From ef0fe2bcc12c95d37a8b537ba1694da22da8ab41 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 21 Mar 2017 11:39:46 +0000 Subject: [PATCH 01/57] Added empty ScalarFV module --- extras/Hadrons/Modules.hpp | 1 + extras/Hadrons/Modules/MScalar/ScalarFV.cc | 40 +++++++++++++++++++ extras/Hadrons/Modules/MScalar/ScalarFV.hpp | 44 +++++++++++++++++++++ extras/Hadrons/modules.inc | 4 +- 4 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 extras/Hadrons/Modules/MScalar/ScalarFV.cc create mode 100644 extras/Hadrons/Modules/MScalar/ScalarFV.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index a25419c5..b482eded 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.cc b/extras/Hadrons/Modules/MScalar/ScalarFV.cc new file mode 100644 index 00000000..26f9f648 --- /dev/null +++ b/extras/Hadrons/Modules/MScalar/ScalarFV.cc @@ -0,0 +1,40 @@ +#include + +using namespace Grid; +using namespace Hadrons; +using namespace MScalar; + +/****************************************************************************** +* TScalarFV implementation * +******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +TScalarFV::TScalarFV(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +std::vector TScalarFV::getInput(void) +{ + std::vector in; + + return in; +} + +std::vector TScalarFV::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +void TScalarFV::setup(void) +{ + +} + +// execution /////////////////////////////////////////////////////////////////// +void TScalarFV::execute(void) +{ + +} diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.hpp b/extras/Hadrons/Modules/MScalar/ScalarFV.hpp new file mode 100644 index 00000000..d350bcae --- /dev/null +++ b/extras/Hadrons/Modules/MScalar/ScalarFV.hpp @@ -0,0 +1,44 @@ +#ifndef Hadrons_ScalarFV_hpp_ +#define Hadrons_ScalarFV_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/****************************************************************************** + * ScalarFV * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MScalar) + +class ScalarFVPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarFVPar, + unsigned int, i); +}; + +class TScalarFV: public Module +{ +public: + // constructor + TScalarFV(const std::string name); + // destructor + virtual ~TScalarFV(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +}; + +MODULE_REGISTER_NS(ScalarFV, TScalarFV, MScalar); + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_ScalarFV_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index dfbe85ff..f368bbdc 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -4,7 +4,8 @@ modules_cc =\ Modules/MGauge/StochEm.cc \ Modules/MGauge/Unit.cc \ Modules/MScalar/ChargedProp.cc \ - Modules/MScalar/FreeProp.cc + Modules/MScalar/FreeProp.cc \ + Modules/MScalar/ScalarFV.cc modules_hpp =\ Modules/MAction/DWF.hpp \ @@ -18,6 +19,7 @@ modules_hpp =\ Modules/MScalar/ChargedProp.hpp \ Modules/MScalar/FreeProp.hpp \ Modules/MScalar/Scalar.hpp \ + Modules/MScalar/ScalarFV.hpp \ Modules/MSolver/RBPrecCG.hpp \ Modules/MSource/Point.hpp \ Modules/MSource/SeqGamma.hpp \ From 54c10a42cc5e5c46e55b4aa8faba6930927e56e1 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 24 Mar 2017 11:42:32 +0000 Subject: [PATCH 02/57] Add source and emField inputs to ScalarFV module --- extras/Hadrons/Modules/MScalar/ScalarFV.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.cc b/extras/Hadrons/Modules/MScalar/ScalarFV.cc index 26f9f648..e7a72abe 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarFV.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarFV.cc @@ -15,7 +15,7 @@ TScalarFV::TScalarFV(const std::string name) // dependencies/products /////////////////////////////////////////////////////// std::vector TScalarFV::getInput(void) { - std::vector in; + std::vector in = {par().source, par().emField}; return in; } From 0c006fbfaac3d47c892fb1305002149d7f7fc31b Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 24 Mar 2017 11:59:09 +0000 Subject: [PATCH 03/57] Add ScalarFV inputs to ScalarFV.hpp --- extras/Hadrons/Modules/MScalar/ScalarFV.hpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.hpp b/extras/Hadrons/Modules/MScalar/ScalarFV.hpp index d350bcae..f7802bda 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarFV.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarFV.hpp @@ -16,6 +16,11 @@ class ScalarFVPar: Serializable { public: GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarFVPar, + std::string, emField, + std::string, source, + double, mass, + double, charge, + std::string, output, unsigned int, i); }; From 85516e9c7c5f1fb3096777e2995a7005f2fbc675 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 24 Mar 2017 17:13:55 +0000 Subject: [PATCH 04/57] Output all terms of scalar propagator separately --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 90 +++++++++++++++---- .../Hadrons/Modules/MScalar/ChargedProp.hpp | 5 +- 2 files changed, 78 insertions(+), 17 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 40d4504c..b76ea8d2 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -23,7 +23,8 @@ std::vector TChargedProp::getInput(void) std::vector TChargedProp::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {getName(), getName()+"_0", getName()+"_D1", + getName()+"_D1D1", getName()+"_D2"}; return out; } @@ -38,6 +39,10 @@ void TChargedProp::setup(void) phaseName_.push_back("_shiftphase_" + std::to_string(mu)); } GFSrcName_ = "_" + getName() + "_DinvSrc"; + prop0Name_ = getName() + "_0"; + propD1Name_ = getName() + "_D1"; + propD1D1Name_ = getName() + "_D1D1"; + propD2Name_ = getName() + "_D2"; if (!env().hasRegisteredObject(freeMomPropName_)) { env().registerLattice(freeMomPropName_); @@ -53,7 +58,14 @@ void TChargedProp::setup(void) { env().registerLattice(GFSrcName_); } + if (!env().hasRegisteredObject(prop0Name_)) + { + env().registerLattice(prop0Name_); + } env().registerLattice(getName()); + env().registerLattice(propD1Name_); + env().registerLattice(propD1D1Name_); + env().registerLattice(propD2Name_); } // execution /////////////////////////////////////////////////////////////////// @@ -64,7 +76,7 @@ void TChargedProp::execute(void) Complex ci(0.0,1.0); FFT fft(env().getGrid()); - // cache free scalar propagator + // cache momentum-space free scalar propagator if (!env().hasCreatedObject(freeMomPropName_)) { LOG(Message) << "Caching momentum space free scalar propagator" @@ -88,6 +100,17 @@ void TChargedProp::execute(void) { GFSrc_ = env().getObject(GFSrcName_); } + // cache free scalar propagator + if (!env().hasCreatedObject(prop0Name_)) + { + prop0_ = env().createLattice(prop0Name_); + *prop0_ = *GFSrc_; + fft.FFT_all_dim(*prop0_, *prop0_, FFT::backward); + } + else + { + prop0_ = env().getObject(prop0Name_); + } // cache phases if (!env().hasCreatedObject(phaseName_[0])) { @@ -117,30 +140,33 @@ void TChargedProp::execute(void) << ", charge= " << par().charge << ")..." << std::endl; ScalarField &prop = *env().createLattice(getName()); + ScalarField &propD1 = *env().createLattice(propD1Name_); + ScalarField &propD1D1 = *env().createLattice(propD1D1Name_); + ScalarField &propD2 = *env().createLattice(propD2Name_); ScalarField buf(env().getGrid()); ScalarField &GFSrc = *GFSrc_, &G = *freeMomProp_; double q = par().charge; - // G*F*Src - prop = GFSrc; - - // - q*G*momD1*G*F*Src (momD1 = F*D1*Finv) + // -G*momD1*G*F*Src (momD1 = F*D1*Finv) buf = GFSrc; momD1(buf, fft); - buf = G*buf; - prop = prop - q*buf; + buf = -G*buf; + fft.FFT_all_dim(propD1, buf, FFT::backward); - // + q^2*G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) + // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) + buf = -buf; momD1(buf, fft); - prop = prop + q*q*G*buf; + propD1D1 = G*buf; + fft.FFT_all_dim(propD1D1, propD1D1, FFT::backward); - // - q^2*G*momD2*G*F*Src (momD2 = F*D2*Finv) + // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); - prop = prop - q*q*G*buf; + buf = -G*buf; + fft.FFT_all_dim(propD2, buf, FFT::backward); - // final FT - fft.FFT_all_dim(prop, prop, FFT::backward); + // full charged scalar propagator + prop = (*prop0_) + q*propD1 + q*q*propD1D1 + q*q*propD2; // OUTPUT IF NECESSARY if (!par().output.empty()) @@ -155,14 +181,48 @@ void TChargedProp::execute(void) std::vector vecBuf; std::vector result; + write(writer, "charge", q); + + // Write full propagator sliceSum(prop, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) { result[t] = TensorRemove(vecBuf[t]); } - write(writer, "charge", q); write(writer, "prop", result); + + // Write free propagator + sliceSum(*prop0_, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_0", result); + + // Write propagator D1 term + sliceSum(propD1, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_D1", result); + + // Write propagator D1D1 term + sliceSum(propD1D1, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_D1D1", result); + + // Write propagator D2 term + sliceSum(propD2, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_D2", result); } } diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index 8bb5faa0..6a6c6c39 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -45,9 +45,10 @@ private: void momD1(ScalarField &s, FFT &fft); void momD2(ScalarField &s, FFT &fft); private: - std::string freeMomPropName_, GFSrcName_; + std::string freeMomPropName_, GFSrcName_, prop0Name_, + propD1Name_, propD1D1Name_, propD2Name_; std::vector phaseName_; - ScalarField *freeMomProp_, *GFSrc_; + ScalarField *freeMomProp_, *GFSrc_, *prop0_; std::vector phase_; EmField *A; }; From 483fd3cfa1e65d894f27b9f04aa14301d644416e Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 27 Mar 2017 13:24:51 +0100 Subject: [PATCH 05/57] Add propagator expansion terms as inputs to ScalarFV --- extras/Hadrons/Modules/MScalar/ScalarFV.cc | 7 ++++++- extras/Hadrons/Modules/MScalar/ScalarFV.hpp | 9 ++++++--- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.cc b/extras/Hadrons/Modules/MScalar/ScalarFV.cc index e7a72abe..2a50a62f 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarFV.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarFV.cc @@ -15,7 +15,12 @@ TScalarFV::TScalarFV(const std::string name) // dependencies/products /////////////////////////////////////////////////////// std::vector TScalarFV::getInput(void) { - std::vector in = {par().source, par().emField}; + std::string prop0Name = par().scalarProp + "_0"; + std::string propD1Name = par().scalarProp + "_D1"; + std::string propD1D1Name = par().scalarProp + "_D1D1"; + std::string propD2Name = par().scalarProp + "_D2"; + std::vector in = {par().source, par().emField, par().scalarProp, + prop0Name, propD1Name, propD1D1Name, propD2Name}; return in; } diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.hpp b/extras/Hadrons/Modules/MScalar/ScalarFV.hpp index f7802bda..fda174db 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarFV.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarFV.hpp @@ -18,14 +18,17 @@ public: GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarFVPar, std::string, emField, std::string, source, - double, mass, + std::string, scalarProp, double, charge, - std::string, output, - unsigned int, i); + std::string, output); }; class TScalarFV: public Module { +public: + SCALAR_TYPE_ALIASES(SIMPL,); + typedef PhotonR::GaugeField EmField; + typedef PhotonR::GaugeLinkField EmComp; public: // constructor TScalarFV(const std::string name); From 4512dbdf584e07acaec4fc86f25985446fc89aa7 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 27 Mar 2017 15:02:16 +0100 Subject: [PATCH 06/57] Rename module ScalarFV to ScalarVP --- extras/Hadrons/Modules.hpp | 2 +- .../MScalar/{ScalarFV.cc => ScalarVP.cc} | 27 ++++++++++--------- .../MScalar/{ScalarFV.hpp => ScalarVP.hpp} | 22 ++++++++------- extras/Hadrons/modules.inc | 4 +-- 4 files changed, 29 insertions(+), 26 deletions(-) rename extras/Hadrons/Modules/MScalar/{ScalarFV.cc => ScalarVP.cc} (54%) rename extras/Hadrons/Modules/MScalar/{ScalarFV.hpp => ScalarVP.hpp} (69%) diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index b482eded..c1d90e3a 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc similarity index 54% rename from extras/Hadrons/Modules/MScalar/ScalarFV.cc rename to extras/Hadrons/Modules/MScalar/ScalarVP.cc index 2a50a62f..dff636dd 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarFV.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -1,31 +1,32 @@ -#include +#include using namespace Grid; using namespace Hadrons; using namespace MScalar; /****************************************************************************** -* TScalarFV implementation * +* TScalarVP implementation * ******************************************************************************/ // constructor ///////////////////////////////////////////////////////////////// -TScalarFV::TScalarFV(const std::string name) -: Module(name) +TScalarVP::TScalarVP(const std::string name) +: Module(name) {} // dependencies/products /////////////////////////////////////////////////////// -std::vector TScalarFV::getInput(void) +std::vector TScalarVP::getInput(void) { - std::string prop0Name = par().scalarProp + "_0"; - std::string propD1Name = par().scalarProp + "_D1"; - std::string propD1D1Name = par().scalarProp + "_D1D1"; - std::string propD2Name = par().scalarProp + "_D2"; + prop0Name_ = par().scalarProp + "_0"; + propD1Name_ = par().scalarProp + "_D1"; + propD1D1Name_ = par().scalarProp + "_D1D1"; + propD2Name_ = par().scalarProp + "_D2"; std::vector in = {par().source, par().emField, par().scalarProp, - prop0Name, propD1Name, propD1D1Name, propD2Name}; + prop0Name_, propD1Name_, propD1D1Name_, + propD2Name_}; return in; } -std::vector TScalarFV::getOutput(void) +std::vector TScalarVP::getOutput(void) { std::vector out = {getName()}; @@ -33,13 +34,13 @@ std::vector TScalarFV::getOutput(void) } // setup /////////////////////////////////////////////////////////////////////// -void TScalarFV::setup(void) +void TScalarVP::setup(void) { } // execution /////////////////////////////////////////////////////////////////// -void TScalarFV::execute(void) +void TScalarVP::execute(void) { } diff --git a/extras/Hadrons/Modules/MScalar/ScalarFV.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp similarity index 69% rename from extras/Hadrons/Modules/MScalar/ScalarFV.hpp rename to extras/Hadrons/Modules/MScalar/ScalarVP.hpp index fda174db..3c3be434 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarFV.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -1,5 +1,5 @@ -#ifndef Hadrons_ScalarFV_hpp_ -#define Hadrons_ScalarFV_hpp_ +#ifndef Hadrons_ScalarVP_hpp_ +#define Hadrons_ScalarVP_hpp_ #include #include @@ -8,14 +8,14 @@ BEGIN_HADRONS_NAMESPACE /****************************************************************************** - * ScalarFV * + * ScalarVP * ******************************************************************************/ BEGIN_MODULE_NAMESPACE(MScalar) -class ScalarFVPar: Serializable +class ScalarVPPar: Serializable { public: - GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarFVPar, + GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarVPPar, std::string, emField, std::string, source, std::string, scalarProp, @@ -23,7 +23,7 @@ public: std::string, output); }; -class TScalarFV: public Module +class TScalarVP: public Module { public: SCALAR_TYPE_ALIASES(SIMPL,); @@ -31,9 +31,9 @@ public: typedef PhotonR::GaugeLinkField EmComp; public: // constructor - TScalarFV(const std::string name); + TScalarVP(const std::string name); // destructor - virtual ~TScalarFV(void) = default; + virtual ~TScalarVP(void) = default; // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); @@ -41,12 +41,14 @@ public: virtual void setup(void); // execution virtual void execute(void); +private: + std::string prop0Name_, propD1Name_, propD1D1Name_, propD2Name_; }; -MODULE_REGISTER_NS(ScalarFV, TScalarFV, MScalar); +MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); END_MODULE_NAMESPACE END_HADRONS_NAMESPACE -#endif // Hadrons_ScalarFV_hpp_ +#endif // Hadrons_ScalarVP_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index f368bbdc..383cb6b5 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -5,7 +5,7 @@ modules_cc =\ Modules/MGauge/Unit.cc \ Modules/MScalar/ChargedProp.cc \ Modules/MScalar/FreeProp.cc \ - Modules/MScalar/ScalarFV.cc + Modules/MScalar/ScalarVP.cc modules_hpp =\ Modules/MAction/DWF.hpp \ @@ -19,7 +19,7 @@ modules_hpp =\ Modules/MScalar/ChargedProp.hpp \ Modules/MScalar/FreeProp.hpp \ Modules/MScalar/Scalar.hpp \ - Modules/MScalar/ScalarFV.hpp \ + Modules/MScalar/ScalarVP.hpp \ Modules/MSolver/RBPrecCG.hpp \ Modules/MSource/Point.hpp \ Modules/MSource/SeqGamma.hpp \ From 9f755e0379e192826a593d758a53124bd28b781a Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 27 Mar 2017 16:49:18 +0100 Subject: [PATCH 07/57] Add functions momD1 and momD2 to ScalarVP --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 68 ++++++++++++++++++++- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 5 ++ 2 files changed, 72 insertions(+), 1 deletion(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index dff636dd..423fb1a2 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -15,7 +15,7 @@ TScalarVP::TScalarVP(const std::string name) // dependencies/products /////////////////////////////////////////////////////// std::vector TScalarVP::getInput(void) { - prop0Name_ = par().scalarProp + "_0"; + prop0Name_ = par().scalarProp + "_0"; propD1Name_ = par().scalarProp + "_D1"; propD1D1Name_ = par().scalarProp + "_D1D1"; propD2Name_ = par().scalarProp + "_D2"; @@ -36,11 +36,77 @@ std::vector TScalarVP::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TScalarVP::setup(void) { + phaseName_.clear(); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + phaseName_.push_back("_shiftphase_" + std::to_string(mu)); + } } // execution /////////////////////////////////////////////////////////////////// void TScalarVP::execute(void) { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + phase_.push_back(env().getObject(phaseName_[mu])); + } } + +void TScalarVP::momD1(ScalarField &s, EmField &A, FFT &fft) +{ + ScalarField buf(env().getGrid()), result(env().getGrid()), + Amu(env().getGrid()); + Complex ci(0.0,1.0); + + result = zero; + + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + Amu = peekLorentz(A, mu); + buf = (*phase_[mu])*s; + fft.FFT_all_dim(buf, buf, FFT::backward); + buf = Amu*buf; + fft.FFT_all_dim(buf, buf, FFT::forward); + result = result - ci*buf; + } + fft.FFT_all_dim(s, s, FFT::backward); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + Amu = peekLorentz(A, mu); + buf = Amu*s; + fft.FFT_all_dim(buf, buf, FFT::forward); + result = result + ci*adj(*phase_[mu])*buf; + } + + s = result; +} + +void TScalarVP::momD2(ScalarField &s, EmField &Asquared, FFT &fft) +{ + ScalarField buf(env().getGrid()), result(env().getGrid()), + A2mu(env().getGrid()); + + result = zero; + + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + A2mu = peekLorentz(Asquared, mu); + buf = (*phase_[mu])*s; + fft.FFT_all_dim(buf, buf, FFT::backward); + buf = A2mu*buf; + fft.FFT_all_dim(buf, buf, FFT::forward); + result = result + .5*buf; + } + fft.FFT_all_dim(s, s, FFT::backward); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + A2mu = peekLorentz(Asquared, mu); + buf = A2mu*s; + fft.FFT_all_dim(buf, buf, FFT::forward); + result = result + .5*adj(*phase_[mu])*buf; + } + + s = result; +} diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 3c3be434..92a4f246 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -41,8 +41,13 @@ public: virtual void setup(void); // execution virtual void execute(void); +private: + void momD1(ScalarField &s, EmField &A, FFT &fft); + void momD2(ScalarField &s, EmField &Asquared, FFT &fft); private: std::string prop0Name_, propD1Name_, propD1D1Name_, propD2Name_; + std::vector phaseName_; + std::vector phase_; }; MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); From 26ebe41fef37d310bba59d378060a26749c1a54b Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 10 Apr 2017 16:33:54 +0100 Subject: [PATCH 08/57] QedFVol: Implement charged propagator calculation within ScalarVP module --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 2 +- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 230 ++++++++++++++++-- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 16 +- 3 files changed, 225 insertions(+), 23 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index b76ea8d2..b68b144d 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -100,7 +100,7 @@ void TChargedProp::execute(void) { GFSrc_ = env().getObject(GFSrcName_); } - // cache free scalar propagator + // cache position-space free scalar propagator if (!env().hasCreatedObject(prop0Name_)) { prop0_ = env().createLattice(prop0Name_); diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 423fb1a2..66cdea7e 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -15,13 +15,7 @@ TScalarVP::TScalarVP(const std::string name) // dependencies/products /////////////////////////////////////////////////////// std::vector TScalarVP::getInput(void) { - prop0Name_ = par().scalarProp + "_0"; - propD1Name_ = par().scalarProp + "_D1"; - propD1D1Name_ = par().scalarProp + "_D1D1"; - propD2Name_ = par().scalarProp + "_D2"; - std::vector in = {par().source, par().emField, par().scalarProp, - prop0Name_, propD1Name_, propD1D1Name_, - propD2Name_}; + std::vector in = {par().source, par().emField}; return in; } @@ -36,26 +30,229 @@ std::vector TScalarVP::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TScalarVP::setup(void) { + freeMomPropName_ = FREEMOMPROP(par().mass); + GFSrcName_ = "_" + getName() + "_DinvSrc"; + prop0Name_ = getName() + "_prop0"; + propQName_ = getName() + "_propQ"; + propSunName_ = getName() + "_propSun"; + propTadName_ = getName() + "_propTad"; + phaseName_.clear(); + muGFSrcName_.clear(); + muProp0Name_.clear(); + muPropQName_.clear(); + muPropSunName_.clear(); + muPropTadName_.clear(); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); + muGFSrcName.push_back("_" + getName() + "_DinvSrc_" + std::to_string(mu)); + muProp0Name_.push_back(getName() + "_prop0_" + std::to_string(mu)); + muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu)); + muPropSunName_.push_back(getName() + "_propSun_" + std::to_string(mu)); + muPropTadName_.push_back(getName() + "_propTad_" + std::to_string(mu)); } + if (!env().hasRegisteredObject(freeMomPropName_)) + { + env().registerLattice(freeMomPropName_); + } + if (!env().hasRegisteredObject(phaseName_[0])) + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + env().registerLattice(phaseName_[mu]); + } + } + if (!env().hasRegisteredObject(GFSrcName_)) + { + env().registerLattice(GFSrcName_); + } + if (!env().hasRegisteredObject(muGFSrcName_[0])) + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + env().registerLattice(muGFSrcName_[mu]); + } + } + if (!env().hasRegisteredObject(prop0Name_)) + { + env().registerLattice(prop0Name_); + } + if (!env().hasRegisteredObject(muProp0Name_[0])) + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + env().registerLattice(muProp0Name_[mu]); + } + } + env().registerLattice(propQName_); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + env().registerLattice(muPropQName_[mu]); + } + env().registerLattice(propSunName_); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + env().registerLattice(muPropSunName_[mu]); + } + env().registerLattice(propTadName_); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + env().registerLattice(muPropTadName_[mu]); + } + env().registerLattice(getName()); } // execution /////////////////////////////////////////////////////////////////// void TScalarVP::execute(void) { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) + // CACHING ANALYTIC EXPRESSIONS + ScalarField &source = *env().getObject(par().source); + Complex ci(0.0,1.0); + FFT fft(env().getGrid()); + + // cache momentum-space free scalar propagator + if (!env().hasCreatedObject(freeMomPropName_)) { - phase_.push_back(env().getObject(phaseName_[mu])); + LOG(Message) << "Caching momentum space free scalar propagator" + << " (mass= " << par().mass << ")..." << std::endl; + freeMomProp_ = env().createLattice(freeMomPropName_); + Scalar::MomentumSpacePropagator(*freeMomProp_, par().mass); + } + else + { + freeMomProp_ = env().getObject(freeMomPropName_); + } + // cache phases + if (!env().hasCreatedObject(phaseName_[0])) + { + std::vector &l = env().getGrid()->_fdimensions; + + LOG(Message) << "Caching shift phases..." << std::endl; + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + Real twoPiL = M_PI*2./l[mu]; + + phase_.push_back(env().createLattice(phaseName_[mu])); + LatticeCoordinate(*(phase_[mu]), mu); + *(phase_[mu]) = exp(ci*twoPiL*(*(phase_[mu]))); + } + } + else + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + phase_.push_back(env().getObject(phaseName_[mu])); + } + } + // cache G*F*src + if (!env().hasCreatedObject(GFSrcName_)) + { + GFSrc_ = env().createLattice(GFSrcName_); + fft.FFT_all_dim(*GFSrc_, source, FFT::forward); + *GFSrc_ = (*freeMomProp_)*(*GFSrc_); + } + else + { + GFSrc_ = env().getObject(GFSrcName_); + } + // cache G*exp(i*k_mu)*F*src + if (!env().hasCreatedObject(muGFSrcName_[0])) + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + muGFSrc_.push_back(env().createLattice(muGFSrcName_[mu])); + fft.FFT_all_dim(*(muGFSrc_[mu]), source, FFT::forward); + *(muGFSrc_[mu]) = (*freeMomProp_)*(*phase_[mu])*(*muGFSrc_[mu]); + } + } + else + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + muGFSrc_.push_back(env().getObject(muGFSrcName_[mu])); + } + } + // cache position-space free scalar propagators + if (!env().hasCreatedObject(prop0Name_)) + { + prop0_ = env().createLattice(prop0Name_); + fft.FFT_all_dim(*prop0_, *GFSrc_, FFT::backward); + } + else + { + prop0_ = env().getObject(prop0Name_); + } + if (!env().hasCreatedObject(muProp0Name_[0])) + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + muProp0_.push_back(env().createLattice(muProp0Name_[mu])); + fft.FFT_all_dim(*(muProp0_[mu]), *(muGFSrc_[mu]), FFT::backward); + } + } + else + { + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + muProp0_.push_back(env().getObject(muProp0Name_[mu])); + } } + // PROPAGATOR CALCULATION + // Propagator from unshifted source + ScalarField &propQ = *env().createLattice(propQName_); + ScalarField &propSun = *env().createLattice(propSunName_); + ScalarField &propTad = *env().createLattice(propTadName_); + chargedProp(propQ, propSun, propTad, *GFSrc_, fft); + + // Propagators from shifted sources + std::vector muPropQ_, muPropSun_, muPropTad_; + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + muPropQ_.push_back(env().createLattice(muPropQName_[mu])); + muPropSun_.push_back(env().createLattice(muPropSunName_[mu])); + muPropTad_.push_back(env().createLattice(muPropTadName_[mu])); + chargedProp(*(muPropQ_[mu]), *(muPropSun_[mu]), *(muPropTad_[mu]), + *(muGFSrc_[mu]), fft); + } + } -void TScalarVP::momD1(ScalarField &s, EmField &A, FFT &fft) +// Calculate O(q) and O(q^2) terms of momentum-space charged propagator +void TScalarVP::chargedProp(ScalarField &prop_q, ScalarField &prop_sun, + ScalarField &prop_tad, ScalarField &GFSrc, + FFT &fft) { + Complex ci(0.0,1.0); + double q = par().charge; + ScalarField &G = *freeMomProp_; + ScalarField buf(env().getGrid()); + + LOG(Message) << "Computing charged scalar propagator" + << " (mass= " << par().mass + << ", charge= " << q << ")..." << std::endl; + + // -q*G*momD1*G*F*Src (momD1 = F*D1*Finv) + buf = GFSrc; + momD1(buf, fft); + buf = G*buf; + prop_q = -q*buf; + + // q*q*G*momD1*G*momD1*G*F*Src + momD1(buf, fft); + prop_sun = q*q*G*buf; + + // -q*q*G*momD2*G*F*Src (momD2 = F*D2*Finv) + buf = GFSrc; + momD2(buf, fft); + prop_tad = -q*q*G*buf; +} + +void TScalarVP::momD1(ScalarField &s, FFT &fft) +{ + EmField &A = *env().getObject(par().emField); ScalarField buf(env().getGrid()), result(env().getGrid()), Amu(env().getGrid()); Complex ci(0.0,1.0); @@ -83,27 +280,28 @@ void TScalarVP::momD1(ScalarField &s, EmField &A, FFT &fft) s = result; } -void TScalarVP::momD2(ScalarField &s, EmField &Asquared, FFT &fft) +void TScalarVP::momD2(ScalarField &s, FFT &fft) { + EmField &A = *env().getObject(par().emField); ScalarField buf(env().getGrid()), result(env().getGrid()), - A2mu(env().getGrid()); + Amu(env().getGrid()); result = zero; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - A2mu = peekLorentz(Asquared, mu); + Amu = peekLorentz(A, mu); buf = (*phase_[mu])*s; fft.FFT_all_dim(buf, buf, FFT::backward); - buf = A2mu*buf; + buf = Amu*Amu*buf; fft.FFT_all_dim(buf, buf, FFT::forward); result = result + .5*buf; } fft.FFT_all_dim(s, s, FFT::backward); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - A2mu = peekLorentz(Asquared, mu); - buf = A2mu*s; + Amu = peekLorentz(A, mu); + buf = Amu*Amu*s; fft.FFT_all_dim(buf, buf, FFT::forward); result = result + .5*adj(*phase_[mu])*buf; } diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 92a4f246..9d57a62a 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -18,7 +18,7 @@ public: GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarVPPar, std::string, emField, std::string, source, - std::string, scalarProp, + double, mass, double, charge, std::string, output); }; @@ -42,12 +42,16 @@ public: // execution virtual void execute(void); private: - void momD1(ScalarField &s, EmField &A, FFT &fft); - void momD2(ScalarField &s, EmField &Asquared, FFT &fft); + void momD1(ScalarField &s, FFT &fft); + void momD2(ScalarField &s, FFT &fft); private: - std::string prop0Name_, propD1Name_, propD1D1Name_, propD2Name_; - std::vector phaseName_; - std::vector phase_; + std::string freeMomPropName_, GFSrcName_, prop0Name_, + propQName_, propSunName_, propTadName_; + std::vector phaseName_, muGFSrcName_, muProp0Name_, + muPropQName, muPropSunName_, muPropTadName_; + ScalarField *freeMomProp_, *GFSrc_, *prop0_; + std::vector phase_, muGFSrc_, muProp0_; + emField *A; }; MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); From c8e6f58e24ac04b0387bafd33334189528212627 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 13 Apr 2017 17:04:37 +0100 Subject: [PATCH 09/57] Fix typos in ScalarVP --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 3 ++- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 7 +++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 66cdea7e..79cc5574 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -1,4 +1,5 @@ #include +#include using namespace Grid; using namespace Hadrons; @@ -46,7 +47,7 @@ void TScalarVP::setup(void) for (unsigned int mu = 0; mu < env().getNd(); ++mu) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); - muGFSrcName.push_back("_" + getName() + "_DinvSrc_" + std::to_string(mu)); + muGFSrcName_.push_back("_" + getName() + "_DinvSrc_" + std::to_string(mu)); muProp0Name_.push_back(getName() + "_prop0_" + std::to_string(mu)); muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu)); muPropSunName_.push_back(getName() + "_propSun_" + std::to_string(mu)); diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 9d57a62a..1a2b82fb 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -42,16 +42,19 @@ public: // execution virtual void execute(void); private: + void chargedProp(ScalarField &prop_q, ScalarField &prop_sun, + ScalarField &prop_tad, ScalarField &GFSrc, + FFT &fft); void momD1(ScalarField &s, FFT &fft); void momD2(ScalarField &s, FFT &fft); private: std::string freeMomPropName_, GFSrcName_, prop0Name_, propQName_, propSunName_, propTadName_; std::vector phaseName_, muGFSrcName_, muProp0Name_, - muPropQName, muPropSunName_, muPropTadName_; + muPropQName_, muPropSunName_, muPropTadName_; ScalarField *freeMomProp_, *GFSrc_, *prop0_; std::vector phase_, muGFSrc_, muProp0_; - emField *A; + EmField *A; }; MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); From bd466a55a89b98c54dbc1287e15feb558a372de4 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 25 Apr 2017 10:04:03 +0100 Subject: [PATCH 10/57] QedFVol: remove charge dependence in chargedProp function of ScalarVP --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 30 ++++++++++++++-------- 1 file changed, 20 insertions(+), 10 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 79cc5574..ed777387 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -23,8 +23,17 @@ std::vector TScalarVP::getInput(void) std::vector TScalarVP::getOutput(void) { - std::vector out = {getName()}; + std::vector out = {getName(), getName()+"_propQ", + getName()+"_propSun", + getName()+"_propTad"}; + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + out.push_back(getName() + "_propQ_" + std::to_string(mu)); + out.push_back(getName() + "_propSun_" + std::to_string(mu)); + out.push_back(getName() + "_propTad_" + std::to_string(mu)); + } + return out; } @@ -112,6 +121,7 @@ void TScalarVP::execute(void) ScalarField &source = *env().getObject(par().source); Complex ci(0.0,1.0); FFT fft(env().getGrid()); + double q = par().charge; // cache momentum-space free scalar propagator if (!env().hasCreatedObject(freeMomPropName_)) @@ -227,28 +237,28 @@ void TScalarVP::chargedProp(ScalarField &prop_q, ScalarField &prop_sun, FFT &fft) { Complex ci(0.0,1.0); - double q = par().charge; - ScalarField &G = *freeMomProp_; + ScalarField &G = *freeMomProp_; ScalarField buf(env().getGrid()); LOG(Message) << "Computing charged scalar propagator" << " (mass= " << par().mass - << ", charge= " << q << ")..." << std::endl; + << ", charge= " << par().charge << ")..." + << std::endl; - // -q*G*momD1*G*F*Src (momD1 = F*D1*Finv) + // -G*momD1*G*F*Src (momD1 = F*D1*Finv) buf = GFSrc; momD1(buf, fft); buf = G*buf; - prop_q = -q*buf; + prop_q = -buf; - // q*q*G*momD1*G*momD1*G*F*Src + // G*momD1*G*momD1*G*F*Src momD1(buf, fft); - prop_sun = q*q*G*buf; + prop_sun = G*buf; - // -q*q*G*momD2*G*F*Src (momD2 = F*D2*Finv) + // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); - prop_tad = -q*q*G*buf; + prop_tad = -G*buf; } void TScalarVP::momD1(ScalarField &s, FFT &fft) From 3ac27e559678f456d512f58670617b26ca1529e5 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 27 Apr 2017 14:17:50 +0100 Subject: [PATCH 11/57] QedFVol: remove unnecessary copies of free propagator from shifted sources in ScalarVP --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 57 ++------------------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 6 +-- 2 files changed, 8 insertions(+), 55 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index ed777387..5a5ef4f0 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -48,16 +48,12 @@ void TScalarVP::setup(void) propTadName_ = getName() + "_propTad"; phaseName_.clear(); - muGFSrcName_.clear(); - muProp0Name_.clear(); muPropQName_.clear(); muPropSunName_.clear(); muPropTadName_.clear(); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); - muGFSrcName_.push_back("_" + getName() + "_DinvSrc_" + std::to_string(mu)); - muProp0Name_.push_back(getName() + "_prop0_" + std::to_string(mu)); muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu)); muPropSunName_.push_back(getName() + "_propSun_" + std::to_string(mu)); muPropTadName_.push_back(getName() + "_propTad_" + std::to_string(mu)); @@ -78,24 +74,10 @@ void TScalarVP::setup(void) { env().registerLattice(GFSrcName_); } - if (!env().hasRegisteredObject(muGFSrcName_[0])) - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - env().registerLattice(muGFSrcName_[mu]); - } - } if (!env().hasRegisteredObject(prop0Name_)) { env().registerLattice(prop0Name_); } - if (!env().hasRegisteredObject(muProp0Name_[0])) - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - env().registerLattice(muProp0Name_[mu]); - } - } env().registerLattice(propQName_); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { @@ -168,23 +150,6 @@ void TScalarVP::execute(void) { GFSrc_ = env().getObject(GFSrcName_); } - // cache G*exp(i*k_mu)*F*src - if (!env().hasCreatedObject(muGFSrcName_[0])) - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - muGFSrc_.push_back(env().createLattice(muGFSrcName_[mu])); - fft.FFT_all_dim(*(muGFSrc_[mu]), source, FFT::forward); - *(muGFSrc_[mu]) = (*freeMomProp_)*(*phase_[mu])*(*muGFSrc_[mu]); - } - } - else - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - muGFSrc_.push_back(env().getObject(muGFSrcName_[mu])); - } - } // cache position-space free scalar propagators if (!env().hasCreatedObject(prop0Name_)) { @@ -195,21 +160,6 @@ void TScalarVP::execute(void) { prop0_ = env().getObject(prop0Name_); } - if (!env().hasCreatedObject(muProp0Name_[0])) - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - muProp0_.push_back(env().createLattice(muProp0Name_[mu])); - fft.FFT_all_dim(*(muProp0_[mu]), *(muGFSrc_[mu]), FFT::backward); - } - } - else - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - muProp0_.push_back(env().getObject(muProp0Name_[mu])); - } - } // PROPAGATOR CALCULATION // Propagator from unshifted source @@ -220,15 +170,18 @@ void TScalarVP::execute(void) // Propagators from shifted sources std::vector muPropQ_, muPropSun_, muPropTad_; + ScalarField buf(env().getGrid()); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { muPropQ_.push_back(env().createLattice(muPropQName_[mu])); muPropSun_.push_back(env().createLattice(muPropSunName_[mu])); muPropTad_.push_back(env().createLattice(muPropTadName_[mu])); + + buf = adj(*phase_[mu])*(*GFSrc_); chargedProp(*(muPropQ_[mu]), *(muPropSun_[mu]), *(muPropTad_[mu]), - *(muGFSrc_[mu]), fft); + buf, fft); } - + } // Calculate O(q) and O(q^2) terms of momentum-space charged propagator diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 1a2b82fb..0d93dc45 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -50,10 +50,10 @@ private: private: std::string freeMomPropName_, GFSrcName_, prop0Name_, propQName_, propSunName_, propTadName_; - std::vector phaseName_, muGFSrcName_, muProp0Name_, - muPropQName_, muPropSunName_, muPropTadName_; + std::vector phaseName_, muPropQName_, muPropSunName_, + muPropTadName_; ScalarField *freeMomProp_, *GFSrc_, *prop0_; - std::vector phase_, muGFSrc_, muProp0_; + std::vector phase_; EmField *A; }; From 2f0dd83016075d7541a0ef86289af64cfae73fed Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 3 May 2017 12:53:41 +0100 Subject: [PATCH 12/57] Calculate HVP using a single contraction of O(alpha) charged propagators. --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 131 ++++++++++++++++++++ extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 18 +-- 2 files changed, 142 insertions(+), 7 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 5a5ef4f0..9689a63f 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -32,6 +32,11 @@ std::vector TScalarVP::getOutput(void) out.push_back(getName() + "_propQ_" + std::to_string(mu)); out.push_back(getName() + "_propSun_" + std::to_string(mu)); out.push_back(getName() + "_propTad_" + std::to_string(mu)); + + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + out.push_back(getName() + "_" + std::to_string(mu) + "_" + std::to_string(nu)); + } } return out; @@ -51,12 +56,22 @@ void TScalarVP::setup(void) muPropQName_.clear(); muPropSunName_.clear(); muPropTadName_.clear(); + vpTensorName_.clear(); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu)); muPropSunName_.push_back(getName() + "_propSun_" + std::to_string(mu)); muPropTadName_.push_back(getName() + "_propTad_" + std::to_string(mu)); + + std::vector vpTensorName_mu; + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + vpTensorName_mu.push_back(getName() + "_" + std::to_string(mu) + + "_" + std::to_string(nu)); + } + vpTensorName_.push_back(vpTensorName_mu); } if (!env().hasRegisteredObject(freeMomPropName_)) @@ -93,6 +108,13 @@ void TScalarVP::setup(void) { env().registerLattice(muPropTadName_[mu]); } + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + env().registerLattice(vpTensorName_[mu][nu]); + } + } env().registerLattice(getName()); } @@ -182,6 +204,115 @@ void TScalarVP::execute(void) buf, fft); } + // CONTRACTIONS + vpTensor_.clear(); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + std::vector vpTensor_mu; + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + vpTensor_mu.push_back(env().createLattice(vpTensorName_[mu][nu])); + } + vpTensor_.push_back(vpTensor_mu); + } + ScalarField prop1(env().getGrid()), prop2(env().getGrid()); + EmField &A = *env().getObject(par().emField); + ScalarField Amu(env().getGrid()); + TComplex Anu0; + std::vector coor0 = {0, 0, 0, 0}; + + // Position-space implementation + prop1 = *GFSrc_ + q*propQ + q*q*propSun + q*q*propTad; + fft.FFT_all_dim(prop1, prop1, FFT::backward); + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + peekSite(Anu0, peekLorentz(A, nu), coor0); + prop2 = adj(*phase_[nu])*(*GFSrc_) + q*(*(muPropQ_[nu])) + + q*q*(*(muPropSun_[nu]) + *(muPropTad_[nu])); + fft.FFT_all_dim(prop2, prop2, FFT::backward); + + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..." + << std::endl; + Amu = peekLorentz(A, mu); + ScalarField &pi_mu_nu = *(vpTensor_[mu][nu]); + pi_mu_nu = adj(prop2) + * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) + * Cshift(prop1, mu, 1) + * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + pi_mu_nu -= Cshift(adj(prop2), mu, 1) + * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) + * prop1 + * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + pi_mu_nu = 2.0*real(pi_mu_nu); + } + } + + // // Momentum-space implementation + // ScalarField propbuf1(env().getGrid()), propbuf2(env().getGrid()); + // prop1 = *GFSrc_ + q*propQ + q*q*propSun + q*q*propTad; + // for (unsigned int nu = 0; nu < env().getNd(); ++nu) + // { + // peekSite(Anu0, peekLorentz(A, nu), coor0); + // prop2 = adj(*phase_[nu])*(*GFSrc_) + q*(*(muPropQ_[nu])) + // + q*q*(*(muPropSun_[nu]) + *(muPropTad_[nu])); + + // for (unsigned int mu = 0; mu < env().getNd(); ++mu) + // { + // LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..." + // << std::endl; + // Amu = peekLorentz(A, mu); + // ScalarField &pi_mu_nu = *(vpTensor_[mu][nu]); + // propbuf1 = (*phase_[mu])*prop1; + // fft.FFT_all_dim(propbuf1, propbuf1, FFT::backward); + // fft.FFT_all_dim(propbuf2, prop2, FFT::backward); + // pi_mu_nu = adj(propbuf2) + // * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) + // * propbuf1 + // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + // propbuf2 = (*phase_[mu])*prop2; + // fft.FFT_all_dim(propbuf1, prop1, FFT::backward); + // fft.FFT_all_dim(propbuf2, propbuf2, FFT::backward); + // pi_mu_nu -= adj(propbuf2) + // * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) + // * propbuf1 + // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + // pi_mu_nu = 2.0*real(pi_mu_nu); + // } + // } + + // OUTPUT IF NECESSARY + if (!par().output.empty()) + { + std::string filename = par().output + "." + + std::to_string(env().getTrajectory()); + + LOG(Message) << "Saving zero-momentum projection to '" + << filename << "'..." << std::endl; + + CorrWriter writer(filename); + std::vector vecBuf; + std::vector result; + + write(writer, "charge", q); + write(writer, "mass", par().mass); + + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + sliceSum(*(vpTensor_[mu][nu]), vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + } + } } // Calculate O(q) and O(q^2) terms of momentum-space charged propagator diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 0d93dc45..fbe73d85 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -48,13 +48,17 @@ private: void momD1(ScalarField &s, FFT &fft); void momD2(ScalarField &s, FFT &fft); private: - std::string freeMomPropName_, GFSrcName_, prop0Name_, - propQName_, propSunName_, propTadName_; - std::vector phaseName_, muPropQName_, muPropSunName_, - muPropTadName_; - ScalarField *freeMomProp_, *GFSrc_, *prop0_; - std::vector phase_; - EmField *A; + std::string freeMomPropName_, GFSrcName_, + prop0Name_, propQName_, + propSunName_, propTadName_; + std::vector phaseName_, muPropQName_, + muPropSunName_, muPropTadName_; + std::vector > vpTensorName_; + ScalarField *freeMomProp_, *GFSrc_, + *prop0_; + std::vector phase_; + std::vector > vpTensor_; + EmField *A; }; MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); From db3837be22a6f654e2da45414a4692886ea38d56 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 3 May 2017 13:26:49 +0100 Subject: [PATCH 13/57] =?UTF-8?q?QedFVol:=20Change=20=E2=80=9Cdouble?= =?UTF-8?q?=E2=80=9D=20to=20=E2=80=9CReal=E2=80=9D=20in=20ScalarVP.cc?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 9689a63f..7745c40e 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -125,7 +125,7 @@ void TScalarVP::execute(void) ScalarField &source = *env().getObject(par().source); Complex ci(0.0,1.0); FFT fft(env().getGrid()); - double q = par().charge; + Real q = par().charge; // cache momentum-space free scalar propagator if (!env().hasCreatedObject(freeMomPropName_)) From 6cb563a40c97c4a443e6f2d5621d7c8c12f5b04e Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 5 May 2017 17:12:41 +0100 Subject: [PATCH 14/57] QedFVol: Access HVP tensor using a vector> instead of vector> --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 64 +++++---------------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 1 - 2 files changed, 15 insertions(+), 50 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 7745c40e..880b3ffd 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -205,15 +205,15 @@ void TScalarVP::execute(void) } // CONTRACTIONS - vpTensor_.clear(); + std::vector > vpTensor; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - std::vector vpTensor_mu; + std::vector vpTensor_mu; for (unsigned int nu = 0; nu < env().getNd(); ++nu) { - vpTensor_mu.push_back(env().createLattice(vpTensorName_[mu][nu])); + vpTensor_mu.push_back(*env().createLattice(vpTensorName_[mu][nu])); } - vpTensor_.push_back(vpTensor_mu); + vpTensor.push_back(vpTensor_mu); } ScalarField prop1(env().getGrid()), prop2(env().getGrid()); EmField &A = *env().getObject(par().emField); @@ -221,7 +221,6 @@ void TScalarVP::execute(void) TComplex Anu0; std::vector coor0 = {0, 0, 0, 0}; - // Position-space implementation prop1 = *GFSrc_ + q*propQ + q*q*propSun + q*q*propTad; fft.FFT_all_dim(prop1, prop1, FFT::backward); for (unsigned int nu = 0; nu < env().getNd(); ++nu) @@ -231,57 +230,24 @@ void TScalarVP::execute(void) + q*q*(*(muPropSun_[nu]) + *(muPropTad_[nu])); fft.FFT_all_dim(prop2, prop2, FFT::backward); + std::vector pi_nu; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..." << std::endl; Amu = peekLorentz(A, mu); - ScalarField &pi_mu_nu = *(vpTensor_[mu][nu]); - pi_mu_nu = adj(prop2) - * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) - * Cshift(prop1, mu, 1) - * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); - pi_mu_nu -= Cshift(adj(prop2), mu, 1) - * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) - * prop1 - * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); - pi_mu_nu = 2.0*real(pi_mu_nu); + vpTensor[mu][nu] = adj(prop2) + * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) + * Cshift(prop1, mu, 1) + * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) + * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) + * prop1 + * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + vpTensor[mu][nu] = 2.0*real(vpTensor[mu][nu]); } } - // // Momentum-space implementation - // ScalarField propbuf1(env().getGrid()), propbuf2(env().getGrid()); - // prop1 = *GFSrc_ + q*propQ + q*q*propSun + q*q*propTad; - // for (unsigned int nu = 0; nu < env().getNd(); ++nu) - // { - // peekSite(Anu0, peekLorentz(A, nu), coor0); - // prop2 = adj(*phase_[nu])*(*GFSrc_) + q*(*(muPropQ_[nu])) - // + q*q*(*(muPropSun_[nu]) + *(muPropTad_[nu])); - - // for (unsigned int mu = 0; mu < env().getNd(); ++mu) - // { - // LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..." - // << std::endl; - // Amu = peekLorentz(A, mu); - // ScalarField &pi_mu_nu = *(vpTensor_[mu][nu]); - // propbuf1 = (*phase_[mu])*prop1; - // fft.FFT_all_dim(propbuf1, propbuf1, FFT::backward); - // fft.FFT_all_dim(propbuf2, prop2, FFT::backward); - // pi_mu_nu = adj(propbuf2) - // * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) - // * propbuf1 - // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); - // propbuf2 = (*phase_[mu])*prop2; - // fft.FFT_all_dim(propbuf1, prop1, FFT::backward); - // fft.FFT_all_dim(propbuf2, propbuf2, FFT::backward); - // pi_mu_nu -= adj(propbuf2) - // * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) - // * propbuf1 - // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); - // pi_mu_nu = 2.0*real(pi_mu_nu); - // } - // } - // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -302,7 +268,7 @@ void TScalarVP::execute(void) { for (unsigned int nu = 0; nu < env().getNd(); ++nu) { - sliceSum(*(vpTensor_[mu][nu]), vecBuf, Tp); + sliceSum(vpTensor[mu][nu], vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) { diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index fbe73d85..9d884575 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -57,7 +57,6 @@ private: ScalarField *freeMomProp_, *GFSrc_, *prop0_; std::vector phase_; - std::vector > vpTensor_; EmField *A; }; From 914f180fa31ca19b0710d393221f56785141b67c Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 9 May 2017 11:46:25 +0100 Subject: [PATCH 15/57] QedFVol: Implement exact O(alpha) vacuum polarisation. --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 119 ++++++++++++++------ extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 3 +- 2 files changed, 85 insertions(+), 37 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 880b3ffd..6e9be923 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -30,8 +30,6 @@ std::vector TScalarVP::getOutput(void) for (unsigned int mu = 0; mu < env().getNd(); ++mu) { out.push_back(getName() + "_propQ_" + std::to_string(mu)); - out.push_back(getName() + "_propSun_" + std::to_string(mu)); - out.push_back(getName() + "_propTad_" + std::to_string(mu)); for (unsigned int nu = 0; nu < env().getNd(); ++nu) { @@ -54,16 +52,12 @@ void TScalarVP::setup(void) phaseName_.clear(); muPropQName_.clear(); - muPropSunName_.clear(); - muPropTadName_.clear(); vpTensorName_.clear(); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu)); - muPropSunName_.push_back(getName() + "_propSun_" + std::to_string(mu)); - muPropTadName_.push_back(getName() + "_propTad_" + std::to_string(mu)); std::vector vpTensorName_mu; for (unsigned int nu = 0; nu < env().getNd(); ++nu) @@ -99,16 +93,8 @@ void TScalarVP::setup(void) env().registerLattice(muPropQName_[mu]); } env().registerLattice(propSunName_); - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - env().registerLattice(muPropSunName_[mu]); - } env().registerLattice(propTadName_); for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - env().registerLattice(muPropTadName_[mu]); - } - for (unsigned int mu = 0; mu < env().getNd(); ++mu) { for (unsigned int nu = 0; nu < env().getNd(); ++nu) { @@ -191,17 +177,16 @@ void TScalarVP::execute(void) chargedProp(propQ, propSun, propTad, *GFSrc_, fft); // Propagators from shifted sources - std::vector muPropQ_, muPropSun_, muPropTad_; - ScalarField buf(env().getGrid()); + std::vector muPropQ; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - muPropQ_.push_back(env().createLattice(muPropQName_[mu])); - muPropSun_.push_back(env().createLattice(muPropSunName_[mu])); - muPropTad_.push_back(env().createLattice(muPropTadName_[mu])); + muPropQ.push_back(*env().createLattice(muPropQName_[mu])); - buf = adj(*phase_[mu])*(*GFSrc_); - chargedProp(*(muPropQ_[mu]), *(muPropSun_[mu]), *(muPropTad_[mu]), - buf, fft); + // -G*momD1*G*F*tau_mu*Src (momD1 = F*D1*Finv) + muPropQ[mu] = adj(*phase_[mu])*(*GFSrc_); + momD1(muPropQ[mu], fft); + muPropQ[mu] = -(*freeMomProp_)*muPropQ[mu]; + fft.FFT_all_dim(muPropQ[mu], muPropQ[mu], FFT::backward); } // CONTRACTIONS @@ -221,33 +206,94 @@ void TScalarVP::execute(void) TComplex Anu0; std::vector coor0 = {0, 0, 0, 0}; - prop1 = *GFSrc_ + q*propQ + q*q*propSun + q*q*propTad; - fft.FFT_all_dim(prop1, prop1, FFT::backward); + // Free VP + + // Charged VP for (unsigned int nu = 0; nu < env().getNd(); ++nu) { peekSite(Anu0, peekLorentz(A, nu), coor0); - prop2 = adj(*phase_[nu])*(*GFSrc_) + q*(*(muPropQ_[nu])) - + q*q*(*(muPropSun_[nu]) + *(muPropTad_[nu])); - fft.FFT_all_dim(prop2, prop2, FFT::backward); - std::vector pi_nu; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..." << std::endl; Amu = peekLorentz(A, mu); - vpTensor[mu][nu] = adj(prop2) - * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) - * Cshift(prop1, mu, 1) - * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + + // "Exchange" terms + prop1 = *prop0_ + q*propQ; + prop2 = Cshift(*prop0_, nu, -1) + q*muPropQ[nu]; + vpTensor[mu][nu] = adj(prop2) * (1.0 + ci*q*Amu) + * Cshift(prop1, mu, 1) * (1.0 + ci*q*Anu0); + vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * (1.0 - ci*q*Amu) + * prop1 * (1.0 + ci*q*Anu0); + + // Subtract O(alpha^2) term + prop1 = q*propQ; + prop2 = q*muPropQ[nu]; + vpTensor[mu][nu] -= adj(prop2) * ci*q*Amu + * Cshift(prop1, mu, 1) * ci*q*Anu0; + vpTensor[mu][nu] += Cshift(adj(prop2), mu, 1) * (-ci)*q*Amu + * prop1 * ci*q*Anu0; + + // Sunset+tadpole from source + prop1 = q*q*(propSun + propTad); + prop2 = Cshift(*prop0_, nu, -1); + vpTensor[mu][nu] += adj(prop2) * Cshift(prop1, mu, 1); + vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * prop1; + + // Sunset+tadpole from shifted source + prop1 = Cshift(prop1, nu, -1); + vpTensor[mu][nu] += Cshift(adj(*prop0_), mu, 1) * prop1; + vpTensor[mu][nu] -= adj(*prop0_) * Cshift(prop1, mu, 1); + + // Source tadpole + prop1 = *prop0_; + vpTensor[mu][nu] += adj(prop2) + * Cshift(prop1, mu, 1) + * (-0.5)*q*q*Anu0*Anu0; vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) - * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) * prop1 - * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + * (-0.5)*q*q*Anu0*Anu0; + + // Sink tadpole + vpTensor[mu][nu] += adj(prop2) + * (-0.5)*q*q*Amu*Amu + * Cshift(prop1, mu, 1); + vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) + * (-0.5)*q*q*Amu*Amu + * prop1; + vpTensor[mu][nu] = 2.0*real(vpTensor[mu][nu]); } } + // prop1 = *GFSrc_ + q*propQ + q*q*propSun + q*q*propTad; + // fft.FFT_all_dim(prop1, prop1, FFT::backward); + // for (unsigned int nu = 0; nu < env().getNd(); ++nu) + // { + // peekSite(Anu0, peekLorentz(A, nu), coor0); + // prop2 = adj(*phase_[nu])*(*GFSrc_) + q*(*(muPropQ_[nu])) + // + q*q*(*(muPropSun_[nu]) + *(muPropTad_[nu])); + // fft.FFT_all_dim(prop2, prop2, FFT::backward); + + // std::vector pi_nu; + // for (unsigned int mu = 0; mu < env().getNd(); ++mu) + // { + // LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..." + // << std::endl; + // Amu = peekLorentz(A, mu); + // vpTensor[mu][nu] = adj(prop2) + // * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) + // * Cshift(prop1, mu, 1) + // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + // vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) + // * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) + // * prop1 + // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); + // vpTensor[mu][nu] = 2.0*real(vpTensor[mu][nu]); + // } + // } + // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -281,7 +327,7 @@ void TScalarVP::execute(void) } } -// Calculate O(q) and O(q^2) terms of momentum-space charged propagator +// Calculate O(q) and O(q^2) terms of position-space charged propagator void TScalarVP::chargedProp(ScalarField &prop_q, ScalarField &prop_sun, ScalarField &prop_tad, ScalarField &GFSrc, FFT &fft) @@ -300,15 +346,18 @@ void TScalarVP::chargedProp(ScalarField &prop_q, ScalarField &prop_sun, momD1(buf, fft); buf = G*buf; prop_q = -buf; + fft.FFT_all_dim(prop_q, prop_q, FFT::backward); // G*momD1*G*momD1*G*F*Src momD1(buf, fft); prop_sun = G*buf; + fft.FFT_all_dim(prop_sun, prop_sun, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); prop_tad = -G*buf; + fft.FFT_all_dim(prop_tad, prop_tad, FFT::backward); } void TScalarVP::momD1(ScalarField &s, FFT &fft) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 9d884575..e0bdd034 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -51,8 +51,7 @@ private: std::string freeMomPropName_, GFSrcName_, prop0Name_, propQName_, propSunName_, propTadName_; - std::vector phaseName_, muPropQName_, - muPropSunName_, muPropTadName_; + std::vector phaseName_, muPropQName_; std::vector > vpTensorName_; ScalarField *freeMomProp_, *GFSrc_, *prop0_; From 5cfc0180aaab83f80c0d8b92d25bbbe97cce57f7 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 9 May 2017 12:46:57 +0100 Subject: [PATCH 16/57] QedFVol: Output free VP along with charged VP. --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 96 ++++++++++----------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 3 +- 2 files changed, 48 insertions(+), 51 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 6e9be923..f6f40700 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -23,7 +23,7 @@ std::vector TScalarVP::getInput(void) std::vector TScalarVP::getOutput(void) { - std::vector out = {getName(), getName()+"_propQ", + std::vector out = {getName()+"_propQ", getName()+"_propSun", getName()+"_propTad"}; @@ -34,6 +34,7 @@ std::vector TScalarVP::getOutput(void) for (unsigned int nu = 0; nu < env().getNd(); ++nu) { out.push_back(getName() + "_" + std::to_string(mu) + "_" + std::to_string(nu)); + out.push_back(getName() + "_free_" + std::to_string(mu) + "_" + std::to_string(nu)); } } @@ -53,6 +54,7 @@ void TScalarVP::setup(void) phaseName_.clear(); muPropQName_.clear(); vpTensorName_.clear(); + freeVpTensorName_.clear(); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { @@ -60,12 +62,16 @@ void TScalarVP::setup(void) muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu)); std::vector vpTensorName_mu; + std::vector freeVpTensorName_mu; for (unsigned int nu = 0; nu < env().getNd(); ++nu) { vpTensorName_mu.push_back(getName() + "_" + std::to_string(mu) + "_" + std::to_string(nu)); + freeVpTensorName_mu.push_back(getName() + "_free_" + std::to_string(mu) + + "_" + std::to_string(nu)); } vpTensorName_.push_back(vpTensorName_mu); + freeVpTensorName_.push_back(freeVpTensorName_mu); } if (!env().hasRegisteredObject(freeMomPropName_)) @@ -90,7 +96,7 @@ void TScalarVP::setup(void) env().registerLattice(propQName_); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - env().registerLattice(muPropQName_[mu]); + env().registerLattice(muPropQName_[mu]); } env().registerLattice(propSunName_); env().registerLattice(propTadName_); @@ -99,9 +105,9 @@ void TScalarVP::setup(void) for (unsigned int nu = 0; nu < env().getNd(); ++nu) { env().registerLattice(vpTensorName_[mu][nu]); + env().registerLattice(freeVpTensorName_[mu][nu]); } } - env().registerLattice(getName()); } // execution /////////////////////////////////////////////////////////////////// @@ -171,12 +177,18 @@ void TScalarVP::execute(void) // PROPAGATOR CALCULATION // Propagator from unshifted source + LOG(Message) << "Computing O(alpha) charged scalar propagator" + << " (mass= " << par().mass + << ", charge= " << q << ")..." + << std::endl; ScalarField &propQ = *env().createLattice(propQName_); ScalarField &propSun = *env().createLattice(propSunName_); ScalarField &propTad = *env().createLattice(propTadName_); chargedProp(propQ, propSun, propTad, *GFSrc_, fft); // Propagators from shifted sources + LOG(Message) << "Computing O(q) charged scalar propagators..." + << std::endl; std::vector muPropQ; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { @@ -190,25 +202,25 @@ void TScalarVP::execute(void) } // CONTRACTIONS - std::vector > vpTensor; - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - std::vector vpTensor_mu; - for (unsigned int nu = 0; nu < env().getNd(); ++nu) - { - vpTensor_mu.push_back(*env().createLattice(vpTensorName_[mu][nu])); - } - vpTensor.push_back(vpTensor_mu); - } ScalarField prop1(env().getGrid()), prop2(env().getGrid()); EmField &A = *env().getObject(par().emField); ScalarField Amu(env().getGrid()); TComplex Anu0; std::vector coor0 = {0, 0, 0, 0}; + std::vector > vpTensor, freeVpTensor; + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + std::vector vpTensor_mu; + std::vector freeVpTensor_mu; + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + vpTensor_mu.push_back(*env().createLattice(vpTensorName_[mu][nu])); + freeVpTensor_mu.push_back(*env().createLattice(freeVpTensorName_[mu][nu])); + } + vpTensor.push_back(vpTensor_mu); + freeVpTensor.push_back(freeVpTensor_mu); + } - // Free VP - - // Charged VP for (unsigned int nu = 0; nu < env().getNd(); ++nu) { peekSite(Anu0, peekLorentz(A, nu), coor0); @@ -219,9 +231,15 @@ void TScalarVP::execute(void) << std::endl; Amu = peekLorentz(A, mu); + // Free VP + prop1 = *prop0_; + prop2 = Cshift(*prop0_, nu, -1); + freeVpTensor[mu][nu] = adj(prop2) * Cshift(prop1, mu, 1); + freeVpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * prop1; + // "Exchange" terms - prop1 = *prop0_ + q*propQ; - prop2 = Cshift(*prop0_, nu, -1) + q*muPropQ[nu]; + prop1 += q*propQ; + prop2 += q*muPropQ[nu]; vpTensor[mu][nu] = adj(prop2) * (1.0 + ci*q*Amu) * Cshift(prop1, mu, 1) * (1.0 + ci*q*Anu0); vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * (1.0 - ci*q*Amu) @@ -267,33 +285,6 @@ void TScalarVP::execute(void) } } - // prop1 = *GFSrc_ + q*propQ + q*q*propSun + q*q*propTad; - // fft.FFT_all_dim(prop1, prop1, FFT::backward); - // for (unsigned int nu = 0; nu < env().getNd(); ++nu) - // { - // peekSite(Anu0, peekLorentz(A, nu), coor0); - // prop2 = adj(*phase_[nu])*(*GFSrc_) + q*(*(muPropQ_[nu])) - // + q*q*(*(muPropSun_[nu]) + *(muPropTad_[nu])); - // fft.FFT_all_dim(prop2, prop2, FFT::backward); - - // std::vector pi_nu; - // for (unsigned int mu = 0; mu < env().getNd(); ++mu) - // { - // LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..." - // << std::endl; - // Amu = peekLorentz(A, mu); - // vpTensor[mu][nu] = adj(prop2) - // * (1.0 + ci*q*Amu - 0.5*q*q*Amu*Amu) - // * Cshift(prop1, mu, 1) - // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); - // vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) - // * (1.0 - ci*q*Amu - 0.5*q*q*Amu*Amu) - // * prop1 - // * (1.0 + ci*q*Anu0 - 0.5*q*q*Anu0*Anu0); - // vpTensor[mu][nu] = 2.0*real(vpTensor[mu][nu]); - // } - // } - // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -322,6 +313,16 @@ void TScalarVP::execute(void) } write(writer, "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), result); + + sliceSum(freeVpTensor[mu][nu], vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, + "Pi_"+std::to_string(mu)+"_"+std::to_string(nu)+"_free", + result); } } } @@ -335,11 +336,6 @@ void TScalarVP::chargedProp(ScalarField &prop_q, ScalarField &prop_sun, Complex ci(0.0,1.0); ScalarField &G = *freeMomProp_; ScalarField buf(env().getGrid()); - - LOG(Message) << "Computing charged scalar propagator" - << " (mass= " << par().mass - << ", charge= " << par().charge << ")..." - << std::endl; // -G*momD1*G*F*Src (momD1 = F*D1*Finv) buf = GFSrc; diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index e0bdd034..4629f6e6 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -52,7 +52,8 @@ private: prop0Name_, propQName_, propSunName_, propTadName_; std::vector phaseName_, muPropQName_; - std::vector > vpTensorName_; + std::vector > vpTensorName_, + freeVpTensorName_; ScalarField *freeMomProp_, *GFSrc_, *prop0_; std::vector phase_; From 009f48a9045c87c13ec2fde2b3630446bd65bbb6 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 7 Jun 2017 16:34:09 +0100 Subject: [PATCH 17/57] QedFVol: Add missing factor of 2 in free vacuum polarisation --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 58 ++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index f6f40700..13591d83 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -185,6 +185,63 @@ void TScalarVP::execute(void) ScalarField &propSun = *env().createLattice(propSunName_); ScalarField &propTad = *env().createLattice(propTadName_); chargedProp(propQ, propSun, propTad, *GFSrc_, fft); + // // OUTPUT IF NECESSARY + // if (!par().output.empty()) + // { + // ScalarField fullProp = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; + // std::string filename = par().output + "_prop_000." + + // std::to_string(env().getTrajectory()); + + // LOG(Message) << "Saving zero-momentum projection to '" + // << filename << "'..." << std::endl; + + // CorrWriter writer(filename); + // std::vector vecBuf; + // std::vector result; + + // write(writer, "charge", q); + + // // Write full propagator + // sliceSum(fullProp, vecBuf, Tp); + // result.resize(vecBuf.size()); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop", result); + + // // Write free propagator + // sliceSum(*prop0_, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_0", result); + + // // Write propagator D1 term + // sliceSum(propD1, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_q", result); + + // // Write propagator D1D1 term + // sliceSum(propD1D1, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_sun", result); + + // // Write propagator D2 term + // sliceSum(propD2, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_tad", result); + // } // Propagators from shifted sources LOG(Message) << "Computing O(q) charged scalar propagators..." @@ -281,6 +338,7 @@ void TScalarVP::execute(void) * (-0.5)*q*q*Amu*Amu * prop1; + freeVpTensor[mu][nu] = 2.0*real(freeVpTensor[mu][nu]); vpTensor[mu][nu] = 2.0*real(vpTensor[mu][nu]); } } From e38612e6fa71c57bf64fca975580a036be021cbb Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 7 Jun 2017 17:42:00 +0100 Subject: [PATCH 18/57] QedFVol: Update ScalarVP module for compatibility with new scalar action --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 2 +- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 13591d83..c91b98ae 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -125,7 +125,7 @@ void TScalarVP::execute(void) LOG(Message) << "Caching momentum space free scalar propagator" << " (mass= " << par().mass << ")..." << std::endl; freeMomProp_ = env().createLattice(freeMomPropName_); - Scalar::MomentumSpacePropagator(*freeMomProp_, par().mass); + SIMPL::MomentumSpacePropagator(*freeMomProp_, par().mass); } else { diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 4629f6e6..fdbad6f6 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -1,5 +1,5 @@ -#ifndef Hadrons_ScalarVP_hpp_ -#define Hadrons_ScalarVP_hpp_ +#ifndef Hadrons_MScalar_ScalarVP_hpp_ +#define Hadrons_MScalar_ScalarVP_hpp_ #include #include @@ -66,4 +66,4 @@ END_MODULE_NAMESPACE END_HADRONS_NAMESPACE -#endif // Hadrons_ScalarVP_hpp_ +#endif // Hadrons_MScalar_ScalarVP_hpp_ From 20ac13fdf36d2d82fd0403b1d92d9771849889d6 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 8 Jun 2017 17:43:39 +0100 Subject: [PATCH 19/57] QedFVol: add ChargedProp as an input to ScalarVP module, instead of calculating scalar propagator within ScalarVP. --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 50 ++-- .../Hadrons/Modules/MScalar/ChargedProp.hpp | 2 +- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 240 ++---------------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 8 +- 4 files changed, 51 insertions(+), 249 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index be64b5ec..a9089056 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -23,8 +23,8 @@ std::vector TChargedProp::getInput(void) std::vector TChargedProp::getOutput(void) { - std::vector out = {getName(), getName()+"_0", getName()+"_D1", - getName()+"_D1D1", getName()+"_D2"}; + std::vector out = {getName(), getName()+"_Q", + getName()+"_Sun", getName()+"_Tad"}; return out; } @@ -40,9 +40,9 @@ void TChargedProp::setup(void) } GFSrcName_ = "_" + getName() + "_DinvSrc"; prop0Name_ = getName() + "_0"; - propD1Name_ = getName() + "_D1"; - propD1D1Name_ = getName() + "_D1D1"; - propD2Name_ = getName() + "_D2"; + propQName_ = getName() + "_Q"; + propSunName_ = getName() + "_Sun"; + propTadName_ = getName() + "_Tad"; if (!env().hasRegisteredObject(freeMomPropName_)) { env().registerLattice(freeMomPropName_); @@ -63,9 +63,9 @@ void TChargedProp::setup(void) env().registerLattice(prop0Name_); } env().registerLattice(getName()); - env().registerLattice(propD1Name_); - env().registerLattice(propD1D1Name_); - env().registerLattice(propD2Name_); + env().registerLattice(propQName_); + env().registerLattice(propSunName_); + env().registerLattice(propTadName_); } // execution /////////////////////////////////////////////////////////////////// @@ -140,9 +140,9 @@ void TChargedProp::execute(void) << ", charge= " << par().charge << ")..." << std::endl; ScalarField &prop = *env().createLattice(getName()); - ScalarField &propD1 = *env().createLattice(propD1Name_); - ScalarField &propD1D1 = *env().createLattice(propD1D1Name_); - ScalarField &propD2 = *env().createLattice(propD2Name_); + ScalarField &propQ = *env().createLattice(propQName_); + ScalarField &propSun = *env().createLattice(propSunName_); + ScalarField &propTad = *env().createLattice(propTadName_); ScalarField buf(env().getGrid()); ScalarField &GFSrc = *GFSrc_, &G = *freeMomProp_; double q = par().charge; @@ -151,22 +151,22 @@ void TChargedProp::execute(void) buf = GFSrc; momD1(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propD1, buf, FFT::backward); + fft.FFT_all_dim(propQ, buf, FFT::backward); // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) buf = -buf; momD1(buf, fft); - propD1D1 = G*buf; - fft.FFT_all_dim(propD1D1, propD1D1, FFT::backward); + propSun = G*buf; + fft.FFT_all_dim(propSun, propSun, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propD2, buf, FFT::backward); + fft.FFT_all_dim(propTad, buf, FFT::backward); // full charged scalar propagator - prop = (*prop0_) + q*propD1 + q*q*propD1D1 + q*q*propD2; + prop = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; // OUTPUT IF NECESSARY if (!par().output.empty()) @@ -200,29 +200,29 @@ void TChargedProp::execute(void) } write(writer, "prop_0", result); - // Write propagator D1 term - sliceSum(propD1, vecBuf, Tp); + // Write propagator O(q) term + sliceSum(propQ, vecBuf, Tp); for (unsigned int t = 0; t < vecBuf.size(); ++t) { result[t] = TensorRemove(vecBuf[t]); } - write(writer, "prop_D1", result); + write(writer, "prop_Q", result); - // Write propagator D1D1 term - sliceSum(propD1D1, vecBuf, Tp); + // Write propagator sunset term + sliceSum(propSun, vecBuf, Tp); for (unsigned int t = 0; t < vecBuf.size(); ++t) { result[t] = TensorRemove(vecBuf[t]); } - write(writer, "prop_D1D1", result); + write(writer, "prop_Sun", result); - // Write propagator D2 term - sliceSum(propD2, vecBuf, Tp); + // Write propagator tadpole term + sliceSum(propTad, vecBuf, Tp); for (unsigned int t = 0; t < vecBuf.size(); ++t) { result[t] = TensorRemove(vecBuf[t]); } - write(writer, "prop_D2", result); + write(writer, "prop_Tad", result); } } diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index aeb92179..369fff30 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -46,7 +46,7 @@ private: void momD2(ScalarField &s, FFT &fft); private: std::string freeMomPropName_, GFSrcName_, prop0Name_, - propD1Name_, propD1D1Name_, propD2Name_; + propQName_, propSunName_, propTadName_; std::vector phaseName_; ScalarField *freeMomProp_, *GFSrc_, *prop0_; std::vector phase_; diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index c91b98ae..7a3b4f9e 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -1,3 +1,4 @@ +#include #include #include @@ -16,16 +17,19 @@ TScalarVP::TScalarVP(const std::string name) // dependencies/products /////////////////////////////////////////////////////// std::vector TScalarVP::getInput(void) { - std::vector in = {par().source, par().emField}; + propQName_ = par().scalarProp + "_Q"; + propSunName_ = par().scalarProp + "_Sun"; + propTadName_ = par().scalarProp + "_Tad"; + + std::vector in = {par().emField, propQName_, propSunName_, + propTadName_}; return in; } std::vector TScalarVP::getOutput(void) { - std::vector out = {getName()+"_propQ", - getName()+"_propSun", - getName()+"_propTad"}; + std::vector out; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { @@ -44,12 +48,9 @@ std::vector TScalarVP::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TScalarVP::setup(void) { - freeMomPropName_ = FREEMOMPROP(par().mass); - GFSrcName_ = "_" + getName() + "_DinvSrc"; - prop0Name_ = getName() + "_prop0"; - propQName_ = getName() + "_propQ"; - propSunName_ = getName() + "_propSun"; - propTadName_ = getName() + "_propTad"; + freeMomPropName_ = FREEMOMPROP(static_cast(env().getModule(par().scalarProp))->par().mass); + GFSrcName_ = "_" + par().scalarProp + "_DinvSrc"; + prop0Name_ = par().scalarProp + "_0"; phaseName_.clear(); muPropQName_.clear(); @@ -74,174 +75,38 @@ void TScalarVP::setup(void) freeVpTensorName_.push_back(freeVpTensorName_mu); } - if (!env().hasRegisteredObject(freeMomPropName_)) - { - env().registerLattice(freeMomPropName_); - } - if (!env().hasRegisteredObject(phaseName_[0])) - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - env().registerLattice(phaseName_[mu]); - } - } - if (!env().hasRegisteredObject(GFSrcName_)) - { - env().registerLattice(GFSrcName_); - } - if (!env().hasRegisteredObject(prop0Name_)) - { - env().registerLattice(prop0Name_); - } - env().registerLattice(propQName_); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { env().registerLattice(muPropQName_[mu]); - } - env().registerLattice(propSunName_); - env().registerLattice(propTadName_); - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { + for (unsigned int nu = 0; nu < env().getNd(); ++nu) { env().registerLattice(vpTensorName_[mu][nu]); env().registerLattice(freeVpTensorName_[mu][nu]); } - } + } } // execution /////////////////////////////////////////////////////////////////// void TScalarVP::execute(void) { - // CACHING ANALYTIC EXPRESSIONS - ScalarField &source = *env().getObject(par().source); + // Get objects cached by ChargedProp module Complex ci(0.0,1.0); FFT fft(env().getGrid()); - Real q = par().charge; + Real q = static_cast(env().getModule(par().scalarProp))->par().charge; - // cache momentum-space free scalar propagator - if (!env().hasCreatedObject(freeMomPropName_)) + freeMomProp_ = env().getObject(freeMomPropName_); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - LOG(Message) << "Caching momentum space free scalar propagator" - << " (mass= " << par().mass << ")..." << std::endl; - freeMomProp_ = env().createLattice(freeMomPropName_); - SIMPL::MomentumSpacePropagator(*freeMomProp_, par().mass); - } - else - { - freeMomProp_ = env().getObject(freeMomPropName_); - } - // cache phases - if (!env().hasCreatedObject(phaseName_[0])) - { - std::vector &l = env().getGrid()->_fdimensions; - - LOG(Message) << "Caching shift phases..." << std::endl; - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - Real twoPiL = M_PI*2./l[mu]; - - phase_.push_back(env().createLattice(phaseName_[mu])); - LatticeCoordinate(*(phase_[mu]), mu); - *(phase_[mu]) = exp(ci*twoPiL*(*(phase_[mu]))); - } - } - else - { - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - phase_.push_back(env().getObject(phaseName_[mu])); - } - } - // cache G*F*src - if (!env().hasCreatedObject(GFSrcName_)) - { - GFSrc_ = env().createLattice(GFSrcName_); - fft.FFT_all_dim(*GFSrc_, source, FFT::forward); - *GFSrc_ = (*freeMomProp_)*(*GFSrc_); - } - else - { - GFSrc_ = env().getObject(GFSrcName_); - } - // cache position-space free scalar propagators - if (!env().hasCreatedObject(prop0Name_)) - { - prop0_ = env().createLattice(prop0Name_); - fft.FFT_all_dim(*prop0_, *GFSrc_, FFT::backward); - } - else - { - prop0_ = env().getObject(prop0Name_); + phase_.push_back(env().getObject(phaseName_[mu])); } + GFSrc_ = env().getObject(GFSrcName_); + prop0_ = env().getObject(prop0Name_); - // PROPAGATOR CALCULATION // Propagator from unshifted source - LOG(Message) << "Computing O(alpha) charged scalar propagator" - << " (mass= " << par().mass - << ", charge= " << q << ")..." - << std::endl; - ScalarField &propQ = *env().createLattice(propQName_); - ScalarField &propSun = *env().createLattice(propSunName_); - ScalarField &propTad = *env().createLattice(propTadName_); - chargedProp(propQ, propSun, propTad, *GFSrc_, fft); - // // OUTPUT IF NECESSARY - // if (!par().output.empty()) - // { - // ScalarField fullProp = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; - // std::string filename = par().output + "_prop_000." + - // std::to_string(env().getTrajectory()); - - // LOG(Message) << "Saving zero-momentum projection to '" - // << filename << "'..." << std::endl; - - // CorrWriter writer(filename); - // std::vector vecBuf; - // std::vector result; - - // write(writer, "charge", q); - - // // Write full propagator - // sliceSum(fullProp, vecBuf, Tp); - // result.resize(vecBuf.size()); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop", result); - - // // Write free propagator - // sliceSum(*prop0_, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_0", result); - - // // Write propagator D1 term - // sliceSum(propD1, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_q", result); - - // // Write propagator D1D1 term - // sliceSum(propD1D1, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_sun", result); - - // // Write propagator D2 term - // sliceSum(propD2, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_tad", result); - // } + ScalarField &propQ = *env().getObject(propQName_); + ScalarField &propSun = *env().getObject(propSunName_); + ScalarField &propTad = *env().getObject(propTadName_); // Propagators from shifted sources LOG(Message) << "Computing O(q) charged scalar propagators..." @@ -357,7 +222,7 @@ void TScalarVP::execute(void) std::vector result; write(writer, "charge", q); - write(writer, "mass", par().mass); + write(writer, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { @@ -386,34 +251,6 @@ void TScalarVP::execute(void) } } -// Calculate O(q) and O(q^2) terms of position-space charged propagator -void TScalarVP::chargedProp(ScalarField &prop_q, ScalarField &prop_sun, - ScalarField &prop_tad, ScalarField &GFSrc, - FFT &fft) -{ - Complex ci(0.0,1.0); - ScalarField &G = *freeMomProp_; - ScalarField buf(env().getGrid()); - - // -G*momD1*G*F*Src (momD1 = F*D1*Finv) - buf = GFSrc; - momD1(buf, fft); - buf = G*buf; - prop_q = -buf; - fft.FFT_all_dim(prop_q, prop_q, FFT::backward); - - // G*momD1*G*momD1*G*F*Src - momD1(buf, fft); - prop_sun = G*buf; - fft.FFT_all_dim(prop_sun, prop_sun, FFT::backward); - - // -G*momD2*G*F*Src (momD2 = F*D2*Finv) - buf = GFSrc; - momD2(buf, fft); - prop_tad = -G*buf; - fft.FFT_all_dim(prop_tad, prop_tad, FFT::backward); -} - void TScalarVP::momD1(ScalarField &s, FFT &fft) { EmField &A = *env().getObject(par().emField); @@ -443,32 +280,3 @@ void TScalarVP::momD1(ScalarField &s, FFT &fft) s = result; } - -void TScalarVP::momD2(ScalarField &s, FFT &fft) -{ - EmField &A = *env().getObject(par().emField); - ScalarField buf(env().getGrid()), result(env().getGrid()), - Amu(env().getGrid()); - - result = zero; - - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - Amu = peekLorentz(A, mu); - buf = (*phase_[mu])*s; - fft.FFT_all_dim(buf, buf, FFT::backward); - buf = Amu*Amu*buf; - fft.FFT_all_dim(buf, buf, FFT::forward); - result = result + .5*buf; - } - fft.FFT_all_dim(s, s, FFT::backward); - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - Amu = peekLorentz(A, mu); - buf = Amu*Amu*s; - fft.FFT_all_dim(buf, buf, FFT::forward); - result = result + .5*adj(*phase_[mu])*buf; - } - - s = result; -} diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index fdbad6f6..81071ca0 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -17,9 +17,7 @@ class ScalarVPPar: Serializable public: GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarVPPar, std::string, emField, - std::string, source, - double, mass, - double, charge, + std::string, scalarProp, std::string, output); }; @@ -42,11 +40,7 @@ public: // execution virtual void execute(void); private: - void chargedProp(ScalarField &prop_q, ScalarField &prop_sun, - ScalarField &prop_tad, ScalarField &GFSrc, - FFT &fft); void momD1(ScalarField &s, FFT &fft); - void momD2(ScalarField &s, FFT &fft); private: std::string freeMomPropName_, GFSrcName_, prop0Name_, propQName_, From 42f0afcbfa7c1ecbaf57380a8722f46d00d892d7 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 9 Jun 2017 18:08:40 +0100 Subject: [PATCH 20/57] QedFVol: Output all scalar VP diagrams separately --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 276 ++++++++++++++++----- 1 file changed, 214 insertions(+), 62 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 7a3b4f9e..19cdbb9a 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -126,7 +126,7 @@ void TScalarVP::execute(void) // CONTRACTIONS ScalarField prop1(env().getGrid()), prop2(env().getGrid()); EmField &A = *env().getObject(par().emField); - ScalarField Amu(env().getGrid()); + ScalarField Amu(env().getGrid()), tmp_vp(env().getGrid()); TComplex Anu0; std::vector coor0 = {0, 0, 0, 0}; std::vector > vpTensor, freeVpTensor; @@ -143,6 +143,33 @@ void TScalarVP::execute(void) freeVpTensor.push_back(freeVpTensor_mu); } + // Open output files if necessary + CorrWriter *writer, *writer0, *writerD; + std::vector vecBuf; + std::vector result; + if (!par().output.empty()) + { + std::string filename = par().output + "." + + std::to_string(env().getTrajectory()); + std::string filename0 = par().output + "_free." + + std::to_string(env().getTrajectory()); + std::string filenameD = par().output + "_diagrams." + + std::to_string(env().getTrajectory()); + + // LOG(Message) << "Saving zero-momentum projection to '" + // << filename << "'..." << std::endl; + writer = new CorrWriter(filename); + writer0 = new CorrWriter(filename0); + writerD = new CorrWriter(filenameD); + + write(*writer, "charge", q); + write(*writer, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + write(*writer0, "charge", 0.0); + write(*writer0, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + write(*writerD, "charge", q); + write(*writerD, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + } + for (unsigned int nu = 0; nu < env().getNd(); ++nu) { peekSite(Anu0, peekLorentz(A, nu), coor0); @@ -158,75 +185,207 @@ void TScalarVP::execute(void) prop2 = Cshift(*prop0_, nu, -1); freeVpTensor[mu][nu] = adj(prop2) * Cshift(prop1, mu, 1); freeVpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * prop1; + freeVpTensor[mu][nu] = 2.0*real(freeVpTensor[mu][nu]); + + // Output if necessary + if (!par().output.empty()) + { + sliceSum(freeVpTensor[mu][nu], vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writer0, + "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } // "Exchange" terms prop1 += q*propQ; prop2 += q*muPropQ[nu]; - vpTensor[mu][nu] = adj(prop2) * (1.0 + ci*q*Amu) - * Cshift(prop1, mu, 1) * (1.0 + ci*q*Anu0); - vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * (1.0 - ci*q*Amu) - * prop1 * (1.0 + ci*q*Anu0); + tmp_vp = adj(prop2) * (1.0 + ci*q*Amu) + * Cshift(prop1, mu, 1) * (1.0 + ci*q*Anu0); + tmp_vp -= Cshift(adj(prop2), mu, 1) * (1.0 - ci*q*Amu) + * prop1 * (1.0 + ci*q*Anu0); + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] = tmp_vp*1.0; + + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_exchange_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } // Subtract O(alpha^2) term prop1 = q*propQ; prop2 = q*muPropQ[nu]; - vpTensor[mu][nu] -= adj(prop2) * ci*q*Amu - * Cshift(prop1, mu, 1) * ci*q*Anu0; - vpTensor[mu][nu] += Cshift(adj(prop2), mu, 1) * (-ci)*q*Amu - * prop1 * ci*q*Anu0; + tmp_vp = Cshift(adj(prop2), mu, 1) * (-ci)*q*Amu + * prop1 * ci*q*Anu0; + tmp_vp -= adj(prop2) * ci*q*Amu + * Cshift(prop1, mu, 1) * ci*q*Anu0; + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] += tmp_vp; - // Sunset+tadpole from source - prop1 = q*q*(propSun + propTad); + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_alpha2_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + + // Sunset from unshifted source + prop1 = q*q*propSun; prop2 = Cshift(*prop0_, nu, -1); - vpTensor[mu][nu] += adj(prop2) * Cshift(prop1, mu, 1); - vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * prop1; + tmp_vp = adj(prop2) * Cshift(prop1, mu, 1); + tmp_vp -= Cshift(adj(prop2), mu, 1) * prop1; + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] += tmp_vp; - // Sunset+tadpole from shifted source + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_sunset_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + + // Sunset from shifted source prop1 = Cshift(prop1, nu, -1); - vpTensor[mu][nu] += Cshift(adj(*prop0_), mu, 1) * prop1; - vpTensor[mu][nu] -= adj(*prop0_) * Cshift(prop1, mu, 1); + tmp_vp = Cshift(adj(*prop0_), mu, 1) * prop1; + tmp_vp -= adj(*prop0_) * Cshift(prop1, mu, 1); + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] += tmp_vp; + + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_sunset_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + + // Tadpole from unshifted source + prop1 = q*q*propTad; + prop2 = Cshift(*prop0_, nu, -1); + tmp_vp = adj(prop2) * Cshift(prop1, mu, 1); + tmp_vp -= Cshift(adj(prop2), mu, 1) * prop1; + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] += tmp_vp; + + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_tadpole_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + + // Tadpole from shifted source + prop1 = Cshift(prop1, nu, -1); + tmp_vp = Cshift(adj(*prop0_), mu, 1) * prop1; + tmp_vp -= adj(*prop0_) * Cshift(prop1, mu, 1); + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] += tmp_vp; + + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_tadpole_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } // Source tadpole prop1 = *prop0_; - vpTensor[mu][nu] += adj(prop2) - * Cshift(prop1, mu, 1) - * (-0.5)*q*q*Anu0*Anu0; - vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) - * prop1 - * (-0.5)*q*q*Anu0*Anu0; + tmp_vp = adj(prop2) + * Cshift(prop1, mu, 1) + * (-0.5)*q*q*Anu0*Anu0; + tmp_vp -= Cshift(adj(prop2), mu, 1) + * prop1 + * (-0.5)*q*q*Anu0*Anu0; + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] += tmp_vp; + + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_sourcetadpole_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } // Sink tadpole - vpTensor[mu][nu] += adj(prop2) - * (-0.5)*q*q*Amu*Amu - * Cshift(prop1, mu, 1); - vpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) - * (-0.5)*q*q*Amu*Amu - * prop1; + tmp_vp = adj(prop2) + * (-0.5)*q*q*Amu*Amu + * Cshift(prop1, mu, 1); + tmp_vp -= Cshift(adj(prop2), mu, 1) + * (-0.5)*q*q*Amu*Amu + * prop1; + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] += tmp_vp; - freeVpTensor[mu][nu] = 2.0*real(freeVpTensor[mu][nu]); - vpTensor[mu][nu] = 2.0*real(vpTensor[mu][nu]); - } - } + // Output if necessary + if (!par().output.empty()) + { + sliceSum(tmp_vp, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD, + "Pi_sinktadpole_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } - // OUTPUT IF NECESSARY - if (!par().output.empty()) - { - std::string filename = par().output + "." + - std::to_string(env().getTrajectory()); - - LOG(Message) << "Saving zero-momentum projection to '" - << filename << "'..." << std::endl; - - CorrWriter writer(filename); - std::vector vecBuf; - std::vector result; - - write(writer, "charge", q); - write(writer, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - for (unsigned int nu = 0; nu < env().getNd(); ++nu) + // Output if necessary + if (!par().output.empty()) { sliceSum(vpTensor[mu][nu], vecBuf, Tp); result.resize(vecBuf.size()); @@ -234,21 +393,14 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(writer, "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - - sliceSum(freeVpTensor[mu][nu], vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, - "Pi_"+std::to_string(mu)+"_"+std::to_string(nu)+"_free", + write(*writer, "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), result); } } } + delete writer; + delete writer0; + delete writerD; } void TScalarVP::momD1(ScalarField &s, FFT &fft) From 20e92a7009fe8c0e5523bd7c4b2d689f600cb5b4 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 12 Jun 2017 18:27:32 +0100 Subject: [PATCH 21/57] QedVFol: Allow output of scalar propagator and vacuum polarisation projected to arbitrary lattice momentum, not just zero-momentum. --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 121 ++++--- .../Hadrons/Modules/MScalar/ChargedProp.hpp | 3 +- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 318 ++++++++++++------ extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 3 +- 4 files changed, 302 insertions(+), 143 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index a9089056..285b237a 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -171,58 +171,91 @@ void TChargedProp::execute(void) // OUTPUT IF NECESSARY if (!par().output.empty()) { - std::string filename = par().output + "." + + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + std::vector mom = strToVec(par().outputMom[i_p]); + std::string filename = par().output + "_" + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]) + + "." + std::to_string(env().getTrajectory()); - - LOG(Message) << "Saving zero-momentum projection to '" + + LOG(Message) << "Saving (" << par().outputMom[i_p] << ") momentum projection to '" << filename << "'..." << std::endl; - - CorrWriter writer(filename); - std::vector vecBuf; - std::vector result; - - write(writer, "charge", q); - // Write full propagator - sliceSum(prop, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop", result); + CorrWriter writer(filename); + std::vector vecBuf; + std::vector result; - // Write free propagator - sliceSum(*prop0_, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_0", result); + write(writer, "charge", q); + write(writer, "mass", par().mass); - // Write propagator O(q) term - sliceSum(propQ, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Q", result); + // Write full propagator + buf = prop; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + buf = buf*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(buf, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop", result); - // Write propagator sunset term - sliceSum(propSun, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Sun", result); + // Write free propagator + buf = *prop0_; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + buf = buf*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_0", result); - // Write propagator tadpole term - sliceSum(propTad, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); + // Write propagator O(q) term + buf = propQ; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + buf = buf*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Q", result); + + // Write propagator sunset term + buf = propSun; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + buf = buf*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Sun", result); + + // Write propagator tadpole term + buf = propTad; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + buf = buf*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Tad", result); } - write(writer, "prop_Tad", result); } } diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index 369fff30..92b89f9f 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -20,7 +20,8 @@ public: std::string, source, double, mass, double, charge, - std::string, output); + std::string, output, + std::vector, outputMom); }; class TChargedProp: public Module diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 19cdbb9a..e4f4e820 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -90,7 +90,7 @@ void TScalarVP::setup(void) // execution /////////////////////////////////////////////////////////////////// void TScalarVP::execute(void) { - // Get objects cached by ChargedProp module + // Get objects cached by ChargedProp module Complex ci(0.0,1.0); FFT fft(env().getGrid()); Real q = static_cast(env().getModule(par().scalarProp))->par().charge; @@ -144,32 +144,49 @@ void TScalarVP::execute(void) } // Open output files if necessary - CorrWriter *writer, *writer0, *writerD; - std::vector vecBuf; - std::vector result; + std::vector writer, writer0, writerD; if (!par().output.empty()) { - std::string filename = par().output + "." + - std::to_string(env().getTrajectory()); - std::string filename0 = par().output + "_free." + - std::to_string(env().getTrajectory()); - std::string filenameD = par().output + "_diagrams." + - std::to_string(env().getTrajectory()); - - // LOG(Message) << "Saving zero-momentum projection to '" - // << filename << "'..." << std::endl; - writer = new CorrWriter(filename); - writer0 = new CorrWriter(filename0); - writerD = new CorrWriter(filenameD); - - write(*writer, "charge", q); - write(*writer, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - write(*writer0, "charge", 0.0); - write(*writer0, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - write(*writerD, "charge", q); - write(*writerD, "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - } + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + std::vector mom = strToVec(par().outputMom[i_p]); + std::string filename = par().output + "_" + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]) + + "." + + std::to_string(env().getTrajectory()); + std::string filename0 = par().output + "_" + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]) + + "_free." + + std::to_string(env().getTrajectory()); + std::string filenameD = par().output + "_" + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]) + + "_diagrams." + + std::to_string(env().getTrajectory()); + + CorrWriter *writer_i = new CorrWriter(filename); + writer.push_back(writer_i); + CorrWriter *writer0_i = new CorrWriter(filename0); + writer0.push_back(writer0_i); + CorrWriter *writerD_i = new CorrWriter(filenameD); + writerD.push_back(writerD_i); + + write(*writer[i_p], "charge", q); + write(*writer[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + write(*writer0[i_p], "charge", 0.0); + write(*writer0[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + write(*writerD[i_p], "charge", q); + write(*writerD[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + } + } + std::vector vecBuf; + std::vector result; + ScalarField vpPhase(env().getGrid()); + + // Do contractions for (unsigned int nu = 0; nu < env().getNd(); ++nu) { peekSite(Anu0, peekLorentz(A, nu), coor0); @@ -190,15 +207,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(freeVpTensor[mu][nu], vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = freeVpTensor[mu][nu]; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writer0[i_p], + "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writer0, - "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // "Exchange" terms @@ -209,20 +236,30 @@ void TScalarVP::execute(void) tmp_vp -= Cshift(adj(prop2), mu, 1) * (1.0 - ci*q*Amu) * prop1 * (1.0 + ci*q*Anu0); tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] = tmp_vp*1.0; + vpTensor[mu][nu] = tmp_vp; // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_exchange_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_exchange_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Subtract O(alpha^2) term @@ -238,15 +275,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_alpha2_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_alpha2_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Sunset from unshifted source @@ -260,15 +307,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_sunset_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_sunset_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Sunset from shifted source @@ -281,15 +338,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_sunset_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_sunset_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Tadpole from unshifted source @@ -303,15 +370,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_tadpole_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_tadpole_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Tadpole from shifted source @@ -324,15 +401,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_tadpole_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_tadpole_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Source tadpole @@ -349,15 +436,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_sourcetadpole_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_sourcetadpole_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Sink tadpole @@ -373,34 +470,61 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - sliceSum(tmp_vp, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writerD[i_p], + "Pi_sinktadpole_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writerD, - "Pi_sinktadpole_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } // Output if necessary if (!par().output.empty()) { - sliceSum(vpTensor[mu][nu], vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + std::vector mom; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - result[t] = TensorRemove(vecBuf[t]); + mom = strToVec(par().outputMom[i_p]); + vpPhase = vpTensor[mu][nu]; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + } + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(*writer[i_p], + "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), + result); } - write(*writer, "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), - result); } } } - delete writer; - delete writer0; - delete writerD; + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + delete writer[i_p]; + delete writer0[i_p]; + delete writerD[i_p]; + } + } } void TScalarVP::momD1(ScalarField &s, FFT &fft) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 81071ca0..e4a6e825 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -18,7 +18,8 @@ public: GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarVPPar, std::string, emField, std::string, scalarProp, - std::string, output); + std::string, output, + std::vector, outputMom); }; class TScalarVP: public Module From cc4afb978d0defaa8e81a5a555fd5ff11c8e8437 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 24 Aug 2017 17:31:44 +0100 Subject: [PATCH 22/57] Fix bug in non-zero momentum projection --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 25 ++++++++-- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 50 +++++++++++++++---- 2 files changed, 60 insertions(+), 15 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 285b237a..1b901bf1 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -194,7 +194,10 @@ void TChargedProp::execute(void) buf = prop; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - buf = buf*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } } sliceSum(buf, vecBuf, Tp); result.resize(vecBuf.size()); @@ -208,7 +211,10 @@ void TChargedProp::execute(void) buf = *prop0_; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - buf = buf*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } } sliceSum(buf, vecBuf, Tp); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -221,7 +227,10 @@ void TChargedProp::execute(void) buf = propQ; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - buf = buf*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } } sliceSum(buf, vecBuf, Tp); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -234,7 +243,10 @@ void TChargedProp::execute(void) buf = propSun; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - buf = buf*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } } sliceSum(buf, vecBuf, Tp); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -247,7 +259,10 @@ void TChargedProp::execute(void) buf = propTad; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - buf = buf*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } } sliceSum(buf, vecBuf, Tp); for (unsigned int t = 0; t < vecBuf.size(); ++t) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index e4f4e820..4d923802 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -214,7 +214,10 @@ void TScalarVP::execute(void) vpPhase = freeVpTensor[mu][nu]; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -248,7 +251,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -282,7 +288,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -314,7 +323,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -345,7 +357,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -377,7 +392,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -408,7 +426,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -443,7 +464,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -477,7 +501,10 @@ void TScalarVP::execute(void) vpPhase = tmp_vp; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); @@ -501,7 +528,10 @@ void TScalarVP::execute(void) vpPhase = vpTensor[mu][nu]; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - vpPhase = vpPhase*pow(adj(*phase_[j]), mom[j]); + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); From 91676d1dda82e0e4779dbe64f0605be3db102142 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 1 Sep 2017 15:48:30 +0100 Subject: [PATCH 23/57] =?UTF-8?q?Fix=20=E2=80=9CMAP=5FANONYMOUS=20undefine?= =?UTF-8?q?d=E2=80=9D=20error=20on=20OSX.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/communicator/Communicator_base.cc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/lib/communicator/Communicator_base.cc b/lib/communicator/Communicator_base.cc index 956de0d2..ba9de1cc 100644 --- a/lib/communicator/Communicator_base.cc +++ b/lib/communicator/Communicator_base.cc @@ -148,6 +148,11 @@ void *CartesianCommunicator::ShmBufferTranslate(int rank,void * local_p) { void CartesianCommunicator::ShmInitGeneric(void){ #if 1 +#if !defined(MAP_ANONYMOUS) + #define NO_MAP_ANONYMOUS + #define MAP_ANONYMOUS MAP_ANON +#endif + int mmap_flag = MAP_SHARED | MAP_ANONYMOUS; #ifdef MAP_HUGETLB if ( Hugepages ) mmap_flag |= MAP_HUGETLB; @@ -162,6 +167,11 @@ void CartesianCommunicator::ShmInitGeneric(void){ ShmCommBuf=(void *)&ShmBufStorageVector[0]; #endif bzero(ShmCommBuf,MAX_MPI_SHM_BYTES); + +#if defined(NO_MAP_ANONYMOUS) + #undef MAP_ANONYMOUS + #undef NO_MAP_ANONYMOUS +#endif } #endif From b99622d9fbdb1a74dec9c5424c214772cdd7845c Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 28 Sep 2017 13:34:33 -0400 Subject: [PATCH 24/57] QedFVol: fix problem with JSON wanting gcc 4.9 --- lib/json/json.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/json/json.hpp b/lib/json/json.hpp index e7c42920..9d589120 100644 --- a/lib/json/json.hpp +++ b/lib/json/json.hpp @@ -63,7 +63,7 @@ SOFTWARE. #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" #endif #elif defined(__GNUC__) - #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40900 + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40805 #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" #endif #endif From a80e43dbcf4b3106f75ee2c35ea56e6145fd4c9b Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 11 Oct 2017 16:44:51 -0400 Subject: [PATCH 25/57] Added infinite-volume photon in Photon.h (not checked yet) --- lib/qcd/action/gauge/Photon.h | 112 +++++++++++++++++++++++++++++----- 1 file changed, 96 insertions(+), 16 deletions(-) diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index 7e21a1de..c8e3109a 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -58,7 +58,7 @@ namespace QCD{ public: INHERIT_GIMPL_TYPES(Gimpl); GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3); - GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2); + GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2, qedInf, 3); public: Photon(Gauge gauge, ZmScheme zmScheme); virtual ~Photon(void) = default; @@ -69,6 +69,7 @@ namespace QCD{ void StochasticField(GaugeField &out, GridParallelRNG &rng, const GaugeLinkField &weight); private: + void infVolPropagator(GaugeLinkField &out); void invKHatSquared(GaugeLinkField &out); void zmSub(GaugeLinkField &out); private: @@ -95,6 +96,32 @@ namespace QCD{ MomentumSpacePropagator(prop_k,in_k); theFFT.FFT_all_dim(out,prop_k,FFT::backward); } + + template + void Photon::infVolPropagator(GaugeLinkField &out) + { + GridBase *grid = out._grid; + GaugeLinkField xmu(grid), one(grid); + const unsigned int nd = grid->_ndimension; + std::vector &l = grid->_fdimensions; + std::vector x0(nd,0); + TComplex Tone = Complex(1.0,0.0); + TComplex Tzero = Complex(0.0,0.0); + FFT fft(grid); + + one = Complex(1.0,0.0); + out = zero; + for(int mu = 0; mu < nd; mu++) + { + LatticeCoordinate(xmu,mu); + xmu = where(xmu < latt_size[mu]/2, xmu, xmu-latt_size[mu]/2); + out = out + 4*M_PI*M_PI*xmu*xmu; + } + pokeSite(Tone, out, x0); + out = one/out; + pokeSite(Tzero, out, x0); + fft.FFT_all_dim(out, out, FFT::forward); + } template void Photon::invKHatSquared(GaugeLinkField &out) @@ -163,13 +190,28 @@ namespace QCD{ void Photon::MomentumSpacePropagator(const GaugeField &in, GaugeField &out) { - GridBase *grid = out._grid; - LatticeComplex k2Inv(grid); + GridBase *grid = out._grid; + LatticeComplex momProp(grid); - invKHatSquared(k2Inv); - zmSub(k2Inv); + switch (zmScheme_) + { + case ZmScheme::qedTL: + case ZmScheme::qedL: + { + invKHatSquared(momProp); + zmSub(momProp); + break; + } + case ZmScheme::qedInf: + { + infVolPropagator(momProp); + break; + } + default: + break; + } - out = in*k2Inv; + out = in*momProp; } template @@ -179,14 +221,30 @@ namespace QCD{ const unsigned int nd = grid->_ndimension; std::vector latt_size = grid->_fdimensions; - Integer vol = 1; - for(int d = 0; d < nd; d++) + switch (zmScheme_) { - vol = vol * latt_size[d]; + case ZmScheme::qedTL: + case ZmScheme::qedL: + { + Integer vol = 1; + for(int d = 0; d < nd; d++) + { + vol = vol * latt_size[d]; + } + invKHatSquared(weight); + weight = sqrt(vol*real(weight)); + zmSub(weight); + break; + } + case ZmScheme::qedInf: + { + infVolPropagator(weight); + weight = sqrt(real(weight)); + break; + } + default: + break; } - invKHatSquared(weight); - weight = sqrt(vol*real(weight)); - zmSub(weight); } template @@ -209,12 +267,34 @@ namespace QCD{ GaugeField aTilde(grid); FFT fft(grid); - for(int mu = 0; mu < nd; mu++) + switch (zmScheme_) { - gaussian(rng, r); - r = weight*r; - pokeLorentz(aTilde, r, mu); + case ZmScheme::qedTL: + case ZmScheme::qedL: + { + for(int mu = 0; mu < nd; mu++) + { + gaussian(rng, r); + r = weight*r; + pokeLorentz(aTilde, r, mu); + } + break; + } + case ZmScheme::qedInf: + { + Complex shift(1., 1.); // This needs to be a GaugeLink element? + for(int mu = 0; mu < nd; mu++) + { + bernoulli(rng, r); + r = weight*(2.*r - shift); + pokeLorentz(aTilde, r, mu); + } + break; + } + default: + break; } + fft.FFT_all_dim(out, aTilde, FFT::backward); out = real(out); From 564738b1ff57810f46e9209840cc5daeb637157b Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 17 Oct 2017 14:03:57 +0100 Subject: [PATCH 26/57] Add module for unit EM field --- extras/Hadrons/Modules.hpp | 1 + extras/Hadrons/Modules/MGauge/UnitEm.cc | 68 ++++++++++++++++++++++++ extras/Hadrons/Modules/MGauge/UnitEm.hpp | 67 +++++++++++++++++++++++ extras/Hadrons/modules.inc | 2 + lib/qcd/action/gauge/Photon.h | 18 +++++++ 5 files changed, 156 insertions(+) create mode 100644 extras/Hadrons/Modules/MGauge/UnitEm.cc create mode 100644 extras/Hadrons/Modules/MGauge/UnitEm.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 4e1e62f7..78bb213d 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.cc b/extras/Hadrons/Modules/MGauge/UnitEm.cc new file mode 100644 index 00000000..906be4cc --- /dev/null +++ b/extras/Hadrons/Modules/MGauge/UnitEm.cc @@ -0,0 +1,68 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MGauge/StochEm.cc + +Copyright (C) 2015 +Copyright (C) 2016 + + +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 + +using namespace Grid; +using namespace Hadrons; +using namespace MGauge; + +/****************************************************************************** +* TStochEm implementation * +******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +TUnitEm::TUnitEm(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +std::vector TUnitEm::getInput(void) +{ + return std::vector(); +} + +std::vector TUnitEm::getOutput(void) +{ + std::vector out = {getName()}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +void TUnitEm::setup(void) +{ + env().registerLattice(getName()); +} + +// execution /////////////////////////////////////////////////////////////////// +void TUnitEm::execute(void) +{ + PhotonR photon(); + EmField &a = *env().createLattice(getName()); + LOG(Message) << "Generating unit EM potential..." << std::endl; + photon.UnitField(a); +} diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.hpp b/extras/Hadrons/Modules/MGauge/UnitEm.hpp new file mode 100644 index 00000000..ea910929 --- /dev/null +++ b/extras/Hadrons/Modules/MGauge/UnitEm.hpp @@ -0,0 +1,67 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: extras/Hadrons/Modules/MGauge/StochEm.hpp + +Copyright (C) 2015 +Copyright (C) 2016 + + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +See the full license in the file "LICENSE" in the top level distribution directory +*************************************************************************************/ +/* END LEGAL */ +#ifndef Hadrons_MGauge_UnitEm_hpp_ +#define Hadrons_MGauge_UnitEm_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/****************************************************************************** + * StochEm * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MGauge) + +class TUnitEm: public Module +{ +public: + typedef PhotonR::GaugeField EmField; + typedef PhotonR::GaugeLinkField EmComp; +public: + // constructor + TUnitEm(const std::string name); + // destructor + virtual ~TUnitEm(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +}; + +MODULE_REGISTER_NS(UnitEm, TUnitEm, MGauge); + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_MGauge_UnitEm_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index 29d63f58..b3c65de0 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -6,6 +6,7 @@ modules_cc =\ Modules/MGauge/Random.cc \ Modules/MGauge/StochEm.cc \ Modules/MGauge/Unit.cc \ + Modules/MGauge/UnitEm.cc \ Modules/MScalar/ChargedProp.cc \ Modules/MScalar/FreeProp.cc \ Modules/MScalar/ScalarVP.cc @@ -26,6 +27,7 @@ modules_hpp =\ Modules/MGauge/Random.hpp \ Modules/MGauge/StochEm.hpp \ Modules/MGauge/Unit.hpp \ + Modules/MGauge/UnitEm.hpp \ Modules/MLoop/NoiseLoop.hpp \ Modules/MScalar/ChargedProp.hpp \ Modules/MScalar/FreeProp.hpp \ diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index 7e21a1de..1429c2ba 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -68,6 +68,7 @@ namespace QCD{ void StochasticField(GaugeField &out, GridParallelRNG &rng); void StochasticField(GaugeField &out, GridParallelRNG &rng, const GaugeLinkField &weight); + void UnitField(GaugeField &out); private: void invKHatSquared(GaugeLinkField &out); void zmSub(GaugeLinkField &out); @@ -219,6 +220,23 @@ namespace QCD{ out = real(out); } + + template + void Photon::UnitField(GaugeField &out) + { + auto *grid = dynamic_cast(out._grid); + const unsigned int nd = grid->_ndimension; + GaugeLinkField r(grid); + + r = Complex(1.0,0.0); + + for(int mu = 0; mu < nd; mu++) + { + pokeLorentz(out, r, mu); + } + + out = real(out); + } // template // void Photon::FeynmanGaugeMomentumSpacePropagator_L(GaugeField &out, // const GaugeField &in) From 98b1439ff9d1f2ebbe5def84d9e792cc12748672 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 20 Oct 2017 16:24:09 +0100 Subject: [PATCH 27/57] QedFVol: pass arbitrary input values to photon constructor in UnitEm --- extras/Hadrons/Modules/MGauge/UnitEm.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.cc b/extras/Hadrons/Modules/MGauge/UnitEm.cc index 906be4cc..f33dfed3 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.cc +++ b/extras/Hadrons/Modules/MGauge/UnitEm.cc @@ -61,7 +61,7 @@ void TUnitEm::setup(void) // execution /////////////////////////////////////////////////////////////////// void TUnitEm::execute(void) { - PhotonR photon(); + PhotonR photon(0, 0); // Just chose arbitrary input values here EmField &a = *env().createLattice(getName()); LOG(Message) << "Generating unit EM potential..." << std::endl; photon.UnitField(a); From c4339397956396c0deeba1ab9638a350183a734e Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 20 Oct 2017 16:27:58 +0100 Subject: [PATCH 28/57] QedFVol: Temporarily remove incomplete implementation of infinite-volume photon --- lib/qcd/action/gauge/Photon.h | 112 +++++----------------------------- 1 file changed, 16 insertions(+), 96 deletions(-) diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index 3744d56a..1429c2ba 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -58,7 +58,7 @@ namespace QCD{ public: INHERIT_GIMPL_TYPES(Gimpl); GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3); - GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2, qedInf, 3); + GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2); public: Photon(Gauge gauge, ZmScheme zmScheme); virtual ~Photon(void) = default; @@ -70,7 +70,6 @@ namespace QCD{ const GaugeLinkField &weight); void UnitField(GaugeField &out); private: - void infVolPropagator(GaugeLinkField &out); void invKHatSquared(GaugeLinkField &out); void zmSub(GaugeLinkField &out); private: @@ -97,32 +96,6 @@ namespace QCD{ MomentumSpacePropagator(prop_k,in_k); theFFT.FFT_all_dim(out,prop_k,FFT::backward); } - - template - void Photon::infVolPropagator(GaugeLinkField &out) - { - GridBase *grid = out._grid; - GaugeLinkField xmu(grid), one(grid); - const unsigned int nd = grid->_ndimension; - std::vector &l = grid->_fdimensions; - std::vector x0(nd,0); - TComplex Tone = Complex(1.0,0.0); - TComplex Tzero = Complex(0.0,0.0); - FFT fft(grid); - - one = Complex(1.0,0.0); - out = zero; - for(int mu = 0; mu < nd; mu++) - { - LatticeCoordinate(xmu,mu); - xmu = where(xmu < latt_size[mu]/2, xmu, xmu-latt_size[mu]/2); - out = out + 4*M_PI*M_PI*xmu*xmu; - } - pokeSite(Tone, out, x0); - out = one/out; - pokeSite(Tzero, out, x0); - fft.FFT_all_dim(out, out, FFT::forward); - } template void Photon::invKHatSquared(GaugeLinkField &out) @@ -191,28 +164,13 @@ namespace QCD{ void Photon::MomentumSpacePropagator(const GaugeField &in, GaugeField &out) { - GridBase *grid = out._grid; - LatticeComplex momProp(grid); + GridBase *grid = out._grid; + LatticeComplex k2Inv(grid); - switch (zmScheme_) - { - case ZmScheme::qedTL: - case ZmScheme::qedL: - { - invKHatSquared(momProp); - zmSub(momProp); - break; - } - case ZmScheme::qedInf: - { - infVolPropagator(momProp); - break; - } - default: - break; - } + invKHatSquared(k2Inv); + zmSub(k2Inv); - out = in*momProp; + out = in*k2Inv; } template @@ -222,30 +180,14 @@ namespace QCD{ const unsigned int nd = grid->_ndimension; std::vector latt_size = grid->_fdimensions; - switch (zmScheme_) + Integer vol = 1; + for(int d = 0; d < nd; d++) { - case ZmScheme::qedTL: - case ZmScheme::qedL: - { - Integer vol = 1; - for(int d = 0; d < nd; d++) - { - vol = vol * latt_size[d]; - } - invKHatSquared(weight); - weight = sqrt(vol*real(weight)); - zmSub(weight); - break; - } - case ZmScheme::qedInf: - { - infVolPropagator(weight); - weight = sqrt(real(weight)); - break; - } - default: - break; + vol = vol * latt_size[d]; } + invKHatSquared(weight); + weight = sqrt(vol*real(weight)); + zmSub(weight); } template @@ -268,34 +210,12 @@ namespace QCD{ GaugeField aTilde(grid); FFT fft(grid); - switch (zmScheme_) + for(int mu = 0; mu < nd; mu++) { - case ZmScheme::qedTL: - case ZmScheme::qedL: - { - for(int mu = 0; mu < nd; mu++) - { - gaussian(rng, r); - r = weight*r; - pokeLorentz(aTilde, r, mu); - } - break; - } - case ZmScheme::qedInf: - { - Complex shift(1., 1.); // This needs to be a GaugeLink element? - for(int mu = 0; mu < nd; mu++) - { - bernoulli(rng, r); - r = weight*(2.*r - shift); - pokeLorentz(aTilde, r, mu); - } - break; - } - default: - break; + gaussian(rng, r); + r = weight*r; + pokeLorentz(aTilde, r, mu); } - fft.FFT_all_dim(out, aTilde, FFT::backward); out = real(out); From b07a354a3394bc30b3c237580d58418a9494717d Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 30 Oct 2017 14:20:44 +0000 Subject: [PATCH 29/57] QedFVol: output scalar propagator before FFT in spatial directions. --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 204 +++++++++++------- 1 file changed, 126 insertions(+), 78 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 1b901bf1..6ffda844 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -151,23 +151,25 @@ void TChargedProp::execute(void) buf = GFSrc; momD1(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propQ, buf, FFT::backward); + fft.FFT_dim(propQ, buf, env().getNd()-1, FFT::backward); // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) buf = -buf; momD1(buf, fft); propSun = G*buf; - fft.FFT_all_dim(propSun, propSun, FFT::backward); + fft.FFT_dim(propSun, propSun, env().getNd()-1, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propTad, buf, FFT::backward); - - // full charged scalar propagator - prop = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; + fft.FFT_dim(propTad, buf, env().getNd()-1, FFT::backward); + // full charged scalar propagator + buf = GFSrc; + fft.FFT_dim(buf, buf, env().getNd()-1, FFT::backward); + prop = buf + q*propQ + q*q*propSun + q*q*propTad; + // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -184,94 +186,140 @@ void TChargedProp::execute(void) << filename << "'..." << std::endl; CorrWriter writer(filename); - std::vector vecBuf; - std::vector result; + // std::vector vecBuf; + std::vector result, result0, resultQ, resultSun, resultTad; + result.resize(env().getGrid()->_ldimensions[env().getNd()-1]); + result0.resize(env().getGrid()->_ldimensions[env().getNd()-1]); + resultQ.resize(env().getGrid()->_ldimensions[env().getNd()-1]); + resultSun.resize(env().getGrid()->_ldimensions[env().getNd()-1]); + resultTad.resize(env().getGrid()->_ldimensions[env().getNd()-1]); write(writer, "charge", q); write(writer, "mass", par().mass); - // Write full propagator - buf = prop; + TComplex site; + std::vector whichmom; + whichmom.resize(env().getNd()); + for (unsigned int j = 0; j < env().getNd()-1; ++j) { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } + whichmom[j] = mom[j]; } - sliceSum(buf, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + + for (unsigned int t = 0; t < env().getGrid()->_ldimensions[env().getNd()-1]; ++t) { - result[t] = TensorRemove(vecBuf[t]); + whichmom[env().getNd()-1] = t; + // Write full propagator + peekSite(site, prop, whichmom); + result[t]=TensorRemove(site); + // Write free propagator + peekSite(site, buf, whichmom); + result0[t]=TensorRemove(site); + // Write propagator O(q) term + peekSite(site, propQ, whichmom); + resultQ[t]=TensorRemove(site); + // Write propagator sunset term + peekSite(site, propSun, whichmom); + resultSun[t]=TensorRemove(site); + // Write propagator tadpole term + peekSite(site, propTad, whichmom); + resultTad[t]=TensorRemove(site); } write(writer, "prop", result); + write(writer, "prop_0", result0); + write(writer, "prop_Q", resultQ); + write(writer, "prop_Sun", resultSun); + write(writer, "prop_Tad", resultTad); - // Write free propagator - buf = *prop0_; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_0", result); + // // Write full propagator + // buf = prop; + // for (unsigned int j = 0; j < env().getNd()-1; ++j) + // { + // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + // { + // buf = buf*adj(*phase_[j]); + // } + // } + // sliceSum(buf, vecBuf, Tp); + // result.resize(vecBuf.size()); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop", result); - // Write propagator O(q) term - buf = propQ; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Q", result); + // // Write free propagator + // buf = *prop0_; + // for (unsigned int j = 0; j < env().getNd()-1; ++j) + // { + // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + // { + // buf = buf*adj(*phase_[j]); + // } + // } + // sliceSum(buf, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_0", result); - // Write propagator sunset term - buf = propSun; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Sun", result); + // // Write propagator O(q) term + // buf = propQ; + // for (unsigned int j = 0; j < env().getNd()-1; ++j) + // { + // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + // { + // buf = buf*adj(*phase_[j]); + // } + // } + // sliceSum(buf, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_Q", result); - // Write propagator tadpole term - buf = propTad; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Tad", result); + // // Write propagator sunset term + // buf = propSun; + // for (unsigned int j = 0; j < env().getNd()-1; ++j) + // { + // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + // { + // buf = buf*adj(*phase_[j]); + // } + // } + // sliceSum(buf, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_Sun", result); + + // // Write propagator tadpole term + // buf = propTad; + // for (unsigned int j = 0; j < env().getNd()-1; ++j) + // { + // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + // { + // buf = buf*adj(*phase_[j]); + // } + // } + // sliceSum(buf, vecBuf, Tp); + // for (unsigned int t = 0; t < vecBuf.size(); ++t) + // { + // result[t] = TensorRemove(vecBuf[t]); + // } + // write(writer, "prop_Tad", result); } } + + std::vector mask(env().getNd(),1); + mask[env().getNd()-1] = 0; + fft.FFT_dim_mask(prop, prop, mask, FFT::backward); + fft.FFT_dim_mask(propQ, propQ, mask, FFT::backward); + fft.FFT_dim_mask(propSun, propSun, mask, FFT::backward); + fft.FFT_dim_mask(propTad, propTad, mask, FFT::backward); } void TChargedProp::momD1(ScalarField &s, FFT &fft) From 0d4e31ca58ff63903b8832838ab7eba3b0f6a4a6 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 30 Oct 2017 15:46:50 +0000 Subject: [PATCH 30/57] QedFVol: Calculate phase factors for momentum projections once per configuration only. --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 81 ----------- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 131 ++++-------------- 2 files changed, 28 insertions(+), 184 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 6ffda844..3aaf3d5e 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -230,87 +230,6 @@ void TChargedProp::execute(void) write(writer, "prop_Q", resultQ); write(writer, "prop_Sun", resultSun); write(writer, "prop_Tad", resultTad); - - // // Write full propagator - // buf = prop; - // for (unsigned int j = 0; j < env().getNd()-1; ++j) - // { - // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - // { - // buf = buf*adj(*phase_[j]); - // } - // } - // sliceSum(buf, vecBuf, Tp); - // result.resize(vecBuf.size()); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop", result); - - // // Write free propagator - // buf = *prop0_; - // for (unsigned int j = 0; j < env().getNd()-1; ++j) - // { - // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - // { - // buf = buf*adj(*phase_[j]); - // } - // } - // sliceSum(buf, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_0", result); - - // // Write propagator O(q) term - // buf = propQ; - // for (unsigned int j = 0; j < env().getNd()-1; ++j) - // { - // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - // { - // buf = buf*adj(*phase_[j]); - // } - // } - // sliceSum(buf, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_Q", result); - - // // Write propagator sunset term - // buf = propSun; - // for (unsigned int j = 0; j < env().getNd()-1; ++j) - // { - // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - // { - // buf = buf*adj(*phase_[j]); - // } - // } - // sliceSum(buf, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_Sun", result); - - // // Write propagator tadpole term - // buf = propTad; - // for (unsigned int j = 0; j < env().getNd()-1; ++j) - // { - // for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - // { - // buf = buf*adj(*phase_[j]); - // } - // } - // sliceSum(buf, vecBuf, Tp); - // for (unsigned int t = 0; t < vecBuf.size(); ++t) - // { - // result[t] = TensorRemove(vecBuf[t]); - // } - // write(writer, "prop_Tad", result); } } diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 4d923802..297a823d 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -144,13 +144,19 @@ void TScalarVP::execute(void) } // Open output files if necessary + std::vector vecBuf; + std::vector result; + ScalarField vpPhase(env().getGrid()); std::vector writer, writer0, writerD; + std::vector momphases; if (!par().output.empty()) { + LOG(Message) << "Preparing output files..." << std::endl; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { std::vector mom = strToVec(par().outputMom[i_p]); + // Open output files std::string filename = par().output + "_" + std::to_string(mom[0]) + std::to_string(mom[1]) + std::to_string(mom[2]) @@ -180,11 +186,20 @@ void TScalarVP::execute(void) write(*writer0[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); write(*writerD[i_p], "charge", q); write(*writerD[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + + // Calculate phase factors + vpPhase = Complex(1.0,0.0); + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*(*phase_[j]); + } + } + vpPhase = adj(vpPhase); + momphases.push_back(vpPhase); } } - std::vector vecBuf; - std::vector result; - ScalarField vpPhase(env().getGrid()); // Do contractions for (unsigned int nu = 0; nu < env().getNd(); ++nu) @@ -207,18 +222,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = freeVpTensor[mu][nu]; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = freeVpTensor[mu][nu]*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -244,18 +250,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -281,18 +278,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -316,18 +304,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -350,18 +329,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -385,18 +355,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -419,18 +380,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -457,18 +409,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -494,18 +437,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -521,18 +455,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = vpTensor[mu][nu]; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = vpTensor[mu][nu]*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) From e0f13495245cfed766448a0c72d522813c426ce2 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 3 Nov 2017 09:22:41 +0000 Subject: [PATCH 31/57] QedFVol: Undo optimisation of charged propagator --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 131 +++++++++++------- 1 file changed, 82 insertions(+), 49 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 3aaf3d5e..1b901bf1 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -151,25 +151,23 @@ void TChargedProp::execute(void) buf = GFSrc; momD1(buf, fft); buf = -G*buf; - fft.FFT_dim(propQ, buf, env().getNd()-1, FFT::backward); + fft.FFT_all_dim(propQ, buf, FFT::backward); // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) buf = -buf; momD1(buf, fft); propSun = G*buf; - fft.FFT_dim(propSun, propSun, env().getNd()-1, FFT::backward); + fft.FFT_all_dim(propSun, propSun, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); buf = -G*buf; - fft.FFT_dim(propTad, buf, env().getNd()-1, FFT::backward); - - // full charged scalar propagator - buf = GFSrc; - fft.FFT_dim(buf, buf, env().getNd()-1, FFT::backward); - prop = buf + q*propQ + q*q*propSun + q*q*propTad; + fft.FFT_all_dim(propTad, buf, FFT::backward); + // full charged scalar propagator + prop = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; + // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -186,59 +184,94 @@ void TChargedProp::execute(void) << filename << "'..." << std::endl; CorrWriter writer(filename); - // std::vector vecBuf; - std::vector result, result0, resultQ, resultSun, resultTad; - result.resize(env().getGrid()->_ldimensions[env().getNd()-1]); - result0.resize(env().getGrid()->_ldimensions[env().getNd()-1]); - resultQ.resize(env().getGrid()->_ldimensions[env().getNd()-1]); - resultSun.resize(env().getGrid()->_ldimensions[env().getNd()-1]); - resultTad.resize(env().getGrid()->_ldimensions[env().getNd()-1]); + std::vector vecBuf; + std::vector result; write(writer, "charge", q); write(writer, "mass", par().mass); - TComplex site; - std::vector whichmom; - whichmom.resize(env().getNd()); - + // Write full propagator + buf = prop; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - whichmom[j] = mom[j]; + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } } - - for (unsigned int t = 0; t < env().getGrid()->_ldimensions[env().getNd()-1]; ++t) + sliceSum(buf, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) { - whichmom[env().getNd()-1] = t; - // Write full propagator - peekSite(site, prop, whichmom); - result[t]=TensorRemove(site); - // Write free propagator - peekSite(site, buf, whichmom); - result0[t]=TensorRemove(site); - // Write propagator O(q) term - peekSite(site, propQ, whichmom); - resultQ[t]=TensorRemove(site); - // Write propagator sunset term - peekSite(site, propSun, whichmom); - resultSun[t]=TensorRemove(site); - // Write propagator tadpole term - peekSite(site, propTad, whichmom); - resultTad[t]=TensorRemove(site); + result[t] = TensorRemove(vecBuf[t]); } write(writer, "prop", result); - write(writer, "prop_0", result0); - write(writer, "prop_Q", resultQ); - write(writer, "prop_Sun", resultSun); - write(writer, "prop_Tad", resultTad); + + // Write free propagator + buf = *prop0_; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_0", result); + + // Write propagator O(q) term + buf = propQ; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Q", result); + + // Write propagator sunset term + buf = propSun; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Sun", result); + + // Write propagator tadpole term + buf = propTad; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Tad", result); } } - - std::vector mask(env().getNd(),1); - mask[env().getNd()-1] = 0; - fft.FFT_dim_mask(prop, prop, mask, FFT::backward); - fft.FFT_dim_mask(propQ, propQ, mask, FFT::backward); - fft.FFT_dim_mask(propSun, propSun, mask, FFT::backward); - fft.FFT_dim_mask(propTad, propTad, mask, FFT::backward); } void TChargedProp::momD1(ScalarField &s, FFT &fft) From c645d33db5a6bab5e3255c0dd2287e7f26bf849c Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 3 Nov 2017 10:59:26 +0000 Subject: [PATCH 32/57] QedFVol: Redo optimisation of charged propagator, and fix I/O bug --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 131 +++++++----------- 1 file changed, 49 insertions(+), 82 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 1b901bf1..cb7e6c79 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -151,23 +151,25 @@ void TChargedProp::execute(void) buf = GFSrc; momD1(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propQ, buf, FFT::backward); + fft.FFT_dim(propQ, buf, env().getNd()-1, FFT::backward); // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) buf = -buf; momD1(buf, fft); propSun = G*buf; - fft.FFT_all_dim(propSun, propSun, FFT::backward); + fft.FFT_dim(propSun, propSun, env().getNd()-1, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propTad, buf, FFT::backward); - - // full charged scalar propagator - prop = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; + fft.FFT_dim(propTad, buf, env().getNd()-1, FFT::backward); + // full charged scalar propagator + buf = GFSrc; + fft.FFT_dim(buf, buf, env().getNd()-1, FFT::backward); + prop = buf + q*propQ + q*q*propSun + q*q*propTad; + // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -184,94 +186,59 @@ void TChargedProp::execute(void) << filename << "'..." << std::endl; CorrWriter writer(filename); - std::vector vecBuf; - std::vector result; + // std::vector vecBuf; + std::vector result, result0, resultQ, resultSun, resultTad; + result.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + result0.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + resultQ.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + resultSun.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + resultTad.resize(env().getGrid()->_fdimensions[env().getNd()-1]); write(writer, "charge", q); write(writer, "mass", par().mass); - // Write full propagator - buf = prop; + TComplex site; + std::vector whichmom; + whichmom.resize(env().getNd()); + for (unsigned int j = 0; j < env().getNd()-1; ++j) { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } + whichmom[j] = mom[j]; } - sliceSum(buf, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + + for (unsigned int t = 0; t < env().getGrid()->_fdimensions[env().getNd()-1]; ++t) { - result[t] = TensorRemove(vecBuf[t]); + whichmom[env().getNd()-1] = t; + // Write full propagator + peekSite(site, prop, whichmom); + result[t]=TensorRemove(site); + // Write free propagator + peekSite(site, buf, whichmom); + result0[t]=TensorRemove(site); + // Write propagator O(q) term + peekSite(site, propQ, whichmom); + resultQ[t]=TensorRemove(site); + // Write propagator sunset term + peekSite(site, propSun, whichmom); + resultSun[t]=TensorRemove(site); + // Write propagator tadpole term + peekSite(site, propTad, whichmom); + resultTad[t]=TensorRemove(site); } write(writer, "prop", result); - - // Write free propagator - buf = *prop0_; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_0", result); - - // Write propagator O(q) term - buf = propQ; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Q", result); - - // Write propagator sunset term - buf = propSun; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Sun", result); - - // Write propagator tadpole term - buf = propTad; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Tad", result); + write(writer, "prop_0", result0); + write(writer, "prop_Q", resultQ); + write(writer, "prop_Sun", resultSun); + write(writer, "prop_Tad", resultTad); } } + + std::vector mask(env().getNd(),1); + mask[env().getNd()-1] = 0; + fft.FFT_dim_mask(prop, prop, mask, FFT::backward); + fft.FFT_dim_mask(propQ, propQ, mask, FFT::backward); + fft.FFT_dim_mask(propSun, propSun, mask, FFT::backward); + fft.FFT_dim_mask(propTad, propTad, mask, FFT::backward); } void TChargedProp::momD1(ScalarField &s, FFT &fft) From 9f2a57e334876d347e8c7d5c8a4eb83228bed9ae Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 3 Nov 2017 13:10:11 +0000 Subject: [PATCH 33/57] QedFVol: Undo optimisation of scalar VP, to reduce memory requirements --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 131 ++++++++++++++++----- 1 file changed, 103 insertions(+), 28 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 297a823d..4d923802 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -144,19 +144,13 @@ void TScalarVP::execute(void) } // Open output files if necessary - std::vector vecBuf; - std::vector result; - ScalarField vpPhase(env().getGrid()); std::vector writer, writer0, writerD; - std::vector momphases; if (!par().output.empty()) { - LOG(Message) << "Preparing output files..." << std::endl; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { std::vector mom = strToVec(par().outputMom[i_p]); - // Open output files std::string filename = par().output + "_" + std::to_string(mom[0]) + std::to_string(mom[1]) + std::to_string(mom[2]) @@ -186,20 +180,11 @@ void TScalarVP::execute(void) write(*writer0[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); write(*writerD[i_p], "charge", q); write(*writerD[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - - // Calculate phase factors - vpPhase = Complex(1.0,0.0); - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*(*phase_[j]); - } - } - vpPhase = adj(vpPhase); - momphases.push_back(vpPhase); } } + std::vector vecBuf; + std::vector result; + ScalarField vpPhase(env().getGrid()); // Do contractions for (unsigned int nu = 0; nu < env().getNd(); ++nu) @@ -222,9 +207,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = freeVpTensor[mu][nu]*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = freeVpTensor[mu][nu]; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -250,9 +244,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -278,9 +281,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -304,9 +316,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -329,9 +350,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -355,9 +385,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -380,9 +419,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -409,9 +457,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -437,9 +494,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = tmp_vp*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = tmp_vp; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -455,9 +521,18 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { + std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = vpTensor[mu][nu]*momphases[i_p]; + mom = strToVec(par().outputMom[i_p]); + vpPhase = vpTensor[mu][nu]; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*adj(*phase_[j]); + } + } sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) From 95af55128e1c85bdc3028b8012c5f169fa2ef379 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 3 Nov 2017 18:46:16 +0000 Subject: [PATCH 34/57] =?UTF-8?q?QedFVol:=20Redo=20optimisation=20of=20sca?= =?UTF-8?q?lar=20VP=20(extra=20memory=20requirements=20were=20not=20the=20?= =?UTF-8?q?problem),=20and=20undo=20optimisation=20of=20charged=20propagat?= =?UTF-8?q?or=20(which=20seemed=20to=20be=20causing=20HDF5=20errors,=20alt?= =?UTF-8?q?hough=20I=20don=E2=80=99t=20know=20why).?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 131 +++++++++++------- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 131 ++++-------------- 2 files changed, 110 insertions(+), 152 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index cb7e6c79..1b901bf1 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -151,25 +151,23 @@ void TChargedProp::execute(void) buf = GFSrc; momD1(buf, fft); buf = -G*buf; - fft.FFT_dim(propQ, buf, env().getNd()-1, FFT::backward); + fft.FFT_all_dim(propQ, buf, FFT::backward); // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) buf = -buf; momD1(buf, fft); propSun = G*buf; - fft.FFT_dim(propSun, propSun, env().getNd()-1, FFT::backward); + fft.FFT_all_dim(propSun, propSun, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); buf = -G*buf; - fft.FFT_dim(propTad, buf, env().getNd()-1, FFT::backward); - - // full charged scalar propagator - buf = GFSrc; - fft.FFT_dim(buf, buf, env().getNd()-1, FFT::backward); - prop = buf + q*propQ + q*q*propSun + q*q*propTad; + fft.FFT_all_dim(propTad, buf, FFT::backward); + // full charged scalar propagator + prop = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; + // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -186,59 +184,94 @@ void TChargedProp::execute(void) << filename << "'..." << std::endl; CorrWriter writer(filename); - // std::vector vecBuf; - std::vector result, result0, resultQ, resultSun, resultTad; - result.resize(env().getGrid()->_fdimensions[env().getNd()-1]); - result0.resize(env().getGrid()->_fdimensions[env().getNd()-1]); - resultQ.resize(env().getGrid()->_fdimensions[env().getNd()-1]); - resultSun.resize(env().getGrid()->_fdimensions[env().getNd()-1]); - resultTad.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + std::vector vecBuf; + std::vector result; write(writer, "charge", q); write(writer, "mass", par().mass); - TComplex site; - std::vector whichmom; - whichmom.resize(env().getNd()); - + // Write full propagator + buf = prop; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - whichmom[j] = mom[j]; + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } } - - for (unsigned int t = 0; t < env().getGrid()->_fdimensions[env().getNd()-1]; ++t) + sliceSum(buf, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) { - whichmom[env().getNd()-1] = t; - // Write full propagator - peekSite(site, prop, whichmom); - result[t]=TensorRemove(site); - // Write free propagator - peekSite(site, buf, whichmom); - result0[t]=TensorRemove(site); - // Write propagator O(q) term - peekSite(site, propQ, whichmom); - resultQ[t]=TensorRemove(site); - // Write propagator sunset term - peekSite(site, propSun, whichmom); - resultSun[t]=TensorRemove(site); - // Write propagator tadpole term - peekSite(site, propTad, whichmom); - resultTad[t]=TensorRemove(site); + result[t] = TensorRemove(vecBuf[t]); } write(writer, "prop", result); - write(writer, "prop_0", result0); - write(writer, "prop_Q", resultQ); - write(writer, "prop_Sun", resultSun); - write(writer, "prop_Tad", resultTad); + + // Write free propagator + buf = *prop0_; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_0", result); + + // Write propagator O(q) term + buf = propQ; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Q", result); + + // Write propagator sunset term + buf = propSun; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Sun", result); + + // Write propagator tadpole term + buf = propTad; + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + buf = buf*adj(*phase_[j]); + } + } + sliceSum(buf, vecBuf, Tp); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + write(writer, "prop_Tad", result); } } - - std::vector mask(env().getNd(),1); - mask[env().getNd()-1] = 0; - fft.FFT_dim_mask(prop, prop, mask, FFT::backward); - fft.FFT_dim_mask(propQ, propQ, mask, FFT::backward); - fft.FFT_dim_mask(propSun, propSun, mask, FFT::backward); - fft.FFT_dim_mask(propTad, propTad, mask, FFT::backward); } void TChargedProp::momD1(ScalarField &s, FFT &fft) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 4d923802..297a823d 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -144,13 +144,19 @@ void TScalarVP::execute(void) } // Open output files if necessary + std::vector vecBuf; + std::vector result; + ScalarField vpPhase(env().getGrid()); std::vector writer, writer0, writerD; + std::vector momphases; if (!par().output.empty()) { + LOG(Message) << "Preparing output files..." << std::endl; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { std::vector mom = strToVec(par().outputMom[i_p]); + // Open output files std::string filename = par().output + "_" + std::to_string(mom[0]) + std::to_string(mom[1]) + std::to_string(mom[2]) @@ -180,11 +186,20 @@ void TScalarVP::execute(void) write(*writer0[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); write(*writerD[i_p], "charge", q); write(*writerD[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + + // Calculate phase factors + vpPhase = Complex(1.0,0.0); + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*(*phase_[j]); + } + } + vpPhase = adj(vpPhase); + momphases.push_back(vpPhase); } } - std::vector vecBuf; - std::vector result; - ScalarField vpPhase(env().getGrid()); // Do contractions for (unsigned int nu = 0; nu < env().getNd(); ++nu) @@ -207,18 +222,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = freeVpTensor[mu][nu]; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = freeVpTensor[mu][nu]*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -244,18 +250,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -281,18 +278,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -316,18 +304,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -350,18 +329,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -385,18 +355,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -419,18 +380,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -457,18 +409,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -494,18 +437,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = tmp_vp; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -521,18 +455,9 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - std::vector mom; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - mom = strToVec(par().outputMom[i_p]); - vpPhase = vpTensor[mu][nu]; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - vpPhase = vpPhase*adj(*phase_[j]); - } - } + vpPhase = vpTensor[mu][nu]*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) From 840814c7769b33c2a6af28e68d85f5517866289c Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 6 Nov 2017 16:34:55 +0000 Subject: [PATCH 35/57] QedFVol: Patch to fix MPI communicators error --- lib/communicator/Communicator_mpi.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/communicator/Communicator_mpi.cc b/lib/communicator/Communicator_mpi.cc index ef612f98..e123aaa4 100644 --- a/lib/communicator/Communicator_mpi.cc +++ b/lib/communicator/Communicator_mpi.cc @@ -55,9 +55,9 @@ void CartesianCommunicator::Init(int *argc, char ***argv) { CartesianCommunicator::~CartesianCommunicator() { - int MPI_is_finalised; - MPI_Finalized(&MPI_is_finalised); - if (communicator && MPI_is_finalised) + // int MPI_is_finalised; + // MPI_Finalized(&MPI_is_finalised); + if (communicator && !MPI::Is_finalized()) MPI_Comm_free(&communicator); } From 0c668bf46aabe20421227d59fe347c1828fa8932 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 7 Nov 2017 14:46:39 +0000 Subject: [PATCH 36/57] QedFVol: Write to output files from one process only. --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 136 +++++++----------- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 126 ++++++++++------ 2 files changed, 134 insertions(+), 128 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 1b901bf1..33c3d4dd 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -151,23 +151,25 @@ void TChargedProp::execute(void) buf = GFSrc; momD1(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propQ, buf, FFT::backward); + fft.FFT_dim(propQ, buf, env().getNd()-1, FFT::backward); // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) buf = -buf; momD1(buf, fft); propSun = G*buf; - fft.FFT_all_dim(propSun, propSun, FFT::backward); + fft.FFT_dim(propSun, propSun, env().getNd()-1, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) buf = GFSrc; momD2(buf, fft); buf = -G*buf; - fft.FFT_all_dim(propTad, buf, FFT::backward); - - // full charged scalar propagator - prop = (*prop0_) + q*propQ + q*q*propSun + q*q*propTad; + fft.FFT_dim(propTad, buf, env().getNd()-1, FFT::backward); + // full charged scalar propagator + buf = GFSrc; + fft.FFT_dim(buf, buf, env().getNd()-1, FFT::backward); + prop = buf + q*propQ + q*q*propSun + q*q*propTad; + // OUTPUT IF NECESSARY if (!par().output.empty()) { @@ -183,95 +185,63 @@ void TChargedProp::execute(void) LOG(Message) << "Saving (" << par().outputMom[i_p] << ") momentum projection to '" << filename << "'..." << std::endl; - CorrWriter writer(filename); - std::vector vecBuf; - std::vector result; + // std::vector vecBuf; + std::vector result, result0, resultQ, resultSun, resultTad; + result.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + result0.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + resultQ.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + resultSun.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + resultTad.resize(env().getGrid()->_fdimensions[env().getNd()-1]); - write(writer, "charge", q); - write(writer, "mass", par().mass); + TComplex site; + std::vector whichmom; + whichmom.resize(env().getNd()); - // Write full propagator - buf = prop; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } + whichmom[j] = mom[j]; } - sliceSum(buf, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop", result); - // Write free propagator - buf = *prop0_; - for (unsigned int j = 0; j < env().getNd()-1; ++j) + for (unsigned int t = 0; t < env().getGrid()->_fdimensions[env().getNd()-1]; ++t) { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } + whichmom[env().getNd()-1] = t; + // Write full propagator + peekSite(site, prop, whichmom); + result[t]=TensorRemove(site); + // Write free propagator + peekSite(site, buf, whichmom); + result0[t]=TensorRemove(site); + // Write propagator O(q) term + peekSite(site, propQ, whichmom); + resultQ[t]=TensorRemove(site); + // Write propagator sunset term + peekSite(site, propSun, whichmom); + resultSun[t]=TensorRemove(site); + // Write propagator tadpole term + peekSite(site, propTad, whichmom); + resultTad[t]=TensorRemove(site); } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) + + if (env().getGrid()->IsBoss()) { - result[t] = TensorRemove(vecBuf[t]); + CorrWriter writer(filename); + write(writer, "charge", q); + write(writer, "mass", par().mass); + write(writer, "prop", result); + write(writer, "prop_0", result0); + write(writer, "prop_Q", resultQ); + write(writer, "prop_Sun", resultSun); + write(writer, "prop_Tad", resultTad); } - write(writer, "prop_0", result); - - // Write propagator O(q) term - buf = propQ; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Q", result); - - // Write propagator sunset term - buf = propSun; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Sun", result); - - // Write propagator tadpole term - buf = propTad; - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - buf = buf*adj(*phase_[j]); - } - } - sliceSum(buf, vecBuf, Tp); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(writer, "prop_Tad", result); } } + + std::vector mask(env().getNd(),1); + mask[env().getNd()-1] = 0; + fft.FFT_dim_mask(prop, prop, mask, FFT::backward); + fft.FFT_dim_mask(propQ, propQ, mask, FFT::backward); + fft.FFT_dim_mask(propSun, propSun, mask, FFT::backward); + fft.FFT_dim_mask(propTad, propTad, mask, FFT::backward); } void TChargedProp::momD1(ScalarField &s, FFT &fft) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 297a823d..b8cdb7e3 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -173,19 +173,22 @@ void TScalarVP::execute(void) + "_diagrams." + std::to_string(env().getTrajectory()); - CorrWriter *writer_i = new CorrWriter(filename); - writer.push_back(writer_i); - CorrWriter *writer0_i = new CorrWriter(filename0); - writer0.push_back(writer0_i); - CorrWriter *writerD_i = new CorrWriter(filenameD); - writerD.push_back(writerD_i); + if (env().getGrid()->IsBoss()) + { + CorrWriter *writer_i = new CorrWriter(filename); + writer.push_back(writer_i); + CorrWriter *writer0_i = new CorrWriter(filename0); + writer0.push_back(writer0_i); + CorrWriter *writerD_i = new CorrWriter(filenameD); + writerD.push_back(writerD_i); - write(*writer[i_p], "charge", q); - write(*writer[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - write(*writer0[i_p], "charge", 0.0); - write(*writer0[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - write(*writerD[i_p], "charge", q); - write(*writerD[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + write(*writer[i_p], "charge", q); + write(*writer[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + write(*writer0[i_p], "charge", 0.0); + write(*writer0[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + write(*writerD[i_p], "charge", q); + write(*writerD[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); + } // Calculate phase factors vpPhase = Complex(1.0,0.0); @@ -231,9 +234,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writer0[i_p], - "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writer0[i_p], + "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -259,9 +265,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_exchange_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_exchange_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -287,9 +296,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_alpha2_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_alpha2_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -313,9 +325,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_sunset_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_sunset_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -338,9 +353,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_sunset_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_sunset_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -364,9 +382,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_tadpole_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_tadpole_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -389,9 +410,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_tadpole_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_tadpole_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -418,9 +442,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_sourcetadpole_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_sourcetadpole_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -446,9 +473,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writerD[i_p], - "Pi_sinktadpole_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writerD[i_p], + "Pi_sinktadpole_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } @@ -464,9 +494,12 @@ void TScalarVP::execute(void) { result[t] = TensorRemove(vecBuf[t]); } - write(*writer[i_p], - "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), - result); + if (env().getGrid()->IsBoss()) + { + write(*writer[i_p], + "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } } } } @@ -475,9 +508,12 @@ void TScalarVP::execute(void) { for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - delete writer[i_p]; - delete writer0[i_p]; - delete writerD[i_p]; + if (env().getGrid()->IsBoss()) + { + delete writer[i_p]; + delete writer0[i_p]; + delete writerD[i_p]; + } } } } From 6bc136b1d0b9e5308ce531f67273a525b0549990 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 13 Dec 2017 17:31:01 +0000 Subject: [PATCH 37/57] Add module for calculating diagrams required for HVP counter-terms --- extras/Hadrons/Modules.hpp | 1 + .../Hadrons/Modules/MScalar/VPCounterTerms.cc | 257 ++++++++++++++++++ .../Modules/MScalar/VPCounterTerms.hpp | 55 ++++ extras/Hadrons/modules.inc | 4 +- 4 files changed, 316 insertions(+), 1 deletion(-) create mode 100644 extras/Hadrons/Modules/MScalar/VPCounterTerms.cc create mode 100644 extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp diff --git a/extras/Hadrons/Modules.hpp b/extras/Hadrons/Modules.hpp index 78bb213d..1aa4b74d 100644 --- a/extras/Hadrons/Modules.hpp +++ b/extras/Hadrons/Modules.hpp @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include diff --git a/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc b/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc new file mode 100644 index 00000000..17dd1abe --- /dev/null +++ b/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc @@ -0,0 +1,257 @@ +#include +#include + +using namespace Grid; +using namespace Hadrons; +using namespace MScalar; + +/****************************************************************************** +* TVPCounterTerms implementation * +******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +TVPCounterTerms::TVPCounterTerms(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +std::vector TVPCounterTerms::getInput(void) +{ + std::vector in = {par().source}; + + return in; +} + +std::vector TVPCounterTerms::getOutput(void) +{ + std::vector out; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +void TVPCounterTerms::setup(void) +{ + freeMomPropName_ = FREEMOMPROP(par().mass); + phaseName_.clear(); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + phaseName_.push_back("_shiftphase_" + std::to_string(mu)); + } + GFSrcName_ = "_" + getName() + "_DinvSrc"; + phatsqName_ = "_" + getName() + "_pHatSquared"; + prop0Name_ = getName() + "_freeProp"; + twoscalarName_ = getName() + "_2scalarProp"; + twoscalarVertexName_ = getName() + "_2scalarProp_withvertex"; + psquaredName_ = getName() + "_psquaredProp"; + env().registerLattice(freeMomPropName_); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + env().registerLattice(phaseName_[mu]); + } + env().registerLattice(phatsqName_); + env().registerLattice(GFSrcName_); + env().registerLattice(prop0Name_); + env().registerLattice(twoscalarName_); + env().registerLattice(twoscalarVertexName_); + env().registerLattice(psquaredName_); +} + +// execution /////////////////////////////////////////////////////////////////// +void TVPCounterTerms::execute(void) +{ + ScalarField &source = *env().getObject(par().source); + Complex ci(0.0,1.0); + FFT fft(env().getGrid()); + ScalarField buf(env().getGrid()), tmp_vp(env().getGrid()); + + // Momentum-space free scalar propagator + ScalarField &G = *env().createLattice(freeMomPropName_); + SIMPL::MomentumSpacePropagator(G, par().mass); + + // Phases and hat{p}^2 + ScalarField &phatsq = *env().createLattice(phatsqName_); + std::vector &l = env().getGrid()->_fdimensions; + + LOG(Message) << "Calculating shift phases..." << std::endl; + phatsq = zero; + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + Real twoPiL = M_PI*2./l[mu]; + + phase_.push_back(env().createLattice(phaseName_[mu])); + LatticeCoordinate(buf, mu); + *(phase_[mu]) = exp(ci*twoPiL*buf); + buf = 2.*sin(.5*twoPiL*buf); + phatsq = phatsq + buf*buf; + } + + // G*F*src + ScalarField &GFSrc = *env().createLattice(GFSrcName_); + fft.FFT_all_dim(GFSrc, source, FFT::forward); + GFSrc = G*GFSrc; + + // Position-space free scalar propagator + ScalarField &prop0 = *env().createLattice(prop0Name_); + prop0 = GFSrc; + fft.FFT_all_dim(prop0, prop0, FFT::backward); + + // Propagators for counter-terms + ScalarField &twoscalarProp = *env().createLattice(twoscalarName_); + ScalarField &twoscalarVertexProp = *env().createLattice(twoscalarVertexName_); + ScalarField &psquaredProp = *env().createLattice(psquaredName_); + + twoscalarProp = G*GFSrc; + fft.FFT_all_dim(twoscalarProp, twoscalarProp, FFT::backward); + + twoscalarVertexProp = zero; + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + buf = GFSrc; + twoscalarVertexProp = twoscalarVertexProp + .5*((*phase_[mu]) + adj(*phase_[mu]))*buf; + } + twoscalarVertexProp = G*twoscalarVertexProp; + fft.FFT_all_dim(twoscalarVertexProp, twoscalarVertexProp, FFT::backward); + + psquaredProp = G*phatsq*GFSrc; + fft.FFT_all_dim(psquaredProp, psquaredProp, FFT::backward); + + // Open output files if necessary + std::vector vecBuf; + std::vector result; + ScalarField vpPhase(env().getGrid()); + std::vector writer; + std::vector momphases; + if (!par().output.empty()) + { + LOG(Message) << "Preparing output files..." << std::endl; + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + std::vector mom = strToVec(par().outputMom[i_p]); + + // Open output files + std::string filename = par().output + "_" + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]) + + "." + + std::to_string(env().getTrajectory()); + + if (env().getGrid()->IsBoss()) + { + CorrWriter *writer_i = new CorrWriter(filename); + writer.push_back(writer_i); + + write(*writer[i_p], "mass", par().mass); + } + + // Calculate phase factors + vpPhase = Complex(1.0,0.0); + for (unsigned int j = 0; j < env().getNd()-1; ++j) + { + for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) + { + vpPhase = vpPhase*(*phase_[j]); + } + } + vpPhase = adj(vpPhase); + momphases.push_back(vpPhase); + } + } + + // Contractions + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + buf = adj(Cshift(prop0, nu, -1)); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + // Three-scalar loop (no vertex) + tmp_vp = buf * Cshift(twoscalarProp, mu, 1); + tmp_vp -= Cshift(buf, mu, 1) * twoscalarProp; + tmp_vp = 2.0*real(tmp_vp); + + // Output if necessary + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + vpPhase = tmp_vp*momphases[i_p]; + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + if (env().getGrid()->IsBoss()) + { + write(*writer[i_p], + "NoVertex_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + } + } + + // Three-scalar loop (tadpole vertex) + tmp_vp = buf * Cshift(twoscalarVertexProp, mu, 1); + tmp_vp -= Cshift(buf, mu, 1) * twoscalarVertexProp; + tmp_vp = 2.0*real(tmp_vp); + + // Output if necessary + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + vpPhase = tmp_vp*momphases[i_p]; + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + if (env().getGrid()->IsBoss()) + { + write(*writer[i_p], + "TadVertex_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + } + } + + // Three-scalar loop (hat{p}^2 insertion) + tmp_vp = buf * Cshift(psquaredProp, mu, 1); + tmp_vp -= Cshift(buf, mu, 1) * psquaredProp; + tmp_vp = 2.0*real(tmp_vp); + + // Output if necessary + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + vpPhase = tmp_vp*momphases[i_p]; + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + if (env().getGrid()->IsBoss()) + { + write(*writer[i_p], + "pSquaredInsertion_"+std::to_string(mu)+"_"+std::to_string(nu), + result); + } + } + } + } + } + + // Close output files if necessary + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + if (env().getGrid()->IsBoss()) + { + delete writer[i_p]; + } + } + } +} diff --git a/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp new file mode 100644 index 00000000..6bd6db8e --- /dev/null +++ b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp @@ -0,0 +1,55 @@ +#ifndef Hadrons_MScalar_VPCounterTerms_hpp_ +#define Hadrons_MScalar_VPCounterTerms_hpp_ + +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/****************************************************************************** + * VPCounterTerms * + ******************************************************************************/ +BEGIN_MODULE_NAMESPACE(MScalar) + +class VPCounterTermsPar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(VPCounterTermsPar, + std::string, source, + double, mass, + std::string, output, + std::vector, outputMom); +}; + +class TVPCounterTerms: public Module +{ +public: + SCALAR_TYPE_ALIASES(SIMPL,); +public: + // constructor + TVPCounterTerms(const std::string name); + // destructor + virtual ~TVPCounterTerms(void) = default; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); + // setup + virtual void setup(void); + // execution + virtual void execute(void); +private: + std::string freeMomPropName_, GFSrcName_, phatsqName_, prop0Name_, + twoscalarName_, twoscalarVertexName_, + psquaredName_, psquaredVertexName_; + std::vector phaseName_; + std::vector phase_; +}; + +MODULE_REGISTER_NS(VPCounterTerms, TVPCounterTerms, MScalar); + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_MScalar_VPCounterTerms_hpp_ diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index b3c65de0..fa1fe319 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -9,7 +9,8 @@ modules_cc =\ Modules/MGauge/UnitEm.cc \ Modules/MScalar/ChargedProp.cc \ Modules/MScalar/FreeProp.cc \ - Modules/MScalar/ScalarVP.cc + Modules/MScalar/ScalarVP.cc \ + Modules/MScalar/VPCounterTerms.cc modules_hpp =\ Modules/MAction/DWF.hpp \ @@ -33,6 +34,7 @@ modules_hpp =\ Modules/MScalar/FreeProp.hpp \ Modules/MScalar/Scalar.hpp \ Modules/MScalar/ScalarVP.hpp \ + Modules/MScalar/VPCounterTerms.hpp \ Modules/MSink/Point.hpp \ Modules/MSolver/RBPrecCG.hpp \ Modules/MSource/Point.hpp \ From 581be32ed24b9a39aaf22fd05cda185f13cb884e Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 14 Dec 2017 13:42:41 +0000 Subject: [PATCH 38/57] Implement infrared improvement for v=0 on-shell self-energy --- extras/Hadrons/Modules/MGauge/StochEm.cc | 2 +- extras/Hadrons/Modules/MGauge/StochEm.hpp | 3 +- extras/Hadrons/Modules/MGauge/UnitEm.cc | 2 +- lib/qcd/action/gauge/Photon.h | 34 ++++++++++++++++++++--- 4 files changed, 34 insertions(+), 7 deletions(-) diff --git a/extras/Hadrons/Modules/MGauge/StochEm.cc b/extras/Hadrons/Modules/MGauge/StochEm.cc index c7a9fc4f..8f84fe94 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.cc +++ b/extras/Hadrons/Modules/MGauge/StochEm.cc @@ -67,7 +67,7 @@ void TStochEm::setup(void) // execution /////////////////////////////////////////////////////////////////// void TStochEm::execute(void) { - PhotonR photon(par().gauge, par().zmScheme); + PhotonR photon(par().gauge, par().zmScheme, par().improvement); EmField &a = *env().createLattice(getName()); EmComp *w; diff --git a/extras/Hadrons/Modules/MGauge/StochEm.hpp b/extras/Hadrons/Modules/MGauge/StochEm.hpp index 12ce9fdc..b6bfa262 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.hpp +++ b/extras/Hadrons/Modules/MGauge/StochEm.hpp @@ -44,7 +44,8 @@ class StochEmPar: Serializable public: GRID_SERIALIZABLE_CLASS_MEMBERS(StochEmPar, PhotonR::Gauge, gauge, - PhotonR::ZmScheme, zmScheme); + PhotonR::ZmScheme, zmScheme, + Integer, improvement); }; class TStochEm: public Module diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.cc b/extras/Hadrons/Modules/MGauge/UnitEm.cc index f33dfed3..747ef142 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.cc +++ b/extras/Hadrons/Modules/MGauge/UnitEm.cc @@ -61,7 +61,7 @@ void TUnitEm::setup(void) // execution /////////////////////////////////////////////////////////////////// void TUnitEm::execute(void) { - PhotonR photon(0, 0); // Just chose arbitrary input values here + PhotonR photon(0, 0, 0); // Just chose arbitrary input values here EmField &a = *env().createLattice(getName()); LOG(Message) << "Generating unit EM potential..." << std::endl; photon.UnitField(a); diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index 1429c2ba..e0329bed 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -60,7 +60,7 @@ namespace QCD{ GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3); GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2); public: - Photon(Gauge gauge, ZmScheme zmScheme); + Photon(Gauge gauge, ZmScheme zmScheme, Integer improvement); virtual ~Photon(void) = default; void FreePropagator(const GaugeField &in, GaugeField &out); void MomentumSpacePropagator(const GaugeField &in, GaugeField &out); @@ -75,13 +75,14 @@ namespace QCD{ private: Gauge gauge_; ZmScheme zmScheme_; + Integer improvement_; }; typedef Photon PhotonR; template - Photon::Photon(Gauge gauge, ZmScheme zmScheme) - : gauge_(gauge), zmScheme_(zmScheme) + Photon::Photon(Gauge gauge, ZmScheme zmScheme, Integer improvement) + : gauge_(gauge), zmScheme_(zmScheme), improvement_(improvement) {} template @@ -128,6 +129,7 @@ namespace QCD{ { GridBase *grid = out._grid; const unsigned int nd = grid->_ndimension; + std::vector &l = grid->_fdimensions; switch (zmScheme_) { @@ -149,9 +151,33 @@ namespace QCD{ for(int d = 0; d < grid->_ndimension - 1; d++) { LatticeCoordinate(coor,d); + coor = where(coor < Integer(l[d]/2), coor, coor-Integer(l[d])); spNrm = spNrm + coor*coor; } out = where(spNrm == Integer(0), 0.*out, out); + + // IR improvement + switch (improvement_) + { + case 0: + break; + case 1: + { + Real f1 = sqrt(2.48560548); + out = where(spNrm == Integer(1), f1*out, out); + break; + } + case 2: + { + Real f1 = sqrt(4.93053406); + Real f2 = sqrt(-1.44492857); + out = where(spNrm == Integer(1), f1*out, out); + out = where(spNrm == Integer(2), f2*out, out); + break; + } + default: + break; + } break; } @@ -159,7 +185,7 @@ namespace QCD{ break; } } - + template void Photon::MomentumSpacePropagator(const GaugeField &in, GaugeField &out) From 219b3bd34f467fba233656519f34e6c5585e9d40 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 19 Jan 2018 17:14:11 +0000 Subject: [PATCH 39/57] Remove freeVpTensor object --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 25 +++++++++------------ extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 3 +-- 2 files changed, 11 insertions(+), 17 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index b8cdb7e3..95e74394 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -38,7 +38,6 @@ std::vector TScalarVP::getOutput(void) for (unsigned int nu = 0; nu < env().getNd(); ++nu) { out.push_back(getName() + "_" + std::to_string(mu) + "_" + std::to_string(nu)); - out.push_back(getName() + "_free_" + std::to_string(mu) + "_" + std::to_string(nu)); } } @@ -55,7 +54,6 @@ void TScalarVP::setup(void) phaseName_.clear(); muPropQName_.clear(); vpTensorName_.clear(); - freeVpTensorName_.clear(); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { @@ -63,16 +61,12 @@ void TScalarVP::setup(void) muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu)); std::vector vpTensorName_mu; - std::vector freeVpTensorName_mu; for (unsigned int nu = 0; nu < env().getNd(); ++nu) { vpTensorName_mu.push_back(getName() + "_" + std::to_string(mu) + "_" + std::to_string(nu)); - freeVpTensorName_mu.push_back(getName() + "_free_" + std::to_string(mu) - + "_" + std::to_string(nu)); } vpTensorName_.push_back(vpTensorName_mu); - freeVpTensorName_.push_back(freeVpTensorName_mu); } for (unsigned int mu = 0; mu < env().getNd(); ++mu) @@ -82,7 +76,6 @@ void TScalarVP::setup(void) for (unsigned int nu = 0; nu < env().getNd(); ++nu) { env().registerLattice(vpTensorName_[mu][nu]); - env().registerLattice(freeVpTensorName_[mu][nu]); } } } @@ -129,18 +122,15 @@ void TScalarVP::execute(void) ScalarField Amu(env().getGrid()), tmp_vp(env().getGrid()); TComplex Anu0; std::vector coor0 = {0, 0, 0, 0}; - std::vector > vpTensor, freeVpTensor; + std::vector > vpTensor; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { std::vector vpTensor_mu; - std::vector freeVpTensor_mu; for (unsigned int nu = 0; nu < env().getNd(); ++nu) { vpTensor_mu.push_back(*env().createLattice(vpTensorName_[mu][nu])); - freeVpTensor_mu.push_back(*env().createLattice(freeVpTensorName_[mu][nu])); } vpTensor.push_back(vpTensor_mu); - freeVpTensor.push_back(freeVpTensor_mu); } // Open output files if necessary @@ -218,16 +208,17 @@ void TScalarVP::execute(void) // Free VP prop1 = *prop0_; prop2 = Cshift(*prop0_, nu, -1); - freeVpTensor[mu][nu] = adj(prop2) * Cshift(prop1, mu, 1); - freeVpTensor[mu][nu] -= Cshift(adj(prop2), mu, 1) * prop1; - freeVpTensor[mu][nu] = 2.0*real(freeVpTensor[mu][nu]); + tmp_vp = adj(prop2) * Cshift(prop1, mu, 1); + tmp_vp -= Cshift(adj(prop2), mu, 1) * prop1; + tmp_vp = 2.0*real(tmp_vp); + vpTensor[mu][nu] = tmp_vp; // Output if necessary if (!par().output.empty()) { for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = freeVpTensor[mu][nu]*momphases[i_p]; + vpPhase = tmp_vp*momphases[i_p]; sliceSum(vpPhase, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) @@ -243,6 +234,10 @@ void TScalarVP::execute(void) } } + // S + // X + // 4C + // "Exchange" terms prop1 += q*propQ; prop2 += q*muPropQ[nu]; diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index e4a6e825..2b9e988b 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -47,8 +47,7 @@ private: prop0Name_, propQName_, propSunName_, propTadName_; std::vector phaseName_, muPropQName_; - std::vector > vpTensorName_, - freeVpTensorName_; + std::vector > vpTensorName_; ScalarField *freeMomProp_, *GFSrc_, *prop0_; std::vector phase_; From ab3baeb38fef642e496ad8fb9b08f42ff91f5252 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 23 Jan 2018 17:07:45 +0000 Subject: [PATCH 40/57] Implement contractions and data output in functions; calculate diagrams S, X and 4C separately; output 2E and 2T instead of sunset_shifted, sunset_unshifted, tadpole_shifted, tadpole_unshifted; add comments. --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 525 +++++++++----------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 14 + 2 files changed, 241 insertions(+), 298 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 95e74394..93c51a77 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -6,6 +6,78 @@ using namespace Grid; using namespace Hadrons; using namespace MScalar; +/* + * Scalar QED vacuum polarisation up to O(alpha) + * + * + * _______ + * / \ ( adj(S(a\hat{nu}|x)) U_mu(x) S(0|x+a\hat{mu}) U_nu(0) ) + * Diagram notation: U_nu * * U_mu = 2 Re( - ) + * \_______/ ( adj(S(a\hat{nu}|x+a\hat{mu})) adj(U_mu(x)) S(0|x) U_nu(0) ) + * + * + * + * _______ + * / \ + * free = 1 * * 1 + * \_______/ + * + * + * + * _______ + * / \ + * S = iA_nu * * iA_mu + * \_______/ + * + * + * Delta_1 + * ___*___ + * / \ + * X = 1 * * 1 + * \___*___/ + * Delta_1 + * + * Delta_1 Delta_1 + * ___*___ ___*___ + * / \ / \ + * 1 * * iA_mu + iA_nu * * 1 + * \_______/ \_______/ + * 4C = _______ _______ + * / \ / \ + * + 1 * * iA_mu + iA_nu * * 1 + * \___*___/ \___*___/ + * Delta_1 Delta_1 + * + * Delta_1 Delta_1 + * _*___*_ _______ + * / \ / \ + * 2E = 1 * * 1 + 1 * * 1 + * \_______/ \_*___*_/ + * Delta_1 Delta_1 + * + * Delta_2 + * ___*___ _______ + * / \ / \ + * 2T = 1 * * 1 + 1 * * 1 + * \_______/ \___*___/ + * Delta_2 + * + * + * _______ + * / \ + * srcT = -A_nu^2/2 * * 1 + * \_______/ + * + * + * + * _______ + * / \ + * snkT = 1 * * -A_mu^2/2 + * \_______/ + * + * Full VP to O(alpha) = free + q^2*(S+X+4C+2E+2T+srcT+snkT) + */ + /****************************************************************************** * TScalarVP implementation * ******************************************************************************/ @@ -37,7 +109,8 @@ std::vector TScalarVP::getOutput(void) for (unsigned int nu = 0; nu < env().getNd(); ++nu) { - out.push_back(getName() + "_" + std::to_string(mu) + "_" + std::to_string(nu)); + out.push_back(getName() + "_" + std::to_string(mu) + + "_" + std::to_string(nu)); } } @@ -119,8 +192,9 @@ void TScalarVP::execute(void) // CONTRACTIONS ScalarField prop1(env().getGrid()), prop2(env().getGrid()); EmField &A = *env().getObject(par().emField); - ScalarField Amu(env().getGrid()), tmp_vp(env().getGrid()); - TComplex Anu0; + ScalarField Amu(env().getGrid()), U_snk(env().getGrid()); + ScalarField tmp_vp1(env().getGrid()), tmp_vp2(env().getGrid()); + TComplex Anu0, U_src; std::vector coor0 = {0, 0, 0, 0}; std::vector > vpTensor; for (unsigned int mu = 0; mu < env().getNd(); ++mu) @@ -134,10 +208,7 @@ void TScalarVP::execute(void) } // Open output files if necessary - std::vector vecBuf; - std::vector result; - ScalarField vpPhase(env().getGrid()); - std::vector writer, writer0, writerD; + std::vector writer; std::vector momphases; if (!par().output.empty()) { @@ -147,50 +218,32 @@ void TScalarVP::execute(void) std::vector mom = strToVec(par().outputMom[i_p]); // Open output files - std::string filename = par().output + "_" + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]) - + "." + - std::to_string(env().getTrajectory()); - std::string filename0 = par().output + "_" + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]) - + "_free." + - std::to_string(env().getTrajectory()); - std::string filenameD = par().output + "_" + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]) - + "_diagrams." + - std::to_string(env().getTrajectory()); + std::string filename = par().output + "_" + + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]) + "." + + std::to_string(env().getTrajectory()); if (env().getGrid()->IsBoss()) { CorrWriter *writer_i = new CorrWriter(filename); writer.push_back(writer_i); - CorrWriter *writer0_i = new CorrWriter(filename0); - writer0.push_back(writer0_i); - CorrWriter *writerD_i = new CorrWriter(filenameD); - writerD.push_back(writerD_i); write(*writer[i_p], "charge", q); write(*writer[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - write(*writer0[i_p], "charge", 0.0); - write(*writer0[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - write(*writerD[i_p], "charge", q); - write(*writerD[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); } // Calculate phase factors - vpPhase = Complex(1.0,0.0); + tmp_vp1 = Complex(1.0,0.0); for (unsigned int j = 0; j < env().getNd()-1; ++j) { for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) { - vpPhase = vpPhase*(*phase_[j]); + tmp_vp1 = tmp_vp1*(*phase_[j]); } } - vpPhase = adj(vpPhase); - momphases.push_back(vpPhase); + tmp_vp1 = adj(tmp_vp1); + momphases.push_back(tmp_vp1); } } @@ -205,297 +258,132 @@ void TScalarVP::execute(void) << std::endl; Amu = peekLorentz(A, mu); - // Free VP - prop1 = *prop0_; - prop2 = Cshift(*prop0_, nu, -1); - tmp_vp = adj(prop2) * Cshift(prop1, mu, 1); - tmp_vp -= Cshift(adj(prop2), mu, 1) * prop1; - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] = tmp_vp; - + // free + prop1 = *prop0_; // S_0(0|x) + prop2 = Cshift(*prop0_, nu, -1); // S_0(0|x-a\hat{\nu}) + // = S_0(a\hat{\nu}|x) + U_src = Complex(1.0,0.0); + vpContraction(tmp_vp1, prop1, prop2, U_src, mu); + vpTensor[mu][nu] = tmp_vp1; // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writer0[i_p], - "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(writer, tmp_vp1, momphases, + "Pi_free_"+std::to_string(mu)+"_"+std::to_string(nu)); + } + + // srcT + tmp_vp2 = tmp_vp1 * (-0.5)*q*q*Anu0*Anu0; + vpTensor[mu][nu] += tmp_vp2; + // Output if necessary + if (!par().output.empty()) + { + writeVP(writer, tmp_vp2, momphases, + "Pi_srcT_"+std::to_string(mu)+"_"+std::to_string(nu)); + } + + // snkT + tmp_vp2 = tmp_vp1 * (-0.5)*q*q*Amu*Amu; + vpTensor[mu][nu] += tmp_vp2; + // Output if necessary + if (!par().output.empty()) + { + writeVP(writer, tmp_vp2, momphases, + "Pi_snkT_"+std::to_string(mu)+"_"+std::to_string(nu)); } // S - // X + prop1 = *prop0_; // S_0(0|x) + prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) + U_src = ci*q*Anu0; + U_snk = ci*q*Amu; + vpContraction(tmp_vp1, prop1, prop2, U_src, U_snk, mu); + vpTensor[mu][nu] += tmp_vp1; + // Output if necessary + if (!par().output.empty()) + { + writeVP(writer, tmp_vp1, momphases, + "Pi_S_"+std::to_string(mu)+"_"+std::to_string(nu)); + } + // 4C - - // "Exchange" terms - prop1 += q*propQ; - prop2 += q*muPropQ[nu]; - tmp_vp = adj(prop2) * (1.0 + ci*q*Amu) - * Cshift(prop1, mu, 1) * (1.0 + ci*q*Anu0); - tmp_vp -= Cshift(adj(prop2), mu, 1) * (1.0 - ci*q*Amu) - * prop1 * (1.0 + ci*q*Anu0); - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] = tmp_vp; - + prop1 = q*propQ; // q*S_1(0|x) + prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) + U_src = Complex(1.0,0.0); + U_snk = ci*q*Amu; + vpContraction(tmp_vp1, prop1, prop2, U_src, U_snk, mu); + U_src = ci*q*Anu0; + vpContraction(tmp_vp2, prop1, prop2, U_src, mu); + tmp_vp1 += tmp_vp2; + prop1 = *prop0_; // S_0(0|x) + prop2 = q*muPropQ[nu]; // q*S_1(a\hat{\nu}|x) + vpContraction(tmp_vp2, prop1, prop2, U_src, mu); + tmp_vp1 += tmp_vp2; + U_src = Complex(1.0,0.0); + U_snk = ci*q*Amu; + vpContraction(tmp_vp2, prop1, prop2, U_src, U_snk, mu); + tmp_vp1 += tmp_vp2; + vpTensor[mu][nu] += tmp_vp1; // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_exchange_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(writer, tmp_vp1, momphases, + "Pi_4C_"+std::to_string(mu)+"_"+std::to_string(nu)); } - // Subtract O(alpha^2) term - prop1 = q*propQ; - prop2 = q*muPropQ[nu]; - tmp_vp = Cshift(adj(prop2), mu, 1) * (-ci)*q*Amu - * prop1 * ci*q*Anu0; - tmp_vp -= adj(prop2) * ci*q*Amu - * Cshift(prop1, mu, 1) * ci*q*Anu0; - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] += tmp_vp; - + // X + prop1 = q*propQ; // q*S_1(0|x) + prop2 = q*muPropQ[nu]; // q*S_1(a\hat{\nu}|x) + U_src = Complex(1.0,0.0); + vpContraction(tmp_vp1, prop1, prop2, U_src, mu); + vpTensor[mu][nu] += tmp_vp1; // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_alpha2_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(writer, tmp_vp1, momphases, + "Pi_X_"+std::to_string(mu)+"_"+std::to_string(nu)); } - // Sunset from unshifted source - prop1 = q*q*propSun; - prop2 = Cshift(*prop0_, nu, -1); - tmp_vp = adj(prop2) * Cshift(prop1, mu, 1); - tmp_vp -= Cshift(adj(prop2), mu, 1) * prop1; - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] += tmp_vp; - + // 2E + prop1 = q*q*propSun; // q^2*S_\Sigma(0|x) + prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) + U_src = Complex(1.0,0.0); + vpContraction(tmp_vp1, prop1, prop2, U_src, mu); + prop1 = *prop0_; // S_0(0|x) + prop2 = q*q*Cshift(propSun, nu, -1); // q^2*S_\Sigma(0|x-a\hat{\nu}) + //(Note: = ) + vpContraction(tmp_vp2, prop1, prop2, U_src, mu); + tmp_vp1 += tmp_vp2; + vpTensor[mu][nu] += tmp_vp1; // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_sunset_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(writer, tmp_vp1, momphases, + "Pi_2E_"+std::to_string(mu)+"_"+std::to_string(nu)); } - // Sunset from shifted source - prop1 = Cshift(prop1, nu, -1); - tmp_vp = Cshift(adj(*prop0_), mu, 1) * prop1; - tmp_vp -= adj(*prop0_) * Cshift(prop1, mu, 1); - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] += tmp_vp; - + // 2T + prop1 = q*q*propTad; // q^2*S_T(0|x) + prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) + U_src = Complex(1.0,0.0); + vpContraction(tmp_vp1, prop1, prop2, U_src, mu); + prop1 = *prop0_; // S_0(0|x) + prop2 = q*q*Cshift(propTad, nu, -1); // q^2*S_T(0|x-a\hat{\nu}) + vpContraction(tmp_vp2, prop1, prop2, U_src, mu); + tmp_vp1 += tmp_vp2; + vpTensor[mu][nu] += tmp_vp1; // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_sunset_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(writer, tmp_vp1, momphases, + "Pi_2T_"+std::to_string(mu)+"_"+std::to_string(nu)); } - // Tadpole from unshifted source - prop1 = q*q*propTad; - prop2 = Cshift(*prop0_, nu, -1); - tmp_vp = adj(prop2) * Cshift(prop1, mu, 1); - tmp_vp -= Cshift(adj(prop2), mu, 1) * prop1; - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] += tmp_vp; - - // Output if necessary + // Output full VP if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_tadpole_unshifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } - } - - // Tadpole from shifted source - prop1 = Cshift(prop1, nu, -1); - tmp_vp = Cshift(adj(*prop0_), mu, 1) * prop1; - tmp_vp -= adj(*prop0_) * Cshift(prop1, mu, 1); - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] += tmp_vp; - - // Output if necessary - if (!par().output.empty()) - { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_tadpole_shifted_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } - } - - // Source tadpole - prop1 = *prop0_; - tmp_vp = adj(prop2) - * Cshift(prop1, mu, 1) - * (-0.5)*q*q*Anu0*Anu0; - tmp_vp -= Cshift(adj(prop2), mu, 1) - * prop1 - * (-0.5)*q*q*Anu0*Anu0; - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] += tmp_vp; - - // Output if necessary - if (!par().output.empty()) - { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_sourcetadpole_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } - } - - // Sink tadpole - tmp_vp = adj(prop2) - * (-0.5)*q*q*Amu*Amu - * Cshift(prop1, mu, 1); - tmp_vp -= Cshift(adj(prop2), mu, 1) - * (-0.5)*q*q*Amu*Amu - * prop1; - tmp_vp = 2.0*real(tmp_vp); - vpTensor[mu][nu] += tmp_vp; - - // Output if necessary - if (!par().output.empty()) - { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writerD[i_p], - "Pi_sinktadpole_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } - } - - // Output if necessary - if (!par().output.empty()) - { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = vpTensor[mu][nu]*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writer[i_p], - "Pi_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(writer, vpTensor[mu][nu], momphases, + "Pi_"+std::to_string(mu)+"_"+std::to_string(nu)); } } } @@ -506,13 +394,54 @@ void TScalarVP::execute(void) if (env().getGrid()->IsBoss()) { delete writer[i_p]; - delete writer0[i_p]; - delete writerD[i_p]; } } } } +void TScalarVP::vpContraction(ScalarField &vp, + ScalarField &prop_0_x, ScalarField &prop_nu_x, + TComplex u_src, ScalarField &u_snk, int mu) +{ + // Note: this function assumes a point source is used. + vp = adj(prop_nu_x) * u_snk * Cshift(prop_0_x, mu, 1) * u_src; + vp -= Cshift(adj(prop_nu_x), mu, 1) * adj(u_snk) * prop_0_x * u_src; + vp = 2.0*real(vp); +} + +void TScalarVP::vpContraction(ScalarField &vp, + ScalarField &prop_0_x, ScalarField &prop_nu_x, + TComplex u_src, int mu) +{ + // Note: this function assumes a point source is used. + vp = adj(prop_nu_x) * Cshift(prop_0_x, mu, 1) * u_src; + vp -= Cshift(adj(prop_nu_x), mu, 1) * prop_0_x * u_src; + vp = 2.0*real(vp); +} + +void TScalarVP::writeVP(const std::vector &writers, const ScalarField &vp, + const std::vector &momphases, std::string dsetName) +{ + std::vector vecBuf; + std::vector result; + ScalarField vpPhase(env().getGrid()); + + for (unsigned int i_p = 0; i_p < momphases.size(); ++i_p) + { + vpPhase = vp*momphases[i_p]; + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + if (env().getGrid()->IsBoss()) + { + write(*writers[i_p], dsetName, result); + } + } +} + void TScalarVP::momD1(ScalarField &s, FFT &fft) { EmField &A = *env().getObject(par().emField); diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 2b9e988b..564a7f39 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -41,6 +41,20 @@ public: // execution virtual void execute(void); private: + // conserved vector two-point contraction + void vpContraction(ScalarField &vp, + ScalarField &prop_0_x, ScalarField &prop_nu_x, + TComplex u_src, ScalarField &u_snk, int mu); + // conserved vector two-point contraction with unit gauge link at sink + void vpContraction(ScalarField &vp, + ScalarField &prop_0_x, ScalarField &prop_nu_x, + TComplex u_src, int mu); + // write momentum-projected vacuum polarisation to file(s) + void writeVP(const std::vector &writers, + const ScalarField &vp, + const std::vector &momphases, + std::string dsetName); + // momentum-space Delta_1 insertion void momD1(ScalarField &s, FFT &fft); private: std::string freeMomPropName_, GFSrcName_, From 3db7a5387b4e3f1621cda9d21cd8010b3bc46079 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 26 Jan 2018 16:33:48 +0000 Subject: [PATCH 41/57] BROKEN: Adapted scalarVP, UnitEm and VPCounterTerms modules to new Hadrons. Currently getting an assertion error from Communicator_mpi3.cc when I try to run. --- extras/Hadrons/Modules/MGauge/UnitEm.cc | 4 +- extras/Hadrons/Modules/MGauge/UnitEm.hpp | 1 + extras/Hadrons/Modules/MScalar/ChargedProp.cc | 33 +- .../Hadrons/Modules/MScalar/ChargedProp.hpp | 3 +- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 327 ++++++++++-------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 24 +- .../Hadrons/Modules/MScalar/VPCounterTerms.cc | 180 +++++----- .../Modules/MScalar/VPCounterTerms.hpp | 7 +- extras/Hadrons/modules.inc | 2 +- 9 files changed, 292 insertions(+), 289 deletions(-) diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.cc b/extras/Hadrons/Modules/MGauge/UnitEm.cc index 747ef142..a19161ac 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.cc +++ b/extras/Hadrons/Modules/MGauge/UnitEm.cc @@ -55,14 +55,14 @@ std::vector TUnitEm::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TUnitEm::setup(void) { - env().registerLattice(getName()); + envCreateLat(EmField, getName()); } // execution /////////////////////////////////////////////////////////////////// void TUnitEm::execute(void) { PhotonR photon(0, 0, 0); // Just chose arbitrary input values here - EmField &a = *env().createLattice(getName()); + auto &a = envGet(EmField, getName()); LOG(Message) << "Generating unit EM potential..." << std::endl; photon.UnitField(a); } diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.hpp b/extras/Hadrons/Modules/MGauge/UnitEm.hpp index ea910929..1df45d4a 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.hpp +++ b/extras/Hadrons/Modules/MGauge/UnitEm.hpp @@ -52,6 +52,7 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index ee215116..5e65c43e 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -145,16 +145,16 @@ void TChargedProp::execute(void) for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { std::vector mom = strToVec(par().outputMom[i_p]); - std::string filename = par().output + "_" + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]) - + "." + - std::to_string(vm().getTrajectory()); + std::string filename = par().output + "_" + + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]); - LOG(Message) << "Saving (" << par().outputMom[i_p] << ") momentum projection to '" - << filename << "'..." << std::endl; + LOG(Message) << "Saving (" << par().outputMom[i_p] + << ") momentum projection to '" << filename << "'..." + << std::endl; - std::vector result, result0, resultQ, resultSun, resultTad; + std::vector result, result0, resultQ, resultSun, resultTad; result.resize(env().getGrid()->_fdimensions[env().getNd()-1]); result0.resize(result.size()); resultQ.resize(result.size()); @@ -189,13 +189,13 @@ void TChargedProp::execute(void) peekSite(site, propTad, whichmom); resultTad[t]=TensorRemove(site); } - saveResult(par().output, "charge", q); - saveResult(par().output, "mass", par().mass); - saveResult(par().output, "prop", result); - saveResult(par().output, "prop_0", result0); - saveResult(par().output, "prop_Q", resultQ); - saveResult(par().output, "prop_Sun", resultSun); - saveResult(par().output, "prop_Tad", resultTad); + saveResult(filename, "charge", q); + saveResult(filename, "mass", par().mass); + saveResult(filename, "prop", result); + saveResult(filename, "prop_0", result0); + saveResult(filename, "prop_Q", resultQ); + saveResult(filename, "prop_Sun", resultSun); + saveResult(filename, "prop_Tad", resultTad); } } @@ -231,7 +231,8 @@ void TChargedProp::makeCaches(void) } if (!prop0Done_) { - LOG(Message) << "Caching position-space free scalar propagator..." << std::endl; + LOG(Message) << "Caching position-space free scalar propagator..." + << std::endl; fft.FFT_all_dim(prop0, GFSrc, FFT::backward); } if (!phasesDone_) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index 9dd3ce31..3a711361 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -75,7 +75,8 @@ private: void momD1(ScalarField &s, FFT &fft); void momD2(ScalarField &s, FFT &fft); private: - bool freeMomPropDone_, GFSrcDone_, prop0Done_, phasesDone_; + bool freeMomPropDone_, GFSrcDone_, prop0Done_, + phasesDone_; std::string freeMomPropName_, GFSrcName_, prop0Name_, propQName_, propSunName_, propTadName_, fftName_; std::vector phaseName_; diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 93c51a77..9a6106eb 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -9,12 +9,15 @@ using namespace MScalar; /* * Scalar QED vacuum polarisation up to O(alpha) * + * Conserved vector 2-point function diagram notation: + * _______ + * / \ + * U_nu * * U_mu + * \_______/ * - * _______ - * / \ ( adj(S(a\hat{nu}|x)) U_mu(x) S(0|x+a\hat{mu}) U_nu(0) ) - * Diagram notation: U_nu * * U_mu = 2 Re( - ) - * \_______/ ( adj(S(a\hat{nu}|x+a\hat{mu})) adj(U_mu(x)) S(0|x) U_nu(0) ) - * + * ( adj(S(a\hat{nu}|x)) U_mu(x) S(0|x+a\hat{mu}) U_nu(0) ) + * = 2 Re( - ) + * ( adj(S(a\hat{nu}|x+a\hat{mu})) adj(U_mu(x)) S(0|x) U_nu(0) ) * * * _______ @@ -89,12 +92,13 @@ TScalarVP::TScalarVP(const std::string name) // dependencies/products /////////////////////////////////////////////////////// std::vector TScalarVP::getInput(void) { + prop0Name_ = par().scalarProp + "_0"; propQName_ = par().scalarProp + "_Q"; propSunName_ = par().scalarProp + "_Sun"; propTadName_ = par().scalarProp + "_Tad"; - std::vector in = {par().emField, propQName_, propSunName_, - propTadName_}; + std::vector in = {par().emField, prop0Name_, propQName_, + propSunName_, propTadName_}; return in; } @@ -105,7 +109,7 @@ std::vector TScalarVP::getOutput(void) for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - out.push_back(getName() + "_propQ_" + std::to_string(mu)); + // out.push_back(getName() + "_propQ_" + std::to_string(mu)); for (unsigned int nu = 0; nu < env().getNd(); ++nu) { @@ -120,14 +124,13 @@ std::vector TScalarVP::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TScalarVP::setup(void) { - freeMomPropName_ = FREEMOMPROP(static_cast(env().getModule(par().scalarProp))->par().mass); - GFSrcName_ = "_" + par().scalarProp + "_DinvSrc"; - prop0Name_ = par().scalarProp + "_0"; - + freeMomPropName_ = FREEMOMPROP(static_cast(vm().getModule(par().scalarProp))->par().mass); + GFSrcName_ = par().scalarProp + "_DinvSrc"; + fftName_ = par().scalarProp + "_fft"; phaseName_.clear(); muPropQName_.clear(); vpTensorName_.clear(); - + momPhaseName_.clear(); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); @@ -141,109 +144,111 @@ void TScalarVP::setup(void) } vpTensorName_.push_back(vpTensorName_mu); } + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + momPhaseName_.push_back("_momentumphase_" + std::to_string(i_p)); + } + } for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - env().registerLattice(muPropQName_[mu]); + envCreateLat(ScalarField, muPropQName_[mu]); for (unsigned int nu = 0; nu < env().getNd(); ++nu) { - env().registerLattice(vpTensorName_[mu][nu]); + envCreateLat(ScalarField, vpTensorName_[mu][nu]); } } + if (!par().output.empty()) + { + momPhasesDone_ = env().hasCreatedObject(momPhaseName_[0]); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + envCacheLat(ScalarField, momPhaseName_[i_p]); + } + } + envTmpLat(ScalarField, "buf"); + envTmpLat(ScalarField, "result"); + envTmpLat(ScalarField, "Amu"); + envTmpLat(ScalarField, "Usnk"); + envTmpLat(ScalarField, "tmpProp"); } // execution /////////////////////////////////////////////////////////////////// void TScalarVP::execute(void) { - // Get objects cached by ChargedProp module - Complex ci(0.0,1.0); - FFT fft(env().getGrid()); - Real q = static_cast(env().getModule(par().scalarProp))->par().charge; + // CACHING ANALYTIC EXPRESSIONS + makeCaches(); - freeMomProp_ = env().getObject(freeMomPropName_); + Complex ci(0.0,1.0); + Real q = static_cast(vm().getModule(par().scalarProp))->par().charge; + auto &prop0 = envGet(ScalarField, prop0Name_); + auto &propQ = envGet(ScalarField, propQName_); + auto &propSun = envGet(ScalarField, propSunName_); + auto &propTad = envGet(ScalarField, propTadName_); + auto &GFSrc = envGet(ScalarField, GFSrcName_); + auto &G = envGet(ScalarField, freeMomPropName_); + auto &fft = envGet(FFT, fftName_); + phase_.clear(); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - phase_.push_back(env().getObject(phaseName_[mu])); + auto &phmu = envGet(ScalarField, phaseName_[mu]); + phase_.push_back(&phmu); } - GFSrc_ = env().getObject(GFSrcName_); - prop0_ = env().getObject(prop0Name_); - - // Propagator from unshifted source - ScalarField &propQ = *env().getObject(propQName_); - ScalarField &propSun = *env().getObject(propSunName_); - ScalarField &propTad = *env().getObject(propTadName_); - - // Propagators from shifted sources + + // PROPAGATORS FROM SHIFTED SOURCES LOG(Message) << "Computing O(q) charged scalar propagators..." << std::endl; - std::vector muPropQ; + std::vector muPropQ; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - muPropQ.push_back(*env().createLattice(muPropQName_[mu])); + auto &propmu = envGet(ScalarField, muPropQName_[mu]); // -G*momD1*G*F*tau_mu*Src (momD1 = F*D1*Finv) - muPropQ[mu] = adj(*phase_[mu])*(*GFSrc_); - momD1(muPropQ[mu], fft); - muPropQ[mu] = -(*freeMomProp_)*muPropQ[mu]; - fft.FFT_all_dim(muPropQ[mu], muPropQ[mu], FFT::backward); + propmu = adj(*phase_[mu])*GFSrc; + momD1(propmu, fft); + propmu = -G*propmu; + fft.FFT_all_dim(propmu, propmu, FFT::backward); + + muPropQ.push_back(&propmu); } // CONTRACTIONS - ScalarField prop1(env().getGrid()), prop2(env().getGrid()); - EmField &A = *env().getObject(par().emField); - ScalarField Amu(env().getGrid()), U_snk(env().getGrid()); - ScalarField tmp_vp1(env().getGrid()), tmp_vp2(env().getGrid()); - TComplex Anu0, U_src; + auto &A = envGet(EmField, par().emField); + envGetTmp(ScalarField, buf); + envGetTmp(ScalarField, result); + envGetTmp(ScalarField, Amu); + envGetTmp(ScalarField, Usnk); + envGetTmp(ScalarField, tmpProp); + TComplex Anu0, Usrc; std::vector coor0 = {0, 0, 0, 0}; - std::vector > vpTensor; + std::vector > vpTensor; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - std::vector vpTensor_mu; + std::vector vpTensor_mu; for (unsigned int nu = 0; nu < env().getNd(); ++nu) { - vpTensor_mu.push_back(*env().createLattice(vpTensorName_[mu][nu])); + auto &vpmunu = envGet(ScalarField, vpTensorName_[mu][nu]); + vpTensor_mu.push_back(&vpmunu); } vpTensor.push_back(vpTensor_mu); } - // Open output files if necessary - std::vector writer; - std::vector momphases; + // Prepare output files if necessary if (!par().output.empty()) { LOG(Message) << "Preparing output files..." << std::endl; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { std::vector mom = strToVec(par().outputMom[i_p]); - - // Open output files std::string filename = par().output + "_" + std::to_string(mom[0]) + std::to_string(mom[1]) - + std::to_string(mom[2]) + "." - + std::to_string(env().getTrajectory()); - - if (env().getGrid()->IsBoss()) - { - CorrWriter *writer_i = new CorrWriter(filename); - writer.push_back(writer_i); - - write(*writer[i_p], "charge", q); - write(*writer[i_p], "mass", static_cast(env().getModule(par().scalarProp))->par().mass); - } - - // Calculate phase factors - tmp_vp1 = Complex(1.0,0.0); - for (unsigned int j = 0; j < env().getNd()-1; ++j) - { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - tmp_vp1 = tmp_vp1*(*phase_[j]); - } - } - tmp_vp1 = adj(tmp_vp1); - momphases.push_back(tmp_vp1); + + std::to_string(mom[2]); + saveResult(filename, "charge", q); + saveResult(filename, "mass", static_cast(vm().getModule(par().scalarProp))->par().mass); } } @@ -259,142 +264,156 @@ void TScalarVP::execute(void) Amu = peekLorentz(A, mu); // free - prop1 = *prop0_; // S_0(0|x) - prop2 = Cshift(*prop0_, nu, -1); // S_0(0|x-a\hat{\nu}) + tmpProp = Cshift(prop0, nu, -1); // S_0(0|x-a\hat{\nu}) // = S_0(a\hat{\nu}|x) - U_src = Complex(1.0,0.0); - vpContraction(tmp_vp1, prop1, prop2, U_src, mu); - vpTensor[mu][nu] = tmp_vp1; + Usrc = Complex(1.0,0.0); + vpContraction(buf, prop0, tmpProp, Usrc, mu); + *vpTensor[mu][nu] = buf; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp1, momphases, + writeVP(buf, "Pi_free_"+std::to_string(mu)+"_"+std::to_string(nu)); } // srcT - tmp_vp2 = tmp_vp1 * (-0.5)*q*q*Anu0*Anu0; - vpTensor[mu][nu] += tmp_vp2; + result = buf * (-0.5)*q*q*Anu0*Anu0; + *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp2, momphases, + writeVP(result, "Pi_srcT_"+std::to_string(mu)+"_"+std::to_string(nu)); } // snkT - tmp_vp2 = tmp_vp1 * (-0.5)*q*q*Amu*Amu; - vpTensor[mu][nu] += tmp_vp2; + result = buf * (-0.5)*q*q*Amu*Amu; + *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp2, momphases, + writeVP(result, "Pi_snkT_"+std::to_string(mu)+"_"+std::to_string(nu)); } // S - prop1 = *prop0_; // S_0(0|x) - prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) - U_src = ci*q*Anu0; - U_snk = ci*q*Amu; - vpContraction(tmp_vp1, prop1, prop2, U_src, U_snk, mu); - vpTensor[mu][nu] += tmp_vp1; + tmpProp = Cshift(prop0, nu, -1); // S_0(a\hat{\nu}|x) + Usrc = ci*Anu0; + Usnk = ci*Amu; + vpContraction(result, prop0, tmpProp, Usrc, Usnk, mu); + result = q*q*result; + *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp1, momphases, + writeVP(result, "Pi_S_"+std::to_string(mu)+"_"+std::to_string(nu)); } // 4C - prop1 = q*propQ; // q*S_1(0|x) - prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) - U_src = Complex(1.0,0.0); - U_snk = ci*q*Amu; - vpContraction(tmp_vp1, prop1, prop2, U_src, U_snk, mu); - U_src = ci*q*Anu0; - vpContraction(tmp_vp2, prop1, prop2, U_src, mu); - tmp_vp1 += tmp_vp2; - prop1 = *prop0_; // S_0(0|x) - prop2 = q*muPropQ[nu]; // q*S_1(a\hat{\nu}|x) - vpContraction(tmp_vp2, prop1, prop2, U_src, mu); - tmp_vp1 += tmp_vp2; - U_src = Complex(1.0,0.0); - U_snk = ci*q*Amu; - vpContraction(tmp_vp2, prop1, prop2, U_src, U_snk, mu); - tmp_vp1 += tmp_vp2; - vpTensor[mu][nu] += tmp_vp1; + tmpProp = Cshift(prop0, nu, -1); // S_0(a\hat{\nu}|x) + Usrc = Complex(1.0,0.0); + Usnk = ci*Amu; + vpContraction(result, propQ, tmpProp, Usrc, Usnk, mu); + Usrc = ci*Anu0; + vpContraction(buf, propQ, tmpProp, Usrc, mu); + result += buf; + vpContraction(buf, prop0, *muPropQ[nu], Usrc, mu); + result += buf; + Usrc = Complex(1.0,0.0); + Usnk = ci*Amu; + vpContraction(buf, prop0, *muPropQ[nu], Usrc, Usnk, mu); + result += buf; + result = q*q*result; + *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp1, momphases, + writeVP(result, "Pi_4C_"+std::to_string(mu)+"_"+std::to_string(nu)); } // X - prop1 = q*propQ; // q*S_1(0|x) - prop2 = q*muPropQ[nu]; // q*S_1(a\hat{\nu}|x) - U_src = Complex(1.0,0.0); - vpContraction(tmp_vp1, prop1, prop2, U_src, mu); - vpTensor[mu][nu] += tmp_vp1; + Usrc = Complex(1.0,0.0); + vpContraction(result, propQ, *muPropQ[nu], Usrc, mu); + result = q*q*result; + *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp1, momphases, + writeVP(result, "Pi_X_"+std::to_string(mu)+"_"+std::to_string(nu)); } // 2E - prop1 = q*q*propSun; // q^2*S_\Sigma(0|x) - prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) - U_src = Complex(1.0,0.0); - vpContraction(tmp_vp1, prop1, prop2, U_src, mu); - prop1 = *prop0_; // S_0(0|x) - prop2 = q*q*Cshift(propSun, nu, -1); // q^2*S_\Sigma(0|x-a\hat{\nu}) + tmpProp = Cshift(prop0, nu, -1); // S_0(a\hat{\nu}|x) + Usrc = Complex(1.0,0.0); + vpContraction(result, propSun, tmpProp, Usrc, mu); + tmpProp = Cshift(propSun, nu, -1); // S_\Sigma(0|x-a\hat{\nu}) //(Note: = ) - vpContraction(tmp_vp2, prop1, prop2, U_src, mu); - tmp_vp1 += tmp_vp2; - vpTensor[mu][nu] += tmp_vp1; + vpContraction(buf, prop0, tmpProp, Usrc, mu); + result += buf; + result = q*q*result; + *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp1, momphases, + writeVP(result, "Pi_2E_"+std::to_string(mu)+"_"+std::to_string(nu)); } // 2T - prop1 = q*q*propTad; // q^2*S_T(0|x) - prop2 = Cshift(*prop0_, nu, -1); // S_0(a\hat{\nu}|x) - U_src = Complex(1.0,0.0); - vpContraction(tmp_vp1, prop1, prop2, U_src, mu); - prop1 = *prop0_; // S_0(0|x) - prop2 = q*q*Cshift(propTad, nu, -1); // q^2*S_T(0|x-a\hat{\nu}) - vpContraction(tmp_vp2, prop1, prop2, U_src, mu); - tmp_vp1 += tmp_vp2; - vpTensor[mu][nu] += tmp_vp1; + tmpProp = Cshift(prop0, nu, -1); // S_0(a\hat{\nu}|x) + Usrc = Complex(1.0,0.0); + vpContraction(result, propTad, tmpProp, Usrc, mu); + tmpProp = Cshift(propTad, nu, -1); // S_T(0|x-a\hat{\nu}) + vpContraction(buf, prop0, tmpProp, Usrc, mu); + result += buf; + result = q*q*result; + *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, tmp_vp1, momphases, + writeVP(result, "Pi_2T_"+std::to_string(mu)+"_"+std::to_string(nu)); } // Output full VP if necessary if (!par().output.empty()) { - writeVP(writer, vpTensor[mu][nu], momphases, + writeVP(*vpTensor[mu][nu], "Pi_"+std::to_string(mu)+"_"+std::to_string(nu)); } } } - if (!par().output.empty()) +} + +void TScalarVP::makeCaches(void) +{ + envGetTmp(ScalarField, buf); + + if ( (!par().output.empty()) && (!momPhasesDone_) ) { + LOG(Message) << "Caching phases for momentum projections..." + << std::endl; + std::vector &l = env().getGrid()->_fdimensions; + Complex ci(0.0,1.0); + + // Calculate phase factors for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - if (env().getGrid()->IsBoss()) + std::vector mom = strToVec(par().outputMom[i_p]); + auto &momph_ip = envGet(ScalarField, momPhaseName_[i_p]); + momph_ip = zero; + for (unsigned int j = 0; j < env().getNd()-1; ++j) { - delete writer[i_p]; + Real twoPiL = M_PI*2./l[j]; + LatticeCoordinate(buf, j); + buf = mom[j]*twoPiL*buf; + momph_ip = momph_ip + buf; } + momph_ip = exp(-ci*momph_ip); + momPhase_.push_back(&momph_ip); } } } @@ -419,38 +438,40 @@ void TScalarVP::vpContraction(ScalarField &vp, vp = 2.0*real(vp); } -void TScalarVP::writeVP(const std::vector &writers, const ScalarField &vp, - const std::vector &momphases, std::string dsetName) +void TScalarVP::writeVP(const ScalarField &vp, std::string dsetName) { std::vector vecBuf; std::vector result; - ScalarField vpPhase(env().getGrid()); + envGetTmp(ScalarField, buf); - for (unsigned int i_p = 0; i_p < momphases.size(); ++i_p) + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - vpPhase = vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); + std::vector mom = strToVec(par().outputMom[i_p]); + std::string filename = par().output + "_" + + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]); + buf = vp*(*momPhase_[i_p]); + sliceSum(buf, vecBuf, Tp); result.resize(vecBuf.size()); for (unsigned int t = 0; t < vecBuf.size(); ++t) { result[t] = TensorRemove(vecBuf[t]); } - if (env().getGrid()->IsBoss()) - { - write(*writers[i_p], dsetName, result); - } + saveResult(filename, dsetName, result); } } void TScalarVP::momD1(ScalarField &s, FFT &fft) { - EmField &A = *env().getObject(par().emField); - ScalarField buf(env().getGrid()), result(env().getGrid()), - Amu(env().getGrid()); + auto &A = envGet(EmField, par().emField); Complex ci(0.0,1.0); - result = zero; + envGetTmp(ScalarField, buf); + envGetTmp(ScalarField, result); + envGetTmp(ScalarField, Amu); + result = zero; for (unsigned int mu = 0; mu < env().getNd(); ++mu) { Amu = peekLorentz(A, mu); diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 564a7f39..fe351f05 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -8,7 +8,7 @@ BEGIN_HADRONS_NAMESPACE /****************************************************************************** - * ScalarVP * + * Scalar vacuum polarisation * ******************************************************************************/ BEGIN_MODULE_NAMESPACE(MScalar) @@ -36,11 +36,13 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution virtual void execute(void); private: + void makeCaches(void); // conserved vector two-point contraction void vpContraction(ScalarField &vp, ScalarField &prop_0_x, ScalarField &prop_nu_x, @@ -50,22 +52,22 @@ private: ScalarField &prop_0_x, ScalarField &prop_nu_x, TComplex u_src, int mu); // write momentum-projected vacuum polarisation to file(s) - void writeVP(const std::vector &writers, - const ScalarField &vp, - const std::vector &momphases, - std::string dsetName); + void writeVP(const ScalarField &vp, std::string dsetName); // momentum-space Delta_1 insertion void momD1(ScalarField &s, FFT &fft); private: + bool momPhasesDone_; std::string freeMomPropName_, GFSrcName_, prop0Name_, propQName_, - propSunName_, propTadName_; - std::vector phaseName_, muPropQName_; + propSunName_, propTadName_, + fftName_; + std::vector phaseName_, muPropQName_, + momPhaseName_; std::vector > vpTensorName_; - ScalarField *freeMomProp_, *GFSrc_, - *prop0_; - std::vector phase_; - EmField *A; + // ScalarField *freeMomProp_, *GFSrc_, + // *prop0_; + std::vector phase_, momPhase_; + // EmField *A; }; MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); diff --git a/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc b/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc index 17dd1abe..284b3f6c 100644 --- a/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc +++ b/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc @@ -37,39 +37,58 @@ void TVPCounterTerms::setup(void) { phaseName_.push_back("_shiftphase_" + std::to_string(mu)); } - GFSrcName_ = "_" + getName() + "_DinvSrc"; - phatsqName_ = "_" + getName() + "_pHatSquared"; + GFSrcName_ = getName() + "_DinvSrc"; + phatsqName_ = getName() + "_pHatSquared"; prop0Name_ = getName() + "_freeProp"; twoscalarName_ = getName() + "_2scalarProp"; twoscalarVertexName_ = getName() + "_2scalarProp_withvertex"; psquaredName_ = getName() + "_psquaredProp"; - env().registerLattice(freeMomPropName_); + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + momPhaseName_.push_back("_momentumphase_" + std::to_string(i_p)); + } + } + + envCreateLat(ScalarField, freeMomPropName_); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { - env().registerLattice(phaseName_[mu]); + envCreateLat(ScalarField, phaseName_[mu]); } - env().registerLattice(phatsqName_); - env().registerLattice(GFSrcName_); - env().registerLattice(prop0Name_); - env().registerLattice(twoscalarName_); - env().registerLattice(twoscalarVertexName_); - env().registerLattice(psquaredName_); + envCreateLat(ScalarField, phatsqName_); + envCreateLat(ScalarField, GFSrcName_); + envCreateLat(ScalarField, prop0Name_); + envCreateLat(ScalarField, twoscalarName_); + envCreateLat(ScalarField, twoscalarVertexName_); + envCreateLat(ScalarField, psquaredName_); + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + envCacheLat(ScalarField, momPhaseName_[i_p]); + } + } + envTmpLat(ScalarField, "buf"); + envTmpLat(ScalarField, "tmp_vp"); + envTmpLat(ScalarField, "vpPhase"); } // execution /////////////////////////////////////////////////////////////////// void TVPCounterTerms::execute(void) { - ScalarField &source = *env().getObject(par().source); + auto &source = envGet(ScalarField, par().source); Complex ci(0.0,1.0); FFT fft(env().getGrid()); - ScalarField buf(env().getGrid()), tmp_vp(env().getGrid()); + envGetTmp(ScalarField, buf); + envGetTmp(ScalarField, tmp_vp); // Momentum-space free scalar propagator - ScalarField &G = *env().createLattice(freeMomPropName_); + auto &G = envGet(ScalarField, freeMomPropName_); SIMPL::MomentumSpacePropagator(G, par().mass); // Phases and hat{p}^2 - ScalarField &phatsq = *env().createLattice(phatsqName_); + auto &phatsq = envGet(ScalarField, phatsqName_); std::vector &l = env().getGrid()->_fdimensions; LOG(Message) << "Calculating shift phases..." << std::endl; @@ -77,28 +96,29 @@ void TVPCounterTerms::execute(void) for (unsigned int mu = 0; mu < env().getNd(); ++mu) { Real twoPiL = M_PI*2./l[mu]; - - phase_.push_back(env().createLattice(phaseName_[mu])); + auto &phmu = envGet(ScalarField, phaseName_[mu]); + LatticeCoordinate(buf, mu); - *(phase_[mu]) = exp(ci*twoPiL*buf); + phmu = exp(ci*twoPiL*buf); + phase_.push_back(&phmu); buf = 2.*sin(.5*twoPiL*buf); phatsq = phatsq + buf*buf; } // G*F*src - ScalarField &GFSrc = *env().createLattice(GFSrcName_); + auto &GFSrc = envGet(ScalarField, GFSrcName_); fft.FFT_all_dim(GFSrc, source, FFT::forward); GFSrc = G*GFSrc; // Position-space free scalar propagator - ScalarField &prop0 = *env().createLattice(prop0Name_); + auto &prop0 = envGet(ScalarField, prop0Name_); prop0 = GFSrc; fft.FFT_all_dim(prop0, prop0, FFT::backward); // Propagators for counter-terms - ScalarField &twoscalarProp = *env().createLattice(twoscalarName_); - ScalarField &twoscalarVertexProp = *env().createLattice(twoscalarVertexName_); - ScalarField &psquaredProp = *env().createLattice(psquaredName_); + auto &twoscalarProp = envGet(ScalarField, twoscalarName_); + auto &twoscalarVertexProp = envGet(ScalarField, twoscalarVertexName_); + auto &psquaredProp = envGet(ScalarField, psquaredName_); twoscalarProp = G*GFSrc; fft.FFT_all_dim(twoscalarProp, twoscalarProp, FFT::backward); @@ -115,12 +135,7 @@ void TVPCounterTerms::execute(void) psquaredProp = G*phatsq*GFSrc; fft.FFT_all_dim(psquaredProp, psquaredProp, FFT::backward); - // Open output files if necessary - std::vector vecBuf; - std::vector result; - ScalarField vpPhase(env().getGrid()); - std::vector writer; - std::vector momphases; + // Prepare output files if necessary if (!par().output.empty()) { LOG(Message) << "Preparing output files..." << std::endl; @@ -131,29 +146,21 @@ void TVPCounterTerms::execute(void) // Open output files std::string filename = par().output + "_" + std::to_string(mom[0]) + std::to_string(mom[1]) - + std::to_string(mom[2]) - + "." + - std::to_string(env().getTrajectory()); - - if (env().getGrid()->IsBoss()) - { - CorrWriter *writer_i = new CorrWriter(filename); - writer.push_back(writer_i); - - write(*writer[i_p], "mass", par().mass); - } + + std::to_string(mom[2]); + saveResult(filename, "mass", par().mass); // Calculate phase factors - vpPhase = Complex(1.0,0.0); + auto &momph_ip = envGet(ScalarField, momPhaseName_[i_p]); + momph_ip = Complex(1.0,0.0); for (unsigned int j = 0; j < env().getNd()-1; ++j) { for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) { - vpPhase = vpPhase*(*phase_[j]); + momph_ip = momph_ip*(*phase_[j]); } } - vpPhase = adj(vpPhase); - momphases.push_back(vpPhase); + momph_ip = adj(momph_ip); + momPhase_.push_back(&momph_ip); } } @@ -171,22 +178,7 @@ void TVPCounterTerms::execute(void) // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writer[i_p], - "NoVertex_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(tmp_vp, "NoVertex_"+std::to_string(mu)+"_"+std::to_string(nu)); } // Three-scalar loop (tadpole vertex) @@ -197,22 +189,7 @@ void TVPCounterTerms::execute(void) // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writer[i_p], - "TadVertex_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } + writeVP(tmp_vp, "TadVertex_"+std::to_string(mu)+"_"+std::to_string(nu)); } // Three-scalar loop (hat{p}^2 insertion) @@ -223,35 +200,32 @@ void TVPCounterTerms::execute(void) // Output if necessary if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - vpPhase = tmp_vp*momphases[i_p]; - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - if (env().getGrid()->IsBoss()) - { - write(*writer[i_p], - "pSquaredInsertion_"+std::to_string(mu)+"_"+std::to_string(nu), - result); - } - } - } - } - } - - // Close output files if necessary - if (!par().output.empty()) - { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - if (env().getGrid()->IsBoss()) - { - delete writer[i_p]; + writeVP(tmp_vp, "pSquaredInsertion_"+std::to_string(mu)+"_"+std::to_string(nu)); } } } } + +void TVPCounterTerms::writeVP(const ScalarField &vp, std::string dsetName) +{ + std::vector vecBuf; + std::vector result; + envGetTmp(ScalarField, vpPhase); + + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + std::vector mom = strToVec(par().outputMom[i_p]); + std::string filename = par().output + "_" + + std::to_string(mom[0]) + + std::to_string(mom[1]) + + std::to_string(mom[2]); + vpPhase = vp*(*momPhase_[i_p]); + sliceSum(vpPhase, vecBuf, Tp); + result.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + result[t] = TensorRemove(vecBuf[t]); + } + saveResult(filename, dsetName, result); + } +} diff --git a/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp index 6bd6db8e..634206a6 100644 --- a/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp +++ b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp @@ -34,16 +34,19 @@ public: // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); +protected: // setup virtual void setup(void); // execution virtual void execute(void); +private: + void writeVP(const ScalarField &vp, std::string dsetName); private: std::string freeMomPropName_, GFSrcName_, phatsqName_, prop0Name_, twoscalarName_, twoscalarVertexName_, psquaredName_, psquaredVertexName_; - std::vector phaseName_; - std::vector phase_; + std::vector phaseName_, momPhaseName_; + std::vector phase_, momPhase_; }; MODULE_REGISTER_NS(VPCounterTerms, TVPCounterTerms, MScalar); diff --git a/extras/Hadrons/modules.inc b/extras/Hadrons/modules.inc index c149e520..9f642c5b 100644 --- a/extras/Hadrons/modules.inc +++ b/extras/Hadrons/modules.inc @@ -10,7 +10,7 @@ modules_cc =\ Modules/MScalar/ChargedProp.cc \ Modules/MScalar/FreeProp.cc \ Modules/MScalar/ScalarVP.cc \ - Modules/MScalar/VPCounterTerms.cc + Modules/MScalar/VPCounterTerms.cc \ Modules/MIO/LoadNersc.cc modules_hpp =\ From cdf550845fe96e73c8ca5192e4d86d158507eace Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 26 Jan 2018 21:25:20 +0000 Subject: [PATCH 42/57] QedFVol: Fix bugs in StochEm.cc and ChargedProp.cc (still only works without MPI). --- extras/Hadrons/Modules/MGauge/StochEm.cc | 8 ++-- extras/Hadrons/Modules/MGauge/StochEm.hpp | 2 + extras/Hadrons/Modules/MScalar/ChargedProp.cc | 40 ++++++++--------- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 43 +++++++++++-------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 3 +- 5 files changed, 51 insertions(+), 45 deletions(-) diff --git a/extras/Hadrons/Modules/MGauge/StochEm.cc b/extras/Hadrons/Modules/MGauge/StochEm.cc index cea60e84..1c59edee 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.cc +++ b/extras/Hadrons/Modules/MGauge/StochEm.cc @@ -57,10 +57,8 @@ std::vector TStochEm::getOutput(void) // setup /////////////////////////////////////////////////////////////////////// void TStochEm::setup(void) { - if (!env().hasCreatedObject("_" + getName() + "_weight")) - { - envCacheLat(EmComp, "_" + getName() + "_weight"); - } + weightDone_ = env().hasCreatedObject("_" + getName() + "_weight"); + envCacheLat(EmComp, "_" + getName() + "_weight"); envCreateLat(EmField, getName()); } @@ -73,7 +71,7 @@ void TStochEm::execute(void) auto &a = envGet(EmField, getName()); auto &w = envGet(EmComp, "_" + getName() + "_weight"); - if (!env().hasCreatedObject("_" + getName() + "_weight")) + if (!weightDone_) { LOG(Message) << "Caching stochastic EM potential weight (gauge: " << par().gauge << ", zero-mode scheme: " diff --git a/extras/Hadrons/Modules/MGauge/StochEm.hpp b/extras/Hadrons/Modules/MGauge/StochEm.hpp index e3e059de..fa1b6f42 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.hpp +++ b/extras/Hadrons/Modules/MGauge/StochEm.hpp @@ -66,6 +66,8 @@ protected: virtual void setup(void); // execution virtual void execute(void); +private: + bool weightDone_; }; MODULE_REGISTER_NS(StochEm, TStochEm, MGauge); diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 5e65c43e..206734ce 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -117,26 +117,25 @@ void TChargedProp::execute(void) envGetTmp(ScalarField, buf); // -G*momD1*G*F*Src (momD1 = F*D1*Finv) - buf = GFSrc; - momD1(buf, fft); - buf = -G*buf; - fft.FFT_dim(propQ, buf, env().getNd()-1, FFT::backward); + propQ = GFSrc; + momD1(propQ, fft); + propQ = -G*propQ; + propSun = -propQ; + fft.FFT_dim(propQ, propQ, env().getNd()-1, FFT::backward); // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src) - buf = -buf; - momD1(buf, fft); - propSun = G*buf; + momD1(propSun, fft); + propSun = G*propSun; fft.FFT_dim(propSun, propSun, env().getNd()-1, FFT::backward); // -G*momD2*G*F*Src (momD2 = F*D2*Finv) - buf = GFSrc; - momD2(buf, fft); - buf = -G*buf; - fft.FFT_dim(propTad, buf, env().getNd()-1, FFT::backward); + propTad = GFSrc; + momD2(propTad, fft); + propTad = -G*propTad; + fft.FFT_dim(propTad, propTad, env().getNd()-1, FFT::backward); // full charged scalar propagator - buf = GFSrc; - fft.FFT_dim(buf, buf, env().getNd()-1, FFT::backward); + fft.FFT_dim(buf, GFSrc, env().getNd()-1, FFT::backward); prop = buf + q*propQ + q*q*propSun + q*q*propTad; // OUTPUT IF NECESSARY @@ -189,13 +188,14 @@ void TChargedProp::execute(void) peekSite(site, propTad, whichmom); resultTad[t]=TensorRemove(site); } - saveResult(filename, "charge", q); - saveResult(filename, "mass", par().mass); - saveResult(filename, "prop", result); - saveResult(filename, "prop_0", result0); - saveResult(filename, "prop_Q", resultQ); - saveResult(filename, "prop_Sun", resultSun); - saveResult(filename, "prop_Tad", resultTad); + ResultWriter writer(RESULT_FILE_NAME(filename)); + write(writer, "charge", q); + write(writer, "mass", par().mass); + write(writer, "prop", result); + write(writer, "prop_0", result0); + write(writer, "prop_Q", resultQ); + write(writer, "prop_Sun", resultSun); + write(writer, "prop_Tad", resultTad); } } diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 9a6106eb..6be00fd8 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -236,7 +236,8 @@ void TScalarVP::execute(void) vpTensor.push_back(vpTensor_mu); } - // Prepare output files if necessary + // Open output files if necessary + std::vector writer; if (!par().output.empty()) { LOG(Message) << "Preparing output files..." << std::endl; @@ -247,8 +248,10 @@ void TScalarVP::execute(void) + std::to_string(mom[0]) + std::to_string(mom[1]) + std::to_string(mom[2]); - saveResult(filename, "charge", q); - saveResult(filename, "mass", static_cast(vm().getModule(par().scalarProp))->par().mass); + ResultWriter *writer_i = new ResultWriter(RESULT_FILE_NAME(filename)); + writer.push_back(writer_i); + write(*writer_i, "charge", q); + write(*writer_i, "mass", static_cast(vm().getModule(par().scalarProp))->par().mass); } } @@ -272,7 +275,7 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(buf, + writeVP(writer, buf, "Pi_free_"+std::to_string(mu)+"_"+std::to_string(nu)); } @@ -282,7 +285,7 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(result, + writeVP(writer, result, "Pi_srcT_"+std::to_string(mu)+"_"+std::to_string(nu)); } @@ -292,7 +295,7 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(result, + writeVP(writer, result, "Pi_snkT_"+std::to_string(mu)+"_"+std::to_string(nu)); } @@ -306,7 +309,7 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(result, + writeVP(writer, result, "Pi_S_"+std::to_string(mu)+"_"+std::to_string(nu)); } @@ -329,7 +332,7 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(result, + writeVP(writer, result, "Pi_4C_"+std::to_string(mu)+"_"+std::to_string(nu)); } @@ -341,7 +344,7 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(result, + writeVP(writer, result, "Pi_X_"+std::to_string(mu)+"_"+std::to_string(nu)); } @@ -358,7 +361,7 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(result, + writeVP(writer, result, "Pi_2E_"+std::to_string(mu)+"_"+std::to_string(nu)); } @@ -374,18 +377,25 @@ void TScalarVP::execute(void) // Output if necessary if (!par().output.empty()) { - writeVP(result, + writeVP(writer, result, "Pi_2T_"+std::to_string(mu)+"_"+std::to_string(nu)); } // Output full VP if necessary if (!par().output.empty()) { - writeVP(*vpTensor[mu][nu], + writeVP(writer, *vpTensor[mu][nu], "Pi_"+std::to_string(mu)+"_"+std::to_string(nu)); } } } + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + delete writer[i_p]; + } + } } void TScalarVP::makeCaches(void) @@ -438,7 +448,7 @@ void TScalarVP::vpContraction(ScalarField &vp, vp = 2.0*real(vp); } -void TScalarVP::writeVP(const ScalarField &vp, std::string dsetName) +void TScalarVP::writeVP(std::vector &writer, const ScalarField &vp, std::string dsetName) { std::vector vecBuf; std::vector result; @@ -446,11 +456,6 @@ void TScalarVP::writeVP(const ScalarField &vp, std::string dsetName) for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - std::vector mom = strToVec(par().outputMom[i_p]); - std::string filename = par().output + "_" - + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]); buf = vp*(*momPhase_[i_p]); sliceSum(buf, vecBuf, Tp); result.resize(vecBuf.size()); @@ -458,7 +463,7 @@ void TScalarVP::writeVP(const ScalarField &vp, std::string dsetName) { result[t] = TensorRemove(vecBuf[t]); } - saveResult(filename, dsetName, result); + write(*writer[i_p], dsetName, result); } } diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index fe351f05..0839f654 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -52,7 +52,8 @@ private: ScalarField &prop_0_x, ScalarField &prop_nu_x, TComplex u_src, int mu); // write momentum-projected vacuum polarisation to file(s) - void writeVP(const ScalarField &vp, std::string dsetName); + void writeVP(std::vector &writer, const ScalarField &vp, + std::string dsetName); // momentum-space Delta_1 insertion void momD1(ScalarField &s, FFT &fft); private: From 4e0cf0cc286934821eaa333e2b1f640fb54e2b66 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Sat, 27 Jan 2018 15:15:25 +0000 Subject: [PATCH 43/57] QedFVol: Fix bug in ScalarVP.cc due to double use of temporary object. Still getting mpi3 errors when configured with enable-comms=mpi[-auto]. --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index 6be00fd8..a5e00ee0 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -270,17 +270,19 @@ void TScalarVP::execute(void) tmpProp = Cshift(prop0, nu, -1); // S_0(0|x-a\hat{\nu}) // = S_0(a\hat{\nu}|x) Usrc = Complex(1.0,0.0); - vpContraction(buf, prop0, tmpProp, Usrc, mu); - *vpTensor[mu][nu] = buf; + vpContraction(result, prop0, tmpProp, Usrc, mu); + *vpTensor[mu][nu] = result; // Output if necessary if (!par().output.empty()) { - writeVP(writer, buf, + writeVP(writer, result, "Pi_free_"+std::to_string(mu)+"_"+std::to_string(nu)); } + tmpProp = result; // Just using tmpProp as a temporary ScalarField + // here (buf is modified by calls to writeVP()) // srcT - result = buf * (-0.5)*q*q*Anu0*Anu0; + result = tmpProp * (-0.5)*q*q*Anu0*Anu0; *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) @@ -290,7 +292,7 @@ void TScalarVP::execute(void) } // snkT - result = buf * (-0.5)*q*q*Amu*Amu; + result = tmpProp * (-0.5)*q*q*Amu*Amu; *vpTensor[mu][nu] += result; // Output if necessary if (!par().output.empty()) From ac3b0ebc58cbccac051134a06c20686e20c241fd Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 1 Feb 2018 12:31:32 +0000 Subject: [PATCH 44/57] QedFVol: New structure for ChargedProp output files --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 83 ++++++++----------- .../Hadrons/Modules/MScalar/ChargedProp.hpp | 20 +++++ 2 files changed, 56 insertions(+), 47 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 206734ce..5f49c06e 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -114,7 +114,7 @@ void TChargedProp::execute(void) auto &G = envGet(ScalarField, freeMomPropName_); auto &fft = envGet(FFT, fftName_); double q = par().charge; - envGetTmp(ScalarField, buf); + envGetTmp(ScalarField, buf); // -G*momD1*G*F*Src (momD1 = F*D1*Finv) propQ = GFSrc; @@ -141,62 +141,52 @@ void TChargedProp::execute(void) // OUTPUT IF NECESSARY if (!par().output.empty()) { + Result result; + TComplex site; + std::vector siteCoor; + + LOG(Message) << "Saving momentum-projected propagator to '" + << RESULT_FILE_NAME(par().output) << "'..." + << std::endl; + result.projection.resize(par().outputMom.size()); + result.lattice_size = env().getGrid()->_fdimensions; + result.mass = par().mass; + result.charge = q; + siteCoor.resize(env().getNd()); for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - std::vector mom = strToVec(par().outputMom[i_p]); - std::string filename = par().output + "_" - + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]); + result.projection[i_p].momentum = strToVec(par().outputMom[i_p]); - LOG(Message) << "Saving (" << par().outputMom[i_p] - << ") momentum projection to '" << filename << "'..." - << std::endl; + LOG(Message) << "Calculating (" << par().outputMom[i_p] + << ") momentum projection" << std::endl; - std::vector result, result0, resultQ, resultSun, resultTad; - result.resize(env().getGrid()->_fdimensions[env().getNd()-1]); - result0.resize(result.size()); - resultQ.resize(result.size()); - resultSun.resize(result.size()); - resultTad.resize(result.size()); - - TComplex site; - std::vector whichmom; - whichmom.resize(env().getNd()); + result.projection[i_p].corr_0.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + result.projection[i_p].corr.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + result.projection[i_p].corr_Q.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + result.projection[i_p].corr_Sun.resize(env().getGrid()->_fdimensions[env().getNd()-1]); + result.projection[i_p].corr_Tad.resize(env().getGrid()->_fdimensions[env().getNd()-1]); for (unsigned int j = 0; j < env().getNd()-1; ++j) { - whichmom[j] = mom[j]; + siteCoor[j] = result.projection[i_p].momentum[j]; } - for (unsigned int t = 0; t < result.size(); ++t) + for (unsigned int t = 0; t < result.projection[i_p].corr.size(); ++t) { - whichmom[env().getNd()-1] = t; - // Write full propagator - peekSite(site, prop, whichmom); - result[t]=TensorRemove(site); - // Write free propagator - peekSite(site, buf, whichmom); - result0[t]=TensorRemove(site); - // Write propagator O(q) term - peekSite(site, propQ, whichmom); - resultQ[t]=TensorRemove(site); - // Write propagator sunset term - peekSite(site, propSun, whichmom); - resultSun[t]=TensorRemove(site); - // Write propagator tadpole term - peekSite(site, propTad, whichmom); - resultTad[t]=TensorRemove(site); + siteCoor[env().getNd()-1] = t; + peekSite(site, prop, siteCoor); + result.projection[i_p].corr[t]=TensorRemove(site); + peekSite(site, buf, siteCoor); + result.projection[i_p].corr_0[t]=TensorRemove(site); + peekSite(site, propQ, siteCoor); + result.projection[i_p].corr_Q[t]=TensorRemove(site); + peekSite(site, propSun, siteCoor); + result.projection[i_p].corr_Sun[t]=TensorRemove(site); + peekSite(site, propTad, siteCoor); + result.projection[i_p].corr_Tad[t]=TensorRemove(site); } - ResultWriter writer(RESULT_FILE_NAME(filename)); - write(writer, "charge", q); - write(writer, "mass", par().mass); - write(writer, "prop", result); - write(writer, "prop_0", result0); - write(writer, "prop_Q", resultQ); - write(writer, "prop_Sun", resultSun); - write(writer, "prop_Tad", resultTad); } + saveResult(par().output, "prop", result); } std::vector mask(env().getNd(),1); @@ -222,9 +212,8 @@ void TChargedProp::makeCaches(void) } if (!GFSrcDone_) { - FFT fft(env().getGrid()); auto &source = envGet(ScalarField, par().source); - + LOG(Message) << "Caching G*F*src..." << std::endl; fft.FFT_all_dim(GFSrc, source, FFT::forward); GFSrc = freeMomProp*GFSrc; diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index 3a711361..810ebcaa 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -57,6 +57,26 @@ public: SCALAR_TYPE_ALIASES(SIMPL,); typedef PhotonR::GaugeField EmField; typedef PhotonR::GaugeLinkField EmComp; + class Projection: Serializable + { + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(Projection, + std::vector, momentum, + std::vector, corr, + std::vector, corr_0, + std::vector, corr_Q, + std::vector, corr_Sun, + std::vector, corr_Tad); + }; + class Result: Serializable + { + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(Result, + std::vector, lattice_size, + double, mass, + double, charge, + std::vector, projection); + }; public: // constructor TChargedProp(const std::string name); From 5f85473d6b04bc60feae1475798c9f13b4ea92d1 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 1 Feb 2018 12:46:39 +0000 Subject: [PATCH 45/57] QedFVol: Move Projection class into Result class --- .../Hadrons/Modules/MScalar/ChargedProp.hpp | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp index 810ebcaa..baa8c20f 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.hpp +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.hpp @@ -57,20 +57,20 @@ public: SCALAR_TYPE_ALIASES(SIMPL,); typedef PhotonR::GaugeField EmField; typedef PhotonR::GaugeLinkField EmComp; - class Projection: Serializable - { - public: - GRID_SERIALIZABLE_CLASS_MEMBERS(Projection, - std::vector, momentum, - std::vector, corr, - std::vector, corr_0, - std::vector, corr_Q, - std::vector, corr_Sun, - std::vector, corr_Tad); - }; class Result: Serializable { public: + class Projection: Serializable + { + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(Projection, + std::vector, momentum, + std::vector, corr, + std::vector, corr_0, + std::vector, corr_Q, + std::vector, corr_Sun, + std::vector, corr_Tad); + }; GRID_SERIALIZABLE_CLASS_MEMBERS(Result, std::vector, lattice_size, double, mass, From f37ed4958be6d08e2e2538a9aa9ea91afb416a94 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 2 Feb 2018 11:56:51 +0000 Subject: [PATCH 46/57] Implement IR improvement, with coefficients set in input file. --- extras/Hadrons/Modules/MGauge/StochEm.cc | 3 ++- extras/Hadrons/Modules/MGauge/StochEm.hpp | 2 +- extras/Hadrons/Modules/MGauge/UnitEm.cc | 2 +- lib/qcd/action/gauge/Photon.h | 32 +++++------------------ 4 files changed, 11 insertions(+), 28 deletions(-) diff --git a/extras/Hadrons/Modules/MGauge/StochEm.cc b/extras/Hadrons/Modules/MGauge/StochEm.cc index 1c59edee..4c18b968 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.cc +++ b/extras/Hadrons/Modules/MGauge/StochEm.cc @@ -67,7 +67,8 @@ void TStochEm::execute(void) { LOG(Message) << "Generating stochastic EM potential..." << std::endl; - PhotonR photon(par().gauge, par().zmScheme, par().improvement); + std::vector improvements = strToVec(par().improvement); + PhotonR photon(par().gauge, par().zmScheme, improvements); auto &a = envGet(EmField, getName()); auto &w = envGet(EmComp, "_" + getName() + "_weight"); diff --git a/extras/Hadrons/Modules/MGauge/StochEm.hpp b/extras/Hadrons/Modules/MGauge/StochEm.hpp index fa1b6f42..11519b52 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.hpp +++ b/extras/Hadrons/Modules/MGauge/StochEm.hpp @@ -45,7 +45,7 @@ public: GRID_SERIALIZABLE_CLASS_MEMBERS(StochEmPar, PhotonR::Gauge, gauge, PhotonR::ZmScheme, zmScheme, - Integer, improvement); + std::string, improvement); }; class TStochEm: public Module diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.cc b/extras/Hadrons/Modules/MGauge/UnitEm.cc index a19161ac..e23840f5 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.cc +++ b/extras/Hadrons/Modules/MGauge/UnitEm.cc @@ -61,7 +61,7 @@ void TUnitEm::setup(void) // execution /////////////////////////////////////////////////////////////////// void TUnitEm::execute(void) { - PhotonR photon(0, 0, 0); // Just chose arbitrary input values here + PhotonR photon(0, 0, std::vector()); // Just chose arbitrary input values here auto &a = envGet(EmField, getName()); LOG(Message) << "Generating unit EM potential..." << std::endl; photon.UnitField(a); diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index e0329bed..d91a9980 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -60,7 +60,7 @@ namespace QCD{ GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3); GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2); public: - Photon(Gauge gauge, ZmScheme zmScheme, Integer improvement); + Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements); virtual ~Photon(void) = default; void FreePropagator(const GaugeField &in, GaugeField &out); void MomentumSpacePropagator(const GaugeField &in, GaugeField &out); @@ -75,14 +75,14 @@ namespace QCD{ private: Gauge gauge_; ZmScheme zmScheme_; - Integer improvement_; + std::vector improvement_; }; typedef Photon PhotonR; template - Photon::Photon(Gauge gauge, ZmScheme zmScheme, Integer improvement) - : gauge_(gauge), zmScheme_(zmScheme), improvement_(improvement) + Photon::Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements) + : gauge_(gauge), zmScheme_(zmScheme), improvement_(improvements) {} template @@ -157,29 +157,11 @@ namespace QCD{ out = where(spNrm == Integer(0), 0.*out, out); // IR improvement - switch (improvement_) + for(int i = 0; i < improvement_.size(); i++) { - case 0: - break; - case 1: - { - Real f1 = sqrt(2.48560548); - out = where(spNrm == Integer(1), f1*out, out); - break; - } - case 2: - { - Real f1 = sqrt(4.93053406); - Real f2 = sqrt(-1.44492857); - out = where(spNrm == Integer(1), f1*out, out); - out = where(spNrm == Integer(2), f2*out, out); - break; - } - default: - break; + Real f = sqrt(improvement_[i]+1); + out = where(spNrm == Integer(i+1), f*out, out); } - - break; } default: break; From c5b23c367e86a96605b2048c8f27d05e6d7066aa Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 5 Feb 2018 11:46:33 +0000 Subject: [PATCH 47/57] QedFVol: Fix segmentation fault when multiple propagator modules are used. --- extras/Hadrons/Modules/MScalar/ChargedProp.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/extras/Hadrons/Modules/MScalar/ChargedProp.cc b/extras/Hadrons/Modules/MScalar/ChargedProp.cc index 5f49c06e..88c3dffd 100644 --- a/extras/Hadrons/Modules/MScalar/ChargedProp.cc +++ b/extras/Hadrons/Modules/MScalar/ChargedProp.cc @@ -240,6 +240,14 @@ void TChargedProp::makeCaches(void) phase_.push_back(&phmu); } } + else + { + phase_.clear(); + for (unsigned int mu = 0; mu < env().getNd(); ++mu) + { + phase_.push_back(env().getObject(phaseName_[mu])); + } + } } void TChargedProp::momD1(ScalarField &s, FFT &fft) From 594a262dcc911c5df344ffe0837a91779ddeaaed Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 7 Feb 2018 11:37:01 +0000 Subject: [PATCH 48/57] QedFVol: Remove redundant file Communicator_mpi.cc --- lib/communicator/Communicator_mpi.cc | 251 --------------------------- 1 file changed, 251 deletions(-) delete mode 100644 lib/communicator/Communicator_mpi.cc diff --git a/lib/communicator/Communicator_mpi.cc b/lib/communicator/Communicator_mpi.cc deleted file mode 100644 index e123aaa4..00000000 --- a/lib/communicator/Communicator_mpi.cc +++ /dev/null @@ -1,251 +0,0 @@ - /************************************************************************************* - - Grid physics library, www.github.com/paboyle/Grid - - Source file: ./lib/communicator/Communicator_mpi.cc - - Copyright (C) 2015 - -Author: Peter Boyle - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License along - with this program; if not, write to the Free Software Foundation, Inc., - 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - - See the full license in the file "LICENSE" in the top level distribution directory - *************************************************************************************/ - /* END LEGAL */ -#include -#include -#include -#include - -namespace Grid { - - -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Info that is setup once and indept of cartesian layout -/////////////////////////////////////////////////////////////////////////////////////////////////// -MPI_Comm CartesianCommunicator::communicator_world; - -// Should error check all MPI calls. -void CartesianCommunicator::Init(int *argc, char ***argv) { - int flag; - int provided; - MPI_Initialized(&flag); // needed to coexist with other libs apparently - if ( !flag ) { - MPI_Init_thread(argc,argv,MPI_THREAD_MULTIPLE,&provided); - if ( provided != MPI_THREAD_MULTIPLE ) { - QCD::WilsonKernelsStatic::Comms = QCD::WilsonKernelsStatic::CommsThenCompute; - } - } - MPI_Comm_dup (MPI_COMM_WORLD,&communicator_world); - ShmInitGeneric(); -} - -CartesianCommunicator::~CartesianCommunicator() -{ - // int MPI_is_finalised; - // MPI_Finalized(&MPI_is_finalised); - if (communicator && !MPI::Is_finalized()) - MPI_Comm_free(&communicator); -} - -void CartesianCommunicator::GlobalSum(uint32_t &u){ - int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT32_T,MPI_SUM,communicator); - assert(ierr==0); -} -void CartesianCommunicator::GlobalSum(uint64_t &u){ - int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT64_T,MPI_SUM,communicator); - assert(ierr==0); -} -void CartesianCommunicator::GlobalXOR(uint32_t &u){ - int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT32_T,MPI_BXOR,communicator); - assert(ierr==0); -} -void CartesianCommunicator::GlobalXOR(uint64_t &u){ - int ierr=MPI_Allreduce(MPI_IN_PLACE,&u,1,MPI_UINT64_T,MPI_BXOR,communicator); - assert(ierr==0); -} -void CartesianCommunicator::GlobalSum(float &f){ - int ierr=MPI_Allreduce(MPI_IN_PLACE,&f,1,MPI_FLOAT,MPI_SUM,communicator); - assert(ierr==0); -} -void CartesianCommunicator::GlobalSumVector(float *f,int N) -{ - int ierr=MPI_Allreduce(MPI_IN_PLACE,f,N,MPI_FLOAT,MPI_SUM,communicator); - assert(ierr==0); -} -void CartesianCommunicator::GlobalSum(double &d) -{ - int ierr = MPI_Allreduce(MPI_IN_PLACE,&d,1,MPI_DOUBLE,MPI_SUM,communicator); - assert(ierr==0); -} -void CartesianCommunicator::GlobalSumVector(double *d,int N) -{ - int ierr = MPI_Allreduce(MPI_IN_PLACE,d,N,MPI_DOUBLE,MPI_SUM,communicator); - assert(ierr==0); -} -void CartesianCommunicator::ShiftedRanks(int dim,int shift,int &source,int &dest) -{ - int ierr=MPI_Cart_shift(communicator,dim,shift,&source,&dest); - assert(ierr==0); -} -int CartesianCommunicator::RankFromProcessorCoor(std::vector &coor) -{ - int rank; - int ierr=MPI_Cart_rank (communicator, &coor[0], &rank); - assert(ierr==0); - return rank; -} -void CartesianCommunicator::ProcessorCoorFromRank(int rank, std::vector &coor) -{ - coor.resize(_ndimension); - int ierr=MPI_Cart_coords (communicator, rank, _ndimension,&coor[0]); - assert(ierr==0); -} - -// Basic Halo comms primitive -void CartesianCommunicator::SendToRecvFrom(void *xmit, - int dest, - void *recv, - int from, - int bytes) -{ - std::vector reqs(0); - SendToRecvFromBegin(reqs,xmit,dest,recv,from,bytes); - SendToRecvFromComplete(reqs); -} - -void CartesianCommunicator::SendRecvPacket(void *xmit, - void *recv, - int sender, - int receiver, - int bytes) -{ - MPI_Status stat; - assert(sender != receiver); - int tag = sender; - if ( _processor == sender ) { - MPI_Send(xmit, bytes, MPI_CHAR,receiver,tag,communicator); - } - if ( _processor == receiver ) { - MPI_Recv(recv, bytes, MPI_CHAR,sender,tag,communicator,&stat); - } -} - -// Basic Halo comms primitive -void CartesianCommunicator::SendToRecvFromBegin(std::vector &list, - void *xmit, - int dest, - void *recv, - int from, - int bytes) -{ - int myrank = _processor; - int ierr; - if ( CommunicatorPolicy == CommunicatorPolicyConcurrent ) { - MPI_Request xrq; - MPI_Request rrq; - - ierr =MPI_Irecv(recv, bytes, MPI_CHAR,from,from,communicator,&rrq); - ierr|=MPI_Isend(xmit, bytes, MPI_CHAR,dest,_processor,communicator,&xrq); - - assert(ierr==0); - list.push_back(xrq); - list.push_back(rrq); - } else { - // Give the CPU to MPI immediately; can use threads to overlap optionally - ierr=MPI_Sendrecv(xmit,bytes,MPI_CHAR,dest,myrank, - recv,bytes,MPI_CHAR,from, from, - communicator,MPI_STATUS_IGNORE); - assert(ierr==0); - } -} -void CartesianCommunicator::SendToRecvFromComplete(std::vector &list) -{ - if ( CommunicatorPolicy == CommunicatorPolicyConcurrent ) { - int nreq=list.size(); - std::vector status(nreq); - int ierr = MPI_Waitall(nreq,&list[0],&status[0]); - assert(ierr==0); - } -} - -void CartesianCommunicator::Barrier(void) -{ - int ierr = MPI_Barrier(communicator); - assert(ierr==0); -} - -void CartesianCommunicator::Broadcast(int root,void* data, int bytes) -{ - int ierr=MPI_Bcast(data, - bytes, - MPI_BYTE, - root, - communicator); - assert(ierr==0); -} -void CartesianCommunicator::AllToAll(int dim,void *in,void *out,uint64_t words,uint64_t bytes) -{ - std::vector row(_ndimension,1); - assert(dim>=0 && dim<_ndimension); - - // Split the communicator - row[dim] = _processors[dim]; - - CartesianCommunicator Comm(row,*this); - Comm.AllToAll(in,out,words,bytes); -} -void CartesianCommunicator::AllToAll(void *in,void *out,uint64_t words,uint64_t bytes) -{ - // MPI is a pain and uses "int" arguments - // 64*64*64*128*16 == 500Million elements of data. - // When 24*4 bytes multiples get 50x 10^9 >>> 2x10^9 Y2K bug. - // (Turns up on 32^3 x 64 Gparity too) - MPI_Datatype object; - int iwords; - int ibytes; - iwords = words; - ibytes = bytes; - assert(words == iwords); // safe to cast to int ? - assert(bytes == ibytes); // safe to cast to int ? - MPI_Type_contiguous(ibytes,MPI_BYTE,&object); - MPI_Type_commit(&object); - MPI_Alltoall(in,iwords,object,out,iwords,object,communicator); - MPI_Type_free(&object); -} - /////////////////////////////////////////////////////// - // Should only be used prior to Grid Init finished. - // Check for this? - /////////////////////////////////////////////////////// -int CartesianCommunicator::RankWorld(void){ - int r; - MPI_Comm_rank(communicator_world,&r); - return r; -} -void CartesianCommunicator::BroadcastWorld(int root,void* data, int bytes) -{ - int ierr= MPI_Bcast(data, - bytes, - MPI_BYTE, - root, - communicator_world); - assert(ierr==0); -} - - - -} - From 9f202782c5da060acc337e247434ed74a916b2cc Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 7 Feb 2018 20:31:50 +0000 Subject: [PATCH 49/57] QedFVol: Change format of scalar VP output files, and save diagrams without charge factors for consistency with ChargedProp module. --- extras/Hadrons/Modules/MScalar/ScalarVP.cc | 171 ++++++++++++-------- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 31 +++- 2 files changed, 129 insertions(+), 73 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.cc b/extras/Hadrons/Modules/MScalar/ScalarVP.cc index a5e00ee0..fdb9586e 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.cc +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.cc @@ -236,22 +236,38 @@ void TScalarVP::execute(void) vpTensor.push_back(vpTensor_mu); } - // Open output files if necessary - std::vector writer; + // Prepare output data structure if necessary + Result outputData; if (!par().output.empty()) { - LOG(Message) << "Preparing output files..." << std::endl; + outputData.projection.resize(par().outputMom.size()); + outputData.lattice_size = env().getGrid()->_fdimensions; + outputData.mass = static_cast(vm().getModule(par().scalarProp))->par().mass; + outputData.charge = q; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - std::vector mom = strToVec(par().outputMom[i_p]); - std::string filename = par().output + "_" - + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]); - ResultWriter *writer_i = new ResultWriter(RESULT_FILE_NAME(filename)); - writer.push_back(writer_i); - write(*writer_i, "charge", q); - write(*writer_i, "mass", static_cast(vm().getModule(par().scalarProp))->par().mass); + outputData.projection[i_p].momentum = strToVec(par().outputMom[i_p]); + outputData.projection[i_p].pi.resize(env().getNd()); + outputData.projection[i_p].pi_free.resize(env().getNd()); + outputData.projection[i_p].pi_2E.resize(env().getNd()); + outputData.projection[i_p].pi_2T.resize(env().getNd()); + outputData.projection[i_p].pi_S.resize(env().getNd()); + outputData.projection[i_p].pi_4C.resize(env().getNd()); + outputData.projection[i_p].pi_X.resize(env().getNd()); + outputData.projection[i_p].pi_srcT.resize(env().getNd()); + outputData.projection[i_p].pi_snkT.resize(env().getNd()); + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + outputData.projection[i_p].pi[nu].resize(env().getNd()); + outputData.projection[i_p].pi_free[nu].resize(env().getNd()); + outputData.projection[i_p].pi_2E[nu].resize(env().getNd()); + outputData.projection[i_p].pi_2T[nu].resize(env().getNd()); + outputData.projection[i_p].pi_S[nu].resize(env().getNd()); + outputData.projection[i_p].pi_4C[nu].resize(env().getNd()); + outputData.projection[i_p].pi_X[nu].resize(env().getNd()); + outputData.projection[i_p].pi_srcT[nu].resize(env().getNd()); + outputData.projection[i_p].pi_snkT[nu].resize(env().getNd()); + } } } @@ -272,33 +288,42 @@ void TScalarVP::execute(void) Usrc = Complex(1.0,0.0); vpContraction(result, prop0, tmpProp, Usrc, mu); *vpTensor[mu][nu] = result; - // Output if necessary + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_free_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_free[mu][nu], result, + i_p); + } } tmpProp = result; // Just using tmpProp as a temporary ScalarField // here (buf is modified by calls to writeVP()) // srcT - result = tmpProp * (-0.5)*q*q*Anu0*Anu0; - *vpTensor[mu][nu] += result; - // Output if necessary + result = tmpProp * (-0.5)*Anu0*Anu0; + *vpTensor[mu][nu] += q*q*result; + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_srcT_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_srcT[mu][nu], result, + i_p); + } } // snkT - result = tmpProp * (-0.5)*q*q*Amu*Amu; - *vpTensor[mu][nu] += result; - // Output if necessary + result = tmpProp * (-0.5)*Amu*Amu; + *vpTensor[mu][nu] += q*q*result; + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_snkT_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_snkT[mu][nu], result, + i_p); + } } // S @@ -306,13 +331,15 @@ void TScalarVP::execute(void) Usrc = ci*Anu0; Usnk = ci*Amu; vpContraction(result, prop0, tmpProp, Usrc, Usnk, mu); - result = q*q*result; - *vpTensor[mu][nu] += result; - // Output if necessary + *vpTensor[mu][nu] += q*q*result; + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_S_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_S[mu][nu], result, + i_p); + } } // 4C @@ -329,25 +356,29 @@ void TScalarVP::execute(void) Usnk = ci*Amu; vpContraction(buf, prop0, *muPropQ[nu], Usrc, Usnk, mu); result += buf; - result = q*q*result; - *vpTensor[mu][nu] += result; - // Output if necessary + *vpTensor[mu][nu] += q*q*result; + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_4C_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_4C[mu][nu], result, + i_p); + } } // X Usrc = Complex(1.0,0.0); vpContraction(result, propQ, *muPropQ[nu], Usrc, mu); - result = q*q*result; - *vpTensor[mu][nu] += result; - // Output if necessary + *vpTensor[mu][nu] += q*q*result; + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_X_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_X[mu][nu], result, + i_p); + } } // 2E @@ -358,13 +389,15 @@ void TScalarVP::execute(void) //(Note: = ) vpContraction(buf, prop0, tmpProp, Usrc, mu); result += buf; - result = q*q*result; - *vpTensor[mu][nu] += result; - // Output if necessary + *vpTensor[mu][nu] += q*q*result; + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_2E_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_2E[mu][nu], result, + i_p); + } } // 2T @@ -374,29 +407,36 @@ void TScalarVP::execute(void) tmpProp = Cshift(propTad, nu, -1); // S_T(0|x-a\hat{\nu}) vpContraction(buf, prop0, tmpProp, Usrc, mu); result += buf; - result = q*q*result; - *vpTensor[mu][nu] += result; - // Output if necessary + *vpTensor[mu][nu] += q*q*result; + // Do momentum projections if necessary if (!par().output.empty()) { - writeVP(writer, result, - "Pi_2T_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi_2T[mu][nu], result, + i_p); + } } - // Output full VP if necessary + // Do momentum projections of full VP if necessary if (!par().output.empty()) { - writeVP(writer, *vpTensor[mu][nu], - "Pi_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pi[mu][nu], + *vpTensor[mu][nu], i_p); + } } } } + + // OUTPUT IF NECESSARY if (!par().output.empty()) { - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) - { - delete writer[i_p]; - } + LOG(Message) << "Saving momentum-projected HVP to '" + << RESULT_FILE_NAME(par().output) << "'..." + << std::endl; + saveResult(par().output, "HVP", outputData); } } @@ -450,22 +490,17 @@ void TScalarVP::vpContraction(ScalarField &vp, vp = 2.0*real(vp); } -void TScalarVP::writeVP(std::vector &writer, const ScalarField &vp, std::string dsetName) +void TScalarVP::project(std::vector &projection, const ScalarField &vp, int i_p) { std::vector vecBuf; - std::vector result; envGetTmp(ScalarField, buf); - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + buf = vp*(*momPhase_[i_p]); + sliceSum(buf, vecBuf, Tp); + projection.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) { - buf = vp*(*momPhase_[i_p]); - sliceSum(buf, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - write(*writer[i_p], dsetName, result); + projection[t] = TensorRemove(vecBuf[t]); } } diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 0839f654..8e18f80e 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -28,6 +28,30 @@ public: SCALAR_TYPE_ALIASES(SIMPL,); typedef PhotonR::GaugeField EmField; typedef PhotonR::GaugeLinkField EmComp; + class Result: Serializable + { + public: + class Projection: Serializable + { + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(Projection, + std::vector, momentum, + std::vector>>, pi, + std::vector>>, pi_free, + std::vector>>, pi_2E, + std::vector>>, pi_2T, + std::vector>>, pi_S, + std::vector>>, pi_4C, + std::vector>>, pi_X, + std::vector>>, pi_srcT, + std::vector>>, pi_snkT); + }; + GRID_SERIALIZABLE_CLASS_MEMBERS(Result, + std::vector, lattice_size, + double, mass, + double, charge, + std::vector, projection); + }; public: // constructor TScalarVP(const std::string name); @@ -52,8 +76,8 @@ private: ScalarField &prop_0_x, ScalarField &prop_nu_x, TComplex u_src, int mu); // write momentum-projected vacuum polarisation to file(s) - void writeVP(std::vector &writer, const ScalarField &vp, - std::string dsetName); + void project(std::vector &projection, const ScalarField &vp, + int i_p); // momentum-space Delta_1 insertion void momD1(ScalarField &s, FFT &fft); private: @@ -65,10 +89,7 @@ private: std::vector phaseName_, muPropQName_, momPhaseName_; std::vector > vpTensorName_; - // ScalarField *freeMomProp_, *GFSrc_, - // *prop0_; std::vector phase_, momPhase_; - // EmField *A; }; MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); From 315f1146cd9acad43a571a6a081a724e0d372278 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Thu, 8 Feb 2018 20:40:45 +0000 Subject: [PATCH 50/57] QedFVol: Fix output of VPCounterTerms module. --- .../Hadrons/Modules/MScalar/VPCounterTerms.cc | 129 +++++++++--------- .../Modules/MScalar/VPCounterTerms.hpp | 19 ++- 2 files changed, 83 insertions(+), 65 deletions(-) diff --git a/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc b/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc index 284b3f6c..b3393679 100644 --- a/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc +++ b/extras/Hadrons/Modules/MScalar/VPCounterTerms.cc @@ -41,7 +41,6 @@ void TVPCounterTerms::setup(void) phatsqName_ = getName() + "_pHatSquared"; prop0Name_ = getName() + "_freeProp"; twoscalarName_ = getName() + "_2scalarProp"; - twoscalarVertexName_ = getName() + "_2scalarProp_withvertex"; psquaredName_ = getName() + "_psquaredProp"; if (!par().output.empty()) { @@ -60,7 +59,6 @@ void TVPCounterTerms::setup(void) envCreateLat(ScalarField, GFSrcName_); envCreateLat(ScalarField, prop0Name_); envCreateLat(ScalarField, twoscalarName_); - envCreateLat(ScalarField, twoscalarVertexName_); envCreateLat(ScalarField, psquaredName_); if (!par().output.empty()) { @@ -117,49 +115,44 @@ void TVPCounterTerms::execute(void) // Propagators for counter-terms auto &twoscalarProp = envGet(ScalarField, twoscalarName_); - auto &twoscalarVertexProp = envGet(ScalarField, twoscalarVertexName_); auto &psquaredProp = envGet(ScalarField, psquaredName_); twoscalarProp = G*GFSrc; fft.FFT_all_dim(twoscalarProp, twoscalarProp, FFT::backward); - twoscalarVertexProp = zero; - for (unsigned int mu = 0; mu < env().getNd(); ++mu) - { - buf = GFSrc; - twoscalarVertexProp = twoscalarVertexProp + .5*((*phase_[mu]) + adj(*phase_[mu]))*buf; - } - twoscalarVertexProp = G*twoscalarVertexProp; - fft.FFT_all_dim(twoscalarVertexProp, twoscalarVertexProp, FFT::backward); - psquaredProp = G*phatsq*GFSrc; fft.FFT_all_dim(psquaredProp, psquaredProp, FFT::backward); - // Prepare output files if necessary + // Prepare output data structure if necessary + Result outputData; if (!par().output.empty()) { - LOG(Message) << "Preparing output files..." << std::endl; + outputData.projection.resize(par().outputMom.size()); + outputData.lattice_size = env().getGrid()->_fdimensions; + outputData.mass = par().mass; for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) { - std::vector mom = strToVec(par().outputMom[i_p]); - - // Open output files - std::string filename = par().output + "_" + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]); - saveResult(filename, "mass", par().mass); - + outputData.projection[i_p].momentum = strToVec(par().outputMom[i_p]); + outputData.projection[i_p].twoScalar.resize(env().getNd()); + outputData.projection[i_p].threeScalar.resize(env().getNd()); + outputData.projection[i_p].pSquaredInsertion.resize(env().getNd()); + for (unsigned int nu = 0; nu < env().getNd(); ++nu) + { + outputData.projection[i_p].twoScalar[nu].resize(env().getNd()); + outputData.projection[i_p].threeScalar[nu].resize(env().getNd()); + outputData.projection[i_p].pSquaredInsertion[nu].resize(env().getNd()); + } // Calculate phase factors auto &momph_ip = envGet(ScalarField, momPhaseName_[i_p]); - momph_ip = Complex(1.0,0.0); + momph_ip = zero; for (unsigned int j = 0; j < env().getNd()-1; ++j) { - for (unsigned int momcount = 0; momcount < mom[j]; ++momcount) - { - momph_ip = momph_ip*(*phase_[j]); - } + Real twoPiL = M_PI*2./l[j]; + LatticeCoordinate(buf, j); + buf = outputData.projection[i_p].momentum[j]*twoPiL*buf; + momph_ip = momph_ip + buf; } - momph_ip = adj(momph_ip); + momph_ip = exp(-ci*momph_ip); momPhase_.push_back(&momph_ip); } } @@ -170,62 +163,70 @@ void TVPCounterTerms::execute(void) buf = adj(Cshift(prop0, nu, -1)); for (unsigned int mu = 0; mu < env().getNd(); ++mu) { + // Two-scalar loop + tmp_vp = buf * Cshift(prop0, mu, 1); + tmp_vp -= Cshift(buf, mu, 1) * prop0; + tmp_vp = 2.0*real(tmp_vp); + // Output if necessary + if (!par().output.empty()) + { + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].twoScalar[mu][nu], + tmp_vp, i_p); + } + } + // Three-scalar loop (no vertex) tmp_vp = buf * Cshift(twoscalarProp, mu, 1); tmp_vp -= Cshift(buf, mu, 1) * twoscalarProp; tmp_vp = 2.0*real(tmp_vp); - // Output if necessary if (!par().output.empty()) { - writeVP(tmp_vp, "NoVertex_"+std::to_string(mu)+"_"+std::to_string(nu)); - } - - // Three-scalar loop (tadpole vertex) - tmp_vp = buf * Cshift(twoscalarVertexProp, mu, 1); - tmp_vp -= Cshift(buf, mu, 1) * twoscalarVertexProp; - tmp_vp = 2.0*real(tmp_vp); - - // Output if necessary - if (!par().output.empty()) - { - writeVP(tmp_vp, "TadVertex_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].threeScalar[mu][nu], + tmp_vp, i_p); + } } // Three-scalar loop (hat{p}^2 insertion) tmp_vp = buf * Cshift(psquaredProp, mu, 1); tmp_vp -= Cshift(buf, mu, 1) * psquaredProp; tmp_vp = 2.0*real(tmp_vp); - // Output if necessary if (!par().output.empty()) { - writeVP(tmp_vp, "pSquaredInsertion_"+std::to_string(mu)+"_"+std::to_string(nu)); + for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + { + project(outputData.projection[i_p].pSquaredInsertion[mu][nu], + tmp_vp, i_p); + } } } } -} -void TVPCounterTerms::writeVP(const ScalarField &vp, std::string dsetName) -{ - std::vector vecBuf; - std::vector result; - envGetTmp(ScalarField, vpPhase); - - for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p) + // OUTPUT IF NECESSARY + if (!par().output.empty()) { - std::vector mom = strToVec(par().outputMom[i_p]); - std::string filename = par().output + "_" - + std::to_string(mom[0]) - + std::to_string(mom[1]) - + std::to_string(mom[2]); - vpPhase = vp*(*momPhase_[i_p]); - sliceSum(vpPhase, vecBuf, Tp); - result.resize(vecBuf.size()); - for (unsigned int t = 0; t < vecBuf.size(); ++t) - { - result[t] = TensorRemove(vecBuf[t]); - } - saveResult(filename, dsetName, result); + LOG(Message) << "Saving momentum-projected correlators to '" + << RESULT_FILE_NAME(par().output) << "'..." + << std::endl; + saveResult(par().output, "scalar_loops", outputData); + } +} + +void TVPCounterTerms::project(std::vector &projection, const ScalarField &vp, int i_p) +{ + std::vector vecBuf; + envGetTmp(ScalarField, vpPhase); + + vpPhase = vp*(*momPhase_[i_p]); + sliceSum(vpPhase, vecBuf, Tp); + projection.resize(vecBuf.size()); + for (unsigned int t = 0; t < vecBuf.size(); ++t) + { + projection[t] = TensorRemove(vecBuf[t]); } } diff --git a/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp index 634206a6..a0c3688d 100644 --- a/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp +++ b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp @@ -26,6 +26,23 @@ class TVPCounterTerms: public Module { public: SCALAR_TYPE_ALIASES(SIMPL,); + class Result: Serializable + { + public: + class Projection: Serializable + { + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(Projection, + std::vector, momentum, + std::vector>>, twoScalar, + std::vector>>, threeScalar, + std::vector>>, pSquaredInsertion); + }; + GRID_SERIALIZABLE_CLASS_MEMBERS(Result, + std::vector, lattice_size, + double, mass, + std::vector, projection); + }; public: // constructor TVPCounterTerms(const std::string name); @@ -40,7 +57,7 @@ protected: // execution virtual void execute(void); private: - void writeVP(const ScalarField &vp, std::string dsetName); + void project(std::vector &projection, const ScalarField &vp, int i_p); private: std::string freeMomPropName_, GFSrcName_, phatsqName_, prop0Name_, twoscalarName_, twoscalarVertexName_, From 724cf02d4aa06e2f7f4f98feb31b9460fa232a4f Mon Sep 17 00:00:00 2001 From: James Harrison Date: Mon, 12 Feb 2018 17:18:10 +0000 Subject: [PATCH 51/57] QedFVol: Implement infinite-volume photon --- lib/qcd/action/gauge/Photon.h | 113 +++++++++++++++++++++++++++++----- 1 file changed, 97 insertions(+), 16 deletions(-) diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index d91a9980..76211b06 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -58,7 +58,7 @@ namespace QCD{ public: INHERIT_GIMPL_TYPES(Gimpl); GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3); - GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2); + GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2, qedInf, 3); public: Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements); virtual ~Photon(void) = default; @@ -70,6 +70,7 @@ namespace QCD{ const GaugeLinkField &weight); void UnitField(GaugeField &out); private: + void infVolPropagator(GaugeLinkField &out); void invKHatSquared(GaugeLinkField &out); void zmSub(GaugeLinkField &out); private: @@ -97,6 +98,33 @@ namespace QCD{ MomentumSpacePropagator(prop_k,in_k); theFFT.FFT_all_dim(out,prop_k,FFT::backward); } + + template + void Photon::infVolPropagator(GaugeLinkField &out) + { + auto *grid = dynamic_cast(out._grid); + LatticeReal xmu(grid); + GaugeLinkField one(grid); + const unsigned int nd = grid->_ndimension; + std::vector &l = grid->_fdimensions; + std::vector x0(nd,0); + TComplex Tone = Complex(1.0,0.0); + TComplex Tzero = Complex(0.0,0.0); + FFT fft(grid); + + one = Complex(1.0,0.0); + out = zero; + for(int mu = 0; mu < nd; mu++) + { + LatticeCoordinate(xmu,mu); + xmu = where(xmu < l[mu]/2.0, xmu, xmu-double(l[mu])); + out = out + toComplex(4*M_PI*M_PI*xmu*xmu); + } + pokeSite(Tone, out, x0); + out = one/out; + pokeSite(Tzero, out, x0); + fft.FFT_all_dim(out, out, FFT::forward); + } template void Photon::invKHatSquared(GaugeLinkField &out) @@ -172,13 +200,28 @@ namespace QCD{ void Photon::MomentumSpacePropagator(const GaugeField &in, GaugeField &out) { - GridBase *grid = out._grid; - LatticeComplex k2Inv(grid); + GridBase *grid = out._grid; + LatticeComplex momProp(grid); - invKHatSquared(k2Inv); - zmSub(k2Inv); + switch (zmScheme_) + { + case ZmScheme::qedTL: + case ZmScheme::qedL: + { + invKHatSquared(momProp); + zmSub(momProp); + break; + } + case ZmScheme::qedInf: + { + infVolPropagator(momProp); + break; + } + default: + break; + } - out = in*k2Inv; + out = in*momProp; } template @@ -188,14 +231,30 @@ namespace QCD{ const unsigned int nd = grid->_ndimension; std::vector latt_size = grid->_fdimensions; - Integer vol = 1; - for(int d = 0; d < nd; d++) + switch (zmScheme_) { - vol = vol * latt_size[d]; + case ZmScheme::qedTL: + case ZmScheme::qedL: + { + Integer vol = 1; + for(int d = 0; d < nd; d++) + { + vol = vol * latt_size[d]; + } + invKHatSquared(weight); + weight = sqrt(vol*real(weight)); + zmSub(weight); + break; + } + case ZmScheme::qedInf: + { + infVolPropagator(weight); + weight = sqrt(real(weight)); + break; + } + default: + break; } - invKHatSquared(weight); - weight = sqrt(vol*real(weight)); - zmSub(weight); } template @@ -218,12 +277,34 @@ namespace QCD{ GaugeField aTilde(grid); FFT fft(grid); - for(int mu = 0; mu < nd; mu++) + switch (zmScheme_) { - gaussian(rng, r); - r = weight*r; - pokeLorentz(aTilde, r, mu); + case ZmScheme::qedTL: + case ZmScheme::qedL: + { + for(int mu = 0; mu < nd; mu++) + { + gaussian(rng, r); + r = weight*r; + pokeLorentz(aTilde, r, mu); + } + break; + } + case ZmScheme::qedInf: + { + Complex shift(1., 1.); // This needs to be a GaugeLink element? + for(int mu = 0; mu < nd; mu++) + { + bernoulli(rng, r); + r = weight*(2.*r - shift); + pokeLorentz(aTilde, r, mu); + } + break; + } + default: + break; } + fft.FFT_all_dim(out, aTilde, FFT::backward); out = real(out); From 4680a977c3e961f949eed3b8ee1116f8839197b5 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 14 Feb 2018 16:30:09 +0000 Subject: [PATCH 52/57] QedFVol: set infinite-volume photon propagator to 1 at x=0, so that momentum-spage photon propagator is non-negative. Need to check whether this is sufficient for all volumes. --- lib/qcd/action/gauge/Photon.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index 76211b06..4f86deb2 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -109,7 +109,7 @@ namespace QCD{ std::vector &l = grid->_fdimensions; std::vector x0(nd,0); TComplex Tone = Complex(1.0,0.0); - TComplex Tzero = Complex(0.0,0.0); + // TComplex Tzero = Complex(0.0,0.0); FFT fft(grid); one = Complex(1.0,0.0); @@ -122,7 +122,7 @@ namespace QCD{ } pokeSite(Tone, out, x0); out = one/out; - pokeSite(Tzero, out, x0); + // pokeSite(Tzero, out, x0); fft.FFT_all_dim(out, out, FFT::forward); } From 69e4ecc1d27c76c79d2e8951d75961ba1e002347 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Wed, 14 Feb 2018 17:37:18 +0000 Subject: [PATCH 53/57] QedFVol: Fix single precision build error --- lib/qcd/action/gauge/Photon.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index 4f86deb2..2bdf70dd 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -117,7 +117,8 @@ namespace QCD{ for(int mu = 0; mu < nd; mu++) { LatticeCoordinate(xmu,mu); - xmu = where(xmu < l[mu]/2.0, xmu, xmu-double(l[mu])); + Real lo2 = l[mu]/2.0; + xmu = where(xmu < lo2, xmu, xmu-double(l[mu])); out = out + toComplex(4*M_PI*M_PI*xmu*xmu); } pokeSite(Tone, out, x0); From ec3954ff5f1549ef43f8c81b57565f3990c910cb Mon Sep 17 00:00:00 2001 From: James Harrison Date: Fri, 23 Feb 2018 14:53:05 +0000 Subject: [PATCH 54/57] QedFVol: Add input parameter G(x=0) for infinite-volume photon --- extras/Hadrons/Modules/MGauge/StochEm.cc | 2 +- extras/Hadrons/Modules/MGauge/StochEm.hpp | 3 ++- extras/Hadrons/Modules/MGauge/UnitEm.cc | 2 +- lib/qcd/action/gauge/Photon.h | 12 +++++++----- 4 files changed, 11 insertions(+), 8 deletions(-) diff --git a/extras/Hadrons/Modules/MGauge/StochEm.cc b/extras/Hadrons/Modules/MGauge/StochEm.cc index 4c18b968..fec64699 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.cc +++ b/extras/Hadrons/Modules/MGauge/StochEm.cc @@ -68,7 +68,7 @@ void TStochEm::execute(void) LOG(Message) << "Generating stochastic EM potential..." << std::endl; std::vector improvements = strToVec(par().improvement); - PhotonR photon(par().gauge, par().zmScheme, improvements); + PhotonR photon(par().gauge, par().zmScheme, improvements, par().G0_qedInf); auto &a = envGet(EmField, getName()); auto &w = envGet(EmComp, "_" + getName() + "_weight"); diff --git a/extras/Hadrons/Modules/MGauge/StochEm.hpp b/extras/Hadrons/Modules/MGauge/StochEm.hpp index 11519b52..8ed58c4b 100644 --- a/extras/Hadrons/Modules/MGauge/StochEm.hpp +++ b/extras/Hadrons/Modules/MGauge/StochEm.hpp @@ -45,7 +45,8 @@ public: GRID_SERIALIZABLE_CLASS_MEMBERS(StochEmPar, PhotonR::Gauge, gauge, PhotonR::ZmScheme, zmScheme, - std::string, improvement); + std::string, improvement, + Real, G0_qedInf); }; class TStochEm: public Module diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.cc b/extras/Hadrons/Modules/MGauge/UnitEm.cc index e23840f5..ad842584 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.cc +++ b/extras/Hadrons/Modules/MGauge/UnitEm.cc @@ -61,7 +61,7 @@ void TUnitEm::setup(void) // execution /////////////////////////////////////////////////////////////////// void TUnitEm::execute(void) { - PhotonR photon(0, 0, std::vector()); // Just chose arbitrary input values here + PhotonR photon(0, 0, std::vector(), 0.0); // Just chose arbitrary input values here auto &a = envGet(EmField, getName()); LOG(Message) << "Generating unit EM potential..." << std::endl; photon.UnitField(a); diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index 2bdf70dd..bcfe40e0 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -60,7 +60,7 @@ namespace QCD{ GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3); GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2, qedInf, 3); public: - Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements); + Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements, Real G0); virtual ~Photon(void) = default; void FreePropagator(const GaugeField &in, GaugeField &out); void MomentumSpacePropagator(const GaugeField &in, GaugeField &out); @@ -77,13 +77,15 @@ namespace QCD{ Gauge gauge_; ZmScheme zmScheme_; std::vector improvement_; + Real G0_; }; typedef Photon PhotonR; template - Photon::Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements) - : gauge_(gauge), zmScheme_(zmScheme), improvement_(improvements) + Photon::Photon(Gauge gauge, ZmScheme zmScheme, + std::vector improvements, Real G0) + : gauge_(gauge), zmScheme_(zmScheme), improvement_(improvements), G0_(G0) {} template @@ -109,7 +111,7 @@ namespace QCD{ std::vector &l = grid->_fdimensions; std::vector x0(nd,0); TComplex Tone = Complex(1.0,0.0); - // TComplex Tzero = Complex(0.0,0.0); + TComplex Tzero = Complex(G0_,0.0); FFT fft(grid); one = Complex(1.0,0.0); @@ -123,7 +125,7 @@ namespace QCD{ } pokeSite(Tone, out, x0); out = one/out; - // pokeSite(Tzero, out, x0); + pokeSite(Tzero, out, x0); fft.FFT_all_dim(out, out, FFT::forward); } From c793947209aa0fb0111cf95b911e931b2c725d4c Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 6 Mar 2018 16:27:26 +0000 Subject: [PATCH 55/57] Add overloaded Photon constructors, with default parameters for IR improvements and infinite-volume G(x=0). --- extras/Hadrons/Modules/MGauge/UnitEm.cc | 2 +- lib/qcd/action/gauge/Photon.h | 23 ++++++++++++++++++++++- 2 files changed, 23 insertions(+), 2 deletions(-) diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.cc b/extras/Hadrons/Modules/MGauge/UnitEm.cc index ad842584..e5536d7a 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.cc +++ b/extras/Hadrons/Modules/MGauge/UnitEm.cc @@ -61,7 +61,7 @@ void TUnitEm::setup(void) // execution /////////////////////////////////////////////////////////////////// void TUnitEm::execute(void) { - PhotonR photon(0, 0, std::vector(), 0.0); // Just chose arbitrary input values here + PhotonR photon(0, 0); // Just chose arbitrary input values here auto &a = envGet(EmField, getName()); LOG(Message) << "Generating unit EM potential..." << std::endl; photon.UnitField(a); diff --git a/lib/qcd/action/gauge/Photon.h b/lib/qcd/action/gauge/Photon.h index bcfe40e0..f36df5ea 100644 --- a/lib/qcd/action/gauge/Photon.h +++ b/lib/qcd/action/gauge/Photon.h @@ -60,6 +60,9 @@ namespace QCD{ GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3); GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2, qedInf, 3); public: + Photon(Gauge gauge, ZmScheme zmScheme); + Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements); + Photon(Gauge gauge, ZmScheme zmScheme, Real G0); Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements, Real G0); virtual ~Photon(void) = default; void FreePropagator(const GaugeField &in, GaugeField &out); @@ -82,12 +85,30 @@ namespace QCD{ typedef Photon PhotonR; + template + Photon::Photon(Gauge gauge, ZmScheme zmScheme) + : gauge_(gauge), zmScheme_(zmScheme), improvement_(std::vector()), + G0_(0.15493339023106021408483720810737508876916113364521) + {} + + template + Photon::Photon(Gauge gauge, ZmScheme zmScheme, + std::vector improvements) + : gauge_(gauge), zmScheme_(zmScheme), improvement_(improvements), + G0_(0.15493339023106021408483720810737508876916113364521) + {} + + template + Photon::Photon(Gauge gauge, ZmScheme zmScheme, Real G0) + : gauge_(gauge), zmScheme_(zmScheme), improvement_(std::vector()), G0_(G0) + {} + template Photon::Photon(Gauge gauge, ZmScheme zmScheme, std::vector improvements, Real G0) : gauge_(gauge), zmScheme_(zmScheme), improvement_(improvements), G0_(G0) {} - + template void Photon::FreePropagator (const GaugeField &in,GaugeField &out) { From f5db386c557f7eb5d3cab431b4f92a03a6be0112 Mon Sep 17 00:00:00 2001 From: James Harrison Date: Tue, 22 May 2018 16:16:21 +0100 Subject: [PATCH 56/57] Change MODULE_REGISTER_NS -> MODULE_REGISTER in UnitEM, ScalarVP and VPCounterTerms --- extras/Hadrons/Modules/MGauge/UnitEm.hpp | 4 ++-- extras/Hadrons/Modules/MScalar/ScalarVP.hpp | 4 ++-- extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/extras/Hadrons/Modules/MGauge/UnitEm.hpp b/extras/Hadrons/Modules/MGauge/UnitEm.hpp index 94214274..07ee5bba 100644 --- a/extras/Hadrons/Modules/MGauge/UnitEm.hpp +++ b/extras/Hadrons/Modules/MGauge/UnitEm.hpp @@ -49,7 +49,7 @@ public: // constructor TUnitEm(const std::string name); // destructor - virtual ~TUnitEm(void) = default; + virtual ~TUnitEm(void) {}; // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); @@ -60,7 +60,7 @@ protected: virtual void execute(void); }; -MODULE_REGISTER_NS(UnitEm, TUnitEm, MGauge); +MODULE_REGISTER(UnitEm, TUnitEm, MGauge); END_MODULE_NAMESPACE diff --git a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp index 8e18f80e..741325d1 100644 --- a/extras/Hadrons/Modules/MScalar/ScalarVP.hpp +++ b/extras/Hadrons/Modules/MScalar/ScalarVP.hpp @@ -56,7 +56,7 @@ public: // constructor TScalarVP(const std::string name); // destructor - virtual ~TScalarVP(void) = default; + virtual ~TScalarVP(void) {}; // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); @@ -92,7 +92,7 @@ private: std::vector phase_, momPhase_; }; -MODULE_REGISTER_NS(ScalarVP, TScalarVP, MScalar); +MODULE_REGISTER(ScalarVP, TScalarVP, MScalar); END_MODULE_NAMESPACE diff --git a/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp index a0c3688d..99e1b1ce 100644 --- a/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp +++ b/extras/Hadrons/Modules/MScalar/VPCounterTerms.hpp @@ -47,7 +47,7 @@ public: // constructor TVPCounterTerms(const std::string name); // destructor - virtual ~TVPCounterTerms(void) = default; + virtual ~TVPCounterTerms(void) {}; // dependency relation virtual std::vector getInput(void); virtual std::vector getOutput(void); @@ -66,7 +66,7 @@ private: std::vector phase_, momPhase_; }; -MODULE_REGISTER_NS(VPCounterTerms, TVPCounterTerms, MScalar); +MODULE_REGISTER(VPCounterTerms, TVPCounterTerms, MScalar); END_MODULE_NAMESPACE From 84685c9bc3d8cfb32e6536132062eb29603966b9 Mon Sep 17 00:00:00 2001 From: paboyle Date: Mon, 4 Jun 2018 13:42:07 +0100 Subject: [PATCH 57/57] Overflow fix --- lib/lattice/Lattice_rng.h | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/lib/lattice/Lattice_rng.h b/lib/lattice/Lattice_rng.h index edf9dd23..654c5dd5 100644 --- a/lib/lattice/Lattice_rng.h +++ b/lib/lattice/Lattice_rng.h @@ -158,10 +158,19 @@ namespace Grid { // tens of seconds per trajectory so this is clean in all reasonable cases, // and margin of safety is orders of magnitude. // We could hack Sitmo to skip in the higher order words of state if necessary + // + // Replace with 2^30 ; avoid problem on large volumes + // ///////////////////////////////////////////////////////////////////////////////////// // uint64_t skip = site+1; // Old init Skipped then drew. Checked compat with faster init + const int shift = 30; + uint64_t skip = site; - skip = skip<<40; + + skip = skip<> shift)==site); // check for overflow + eng.discard(skip); // std::cout << " Engine " <