diff --git a/Grid/qcd/utils/BaryonUtils.h b/Grid/qcd/utils/BaryonUtils.h index 73d41422..7fcc4502 100644 --- a/Grid/qcd/utils/BaryonUtils.h +++ b/Grid/qcd/utils/BaryonUtils.h @@ -41,9 +41,12 @@ public: typedef typename FImpl::SitePropagator pobj; typedef typename ComplexField::vector_object vobj; - + + typedef Lattice> SpinMatrixField; + typedef typename SpinMatrixField::vector_object sobj; + static constexpr int epsilon[6][3] = {{0,1,2},{1,2,0},{2,0,1},{0,2,1},{2,1,0},{1,0,2}}; - static constexpr Complex epsilon_sgn[6]= {1,1,1,-1,-1,-1}; + static constexpr int epsilon_sgn[6]= {1,1,1,-1,-1,-1}; private: template @@ -81,12 +84,70 @@ public: const char * quarks_right, const int parity, robj &result); + private: + template + static void Sigma_to_Nucleon_Q1_Eye_site(const mobj &Dq_loop, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result); + template + static void Sigma_to_Nucleon_Q1_NonEye_site(const mobj &Du_xi, + const mobj &Du_xf, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result); + + + template + static void Sigma_to_Nucleon_Q2_Eye_site(const mobj &Dq_loop, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result); + template + static void Sigma_to_Nucleon_Q2_NonEye_site(const mobj &Du_xi, + const mobj &Du_xf, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result); + public: + template + static void Sigma_to_Nucleon(const PropagatorField &qq_xi, + const PropagatorField &qq_xf, + const mobj &Du_spec, + const PropagatorField &qd_xf, + const PropagatorField &qs_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + const std::string op, + SpinMatrixField &stn_corr); }; template constexpr int BaryonUtils::epsilon[6][3]; template -constexpr Complex BaryonUtils::epsilon_sgn[6]; +constexpr int BaryonUtils::epsilon_sgn[6]; template template @@ -123,7 +184,7 @@ void BaryonUtils::baryon_site(const mobj &D1, for (int alpha_right=0; alpha_right(epsilon_sgn[ie_left] * epsilon_sgn[ie_right]) * pD1()(gamma_left,gamma_left)(c_right,c_left)*D2g()(alpha_right,beta_left)(a_right,a_left)*gD3()(alpha_right,beta_left)(b_right,b_left); }}} } //This is the \delta_{456}^{231} part @@ -132,7 +193,7 @@ void BaryonUtils::baryon_site(const mobj &D1, for (int alpha_right=0; alpha_right(epsilon_sgn[ie_left] * epsilon_sgn[ie_right]) * pD1g()(gamma_left,beta_left)(c_right,a_left)*D2()(alpha_right,beta_left)(a_right,b_left)*gD3()(alpha_right,gamma_left)(b_right,c_left); }}} } //This is the \delta_{456}^{312} part @@ -141,7 +202,7 @@ void BaryonUtils::baryon_site(const mobj &D1, for (int alpha_right=0; alpha_right(epsilon_sgn[ie_left] * epsilon_sgn[ie_right]) * pD1()(gamma_left,beta_left)(c_right,b_left)*D2()(alpha_right,gamma_left)(a_right,c_left)*gD3g()(alpha_right,beta_left)(b_right,a_left); }}} } //This is the \delta_{456}^{132} part @@ -150,7 +211,7 @@ void BaryonUtils::baryon_site(const mobj &D1, for (int alpha_right=0; alpha_right(epsilon_sgn[ie_left] * epsilon_sgn[ie_right]) * pD1()(gamma_left,gamma_left)(c_right,c_left)*D2()(alpha_right,beta_left)(a_right,b_left)*gD3g()(alpha_right,beta_left)(b_right,a_left); }}} } //This is the \delta_{456}^{321} part @@ -159,7 +220,7 @@ void BaryonUtils::baryon_site(const mobj &D1, for (int alpha_right=0; alpha_right(epsilon_sgn[ie_left] * epsilon_sgn[ie_right]) * pD1()(gamma_left,beta_left)(c_right,b_left)*D2g()(alpha_right,beta_left)(a_right,a_left)*gD3()(alpha_right,gamma_left)(b_right,c_left); }}} } //This is the \delta_{456}^{213} part @@ -168,7 +229,7 @@ void BaryonUtils::baryon_site(const mobj &D1, for (int alpha_right=0; alpha_right(epsilon_sgn[ie_left] * epsilon_sgn[ie_right]) * pD1g()(gamma_left,beta_left)(c_right,a_left)*D2()(alpha_right,gamma_left)(a_right,c_left)*gD3()(alpha_right,beta_left)(b_right,b_left); }}} } } @@ -249,4 +310,246 @@ void BaryonUtils::ContractBaryons_Sliced(const mobj &D1, result=Zero(); baryon_site(D1,D2,D3,GammaA_left,GammaB_left,GammaA_right,GammaB_right,parity,wick_contraction,result); } + +/*********************************************************************** + * End of Baryon 2pt-function code. * + * * + * The following code is for Sigma -> N rare hypeon decays * + **********************************************************************/ + +/* Dq_loop is a quark line from x_H to x_H + * Du_spec is a quark line from x_i to x_f + * Dd_xf is a quark line from x_H to x_f + * Ds_xi is a quark line from x_H to x_i */ +template +template +void BaryonUtils::Sigma_to_Nucleon_Q1_Eye_site(const mobj &Dq_loop, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result) +{ + + Gamma g5(Gamma::Algebra::Gamma5); + + auto DuG = Du_spec * GammaB_nucl; + // Gamma^B * Ds * \gamma_\mu^L * (\gamma_5 * Dd^\dagger * \gamma_5) + auto GDsGDd = GammaB_sigma * Ds_xi * Gamma_H * g5 * adj(Dd_xf) * g5; + // Dq_loop * \gamma_\mu^L + auto DqG = Dq_loop * Gamma_H; + + for (int ie_n=0; ie_n < 6 ; ie_n++){ + int a_n = epsilon[ie_n][0]; //a + int b_n = epsilon[ie_n][1]; //b + int c_n = epsilon[ie_n][2]; //c + for (int ie_s=0; ie_s < 6 ; ie_s++){ + int a_s = epsilon[ie_s][0]; //a' + int b_s = epsilon[ie_s][1]; //b' + int c_s = epsilon[ie_s][2]; //c' + for (int j=0; j(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsGDd()(alpha_s,beta_n)(b_s,b_n) * DqG()(tau2,tau2)(j,j) * DuG()(alpha_s, beta_n)(a_s,a_n) * Du_spec()(gamma_s,gamma_n)(c_s,c_n); + result()(gamma_s,gamma_n)() -= static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsGDd()(alpha_s,beta_n)(b_s,b_n) * DqG()(tau2,tau2)(j,j) * DuG()(gamma_s, beta_n)(c_s,a_n) * Du_spec()(alpha_s,gamma_n)(a_s,c_n); + }}}}}} + } + } +} + +/* Du_xi is a quark line from x_H to x_i + * Du_xf is a quark line from x_H to x_f + * Du_spec is a quark line from x_i to x_f + * Dd_xf is a quark line from x_H to x_f + * Ds_xi is a quark line from x_H to x_i */ +template +template +void BaryonUtils::Sigma_to_Nucleon_Q1_NonEye_site(const mobj &Du_xi, + const mobj &Du_xf, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result) +{ + + Gamma g5(Gamma::Algebra::Gamma5); + + auto DuG = Du_spec * GammaB_nucl; + auto adjDu = g5 * adj(Du_xf) * g5; + auto adjDuG = adjDu * GammaB_nucl; + // Gamma^B * Ds * \gamma_\mu^L * (\gamma_5 * Dd^\dagger * \gamma_5) + auto GDsGDd = GammaB_sigma * Ds_xi * Gamma_H * g5 * adj(Dd_xf) * g5; + // Dq_loop * \gamma_\mu^L + auto DuGH = Du_xi * Gamma_H; + + for (int ie_n=0; ie_n < 6 ; ie_n++){ + int a_n = epsilon[ie_n][0]; //a + int b_n = epsilon[ie_n][1]; //b + int c_n = epsilon[ie_n][2]; //c + for (int ie_s=0; ie_s < 6 ; ie_s++){ + int a_s = epsilon[ie_s][0]; //a' + int b_s = epsilon[ie_s][1]; //b' + int c_s = epsilon[ie_s][2]; //c' + for (int j=0; j(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsGDd()(alpha_s,beta_n)(b_s,b_n) * DuGH()(alpha_s,tau2)(a_s,j) * DuG()(gamma_s, beta_n)(c_s,a_n) * adjDu()(tau2,gamma_n)(j,c_n); + result()(gamma_s,gamma_n)() += static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsGDd()(alpha_s,beta_n)(b_s,b_n) * DuGH()(gamma_s,tau2)(c_s,j) * adjDuG()(tau2, beta_n)(j,a_n) * Du_spec()(alpha_s,gamma_n)(a_s,c_n); + result()(gamma_s,gamma_n)() -= static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsGDd()(alpha_s,beta_n)(b_s,b_n) * DuGH()(alpha_s,tau2)(a_s,j) * adjDuG()(tau2, beta_n)(j,a_n) * Du_spec()(gamma_s,gamma_n)(c_s,c_n); + result()(gamma_s,gamma_n)() -= static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsGDd()(alpha_s,beta_n)(b_s,b_n) * DuGH()(gamma_s,tau2)(c_s,j) * DuG()(alpha_s, beta_n)(a_s,a_n) * adjDu()(tau2,gamma_n)(j,c_n); + }}}}}} + } + } +} + +//Equivalent to "One-trace" +template +template +void BaryonUtils::Sigma_to_Nucleon_Q2_Eye_site(const mobj &Dq_loop, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result) +{ + + Gamma g5(Gamma::Algebra::Gamma5); + + auto DuG = Du_spec * GammaB_nucl; + // Gamma^B * Ds * \gamma_\mu^L + auto GDsG = GammaB_sigma * Ds_xi * Gamma_H; + // Dq_loop * \gamma_\mu^L * (\gamma_5 * Dd^\dagger * \gamma_5) + auto DqGDd = Dq_loop * Gamma_H * g5 * adj(Dd_xf) * g5; + + for (int ie_n=0; ie_n < 6 ; ie_n++){ + int a_n = epsilon[ie_n][0]; //a + int b_n = epsilon[ie_n][1]; //b + int c_n = epsilon[ie_n][2]; //c + for (int ie_s=0; ie_s < 6 ; ie_s++){ + int a_s = epsilon[ie_s][0]; //a' + int b_s = epsilon[ie_s][1]; //b' + int c_s = epsilon[ie_s][2]; //c' + for (int i=0; i(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsG()(alpha_s,tau)(b_s,i) * DqGDd()(tau,beta_n)(i,b_n) * DuG()(alpha_s, beta_n)(a_s,a_n) * Du_spec()(gamma_s,gamma_n)(c_s,c_n); + result()(gamma_s,gamma_n)() += static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsG()(alpha_s,tau)(b_s,i) * DqGDd()(tau,beta_n)(i,b_n) * DuG()(gamma_s, beta_n)(c_s,a_n) * Du_spec()(alpha_s,gamma_n)(a_s,c_n); + }}}}}} + } + } +} + +template +template +void BaryonUtils::Sigma_to_Nucleon_Q2_NonEye_site(const mobj &Du_xi, + const mobj &Du_xf, + const mobj2 &Du_spec, + const mobj &Dd_xf, + const mobj &Ds_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + robj &result) +{ + + Gamma g5(Gamma::Algebra::Gamma5); + + auto DuG = Du_spec * GammaB_nucl; + auto adjDu = g5 * adj(Du_xf) * g5; + auto adjDuG = adjDu * GammaB_nucl; + // Gamma^B * Ds * \gamma_\mu^L + auto GDsG = GammaB_sigma * Ds_xi * Gamma_H; + // Du * \gamma_\mu^L * (\gamma_5 * Dd^\dagger * \gamma_5) + auto DuGDd = Du_xi * Gamma_H * g5 * adj(Dd_xf) * g5; + + for (int ie_n=0; ie_n < 6 ; ie_n++){ + int a_n = epsilon[ie_n][0]; //a + int b_n = epsilon[ie_n][1]; //b + int c_n = epsilon[ie_n][2]; //c + for (int ie_s=0; ie_s < 6 ; ie_s++){ + int a_s = epsilon[ie_s][0]; //a' + int b_s = epsilon[ie_s][1]; //b' + int c_s = epsilon[ie_s][2]; //c' + for (int i=0; i(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsG()(alpha_s,tau)(b_s,i) * DuGDd()(alpha_s,beta_n)(a_s,b_n) * DuG()(gamma_s, beta_n)(c_s,a_n) * adjDu()(tau,gamma_n)(i,c_n); + result()(gamma_s,gamma_n)() -= static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsG()(alpha_s,tau)(b_s,i) * DuGDd()(gamma_s,beta_n)(c_s,b_n) * adjDuG()(tau, beta_n)(i,a_n) * Du_spec()(alpha_s,gamma_n)(a_s,c_n); + result()(gamma_s,gamma_n)() += static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsG()(alpha_s,tau)(b_s,i) * DuGDd()(alpha_s,beta_n)(a_s,b_n) * adjDuG()(tau, beta_n)(i,a_n) * Du_spec()(gamma_s,gamma_n)(c_s,c_n); + result()(gamma_s,gamma_n)() += static_cast(epsilon_sgn[ie_n] * epsilon_sgn[ie_s]) * GDsG()(alpha_s,tau)(b_s,i) * DuGDd()(gamma_s,beta_n)(c_s,b_n) * DuG()(alpha_s, beta_n)(a_s,a_n) * adjDu()(tau,gamma_n)(i,c_n); + }}}}}} + } + } +} + + +template +template +void BaryonUtils::Sigma_to_Nucleon(const PropagatorField &qq_xi, + const PropagatorField &qq_xf, + const mobj &Du_spec, + const PropagatorField &qd_xf, + const PropagatorField &qs_xi, + const Gamma Gamma_H, + const Gamma GammaB_sigma, + const Gamma GammaB_nucl, + const int parity, + const std::string op, + SpinMatrixField &stn_corr) +{ + assert(parity==1 || parity == -1 && "Parity must be +1 or -1"); + + GridBase *grid = qs_xi.Grid(); + + auto vcorr= stn_corr.View(); + auto vq_xi = qq_xi.View(); + auto vq_xf = qq_xf.View(); + auto vd_xf = qd_xf.View(); + auto vs_xi = qs_xi.View(); + + // accelerator_for(ss, grid->oSites(), grid->Nsimd(), { + thread_for(ss,grid->oSites(),{ + auto Dq_xi = vq_xi[ss]; + auto Dq_xf = vq_xf[ss]; + auto Dd_xf = vd_xf[ss]; + auto Ds_xi = vs_xi[ss]; + sobj result=Zero(); + if(op == "Q1_NonEye"){ + Sigma_to_Nucleon_Q1_NonEye_site(Dq_xi,Dq_xf,Du_spec,Dd_xf,Ds_xi,Gamma_H,GammaB_sigma,GammaB_nucl,parity,result); + } else if(op == "Q1_Eye"){ + Sigma_to_Nucleon_Q1_Eye_site(Dq_xi,Du_spec,Dd_xf,Ds_xi,Gamma_H,GammaB_sigma,GammaB_nucl,parity,result); + } else if(op == "Q2_NonEye"){ + Sigma_to_Nucleon_Q2_NonEye_site(Dq_xi,Dq_xf,Du_spec,Dd_xf,Ds_xi,Gamma_H,GammaB_sigma,GammaB_nucl,parity,result); + } else if(op == "Q2_Eye"){ + Sigma_to_Nucleon_Q2_Eye_site(Dq_xi,Du_spec,Dd_xf,Ds_xi,Gamma_H,GammaB_sigma,GammaB_nucl,parity,result); + } else { + assert(0 && "Weak Operator not correctly specified"); + } + vcorr[ss] = result; + } );//end loop over lattice sites +} + NAMESPACE_END(Grid); diff --git a/Hadrons/Global.hpp b/Hadrons/Global.hpp index 9b592721..b82c6288 100644 --- a/Hadrons/Global.hpp +++ b/Hadrons/Global.hpp @@ -272,7 +272,7 @@ struct Correlator: Serializable { GRID_SERIALIZABLE_CLASS_MEMBERS(ARG(Correlator), Metadata, info, - std::vector, corr); + std::vector, corr); }; END_HADRONS_NAMESPACE diff --git a/Hadrons/Modules.hpp b/Hadrons/Modules.hpp index c041afa0..ebe82910 100644 --- a/Hadrons/Modules.hpp +++ b/Hadrons/Modules.hpp @@ -1,73 +1,76 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include #include -#include -#include +#include #include #include #include -#include -#include -#include -#include +#include +#include +#include #include #include +#include +#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonEye.cc b/Hadrons/Modules/MContraction/SigmaToNucleonEye.cc new file mode 100644 index 00000000..4e938309 --- /dev/null +++ b/Hadrons/Modules/MContraction/SigmaToNucleonEye.cc @@ -0,0 +1,7 @@ +#include + +using namespace Grid; +using namespace Hadrons; +using namespace MContraction; + +template class Grid::Hadrons::MContraction::TSigmaToNucleonEye; diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp b/Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp new file mode 100644 index 00000000..e4189f7c --- /dev/null +++ b/Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp @@ -0,0 +1,219 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp + +Copyright (C) 2015-2019 + +Author: Antonin Portelli +Author: Felix Erben + +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_MContraction_SigmaToNucleonEye_hpp_ +#define Hadrons_MContraction_SigmaToNucleonEye_hpp_ + +#include +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/****************************************************************************** + * SigmaToNucleonEye * + ******************************************************************************/ +/* + * Sigma-to-nucleon 3-pt diagrams, eye topologies. + * + * Schematics: qq_loop | + * /-<-¬ | + * / \ | qs_xi G qd_xf + * \ / | /----<------*------<----¬ + * qs_xi \ / qd_xf | / /-*-¬ \ + * /-----<-----* *-----<----¬ | / / G \ \ + * * G G * | * \ / qq_loop * + * |\ /| | |\ \->-/ /| + * | \ / | | | \ / | + * | \---------->---------/ | | | \----------->----------/ | + * \ qu_spec / | \ qu_spec / + * \ / | \ / + * \---------->---------/ | \----------->----------/ + * qu_spec | qu_spec + * + * analogously to the rare-kaon naming, the left diagram is named 'one-trace' and + * the diagram on the right 'two-trace' + */ +BEGIN_MODULE_NAMESPACE(MContraction) + +class SigmaToNucleonEyePar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(SigmaToNucleonEyePar, + std::string, qq_loop, + std::string, qu_spec, + std::string, qd_xf, + std::string, qs_xi, + unsigned int, tOut, + std::string, parity, + std::string, sink, + std::string, output); +}; + +template +class TSigmaToNucleonEye: public Module +{ +public: + FERM_TYPE_ALIASES(FImpl1, 1); + FERM_TYPE_ALIASES(FImpl2, 2); + FERM_TYPE_ALIASES(FImpl3, 3); + FERM_TYPE_ALIASES(FImpl3, 4); + BASIC_TYPE_ALIASES(ScalarImplCR, Scalar); + SINK_TYPE_ALIASES(Scalar); + typedef typename SpinMatrixField1::vector_object::scalar_object SpinMatrix; + class Metadata: Serializable + { + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(Metadata, + Gamma::Algebra, gamma_H, + Gamma::Algebra, gammaA_sigma, + Gamma::Algebra, gammaB_sigma, + Gamma::Algebra, gammaA_nucl, + Gamma::Algebra, gammaB_nucl, + int, trace, + int, parity); + }; + typedef Correlator Result; +public: + // constructor + TSigmaToNucleonEye(const std::string name); + // destructor + virtual ~TSigmaToNucleonEye(void) {}; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); +protected: + // setup + virtual void setup(void); + // execution + virtual void execute(void); + // Which gamma algebra was specified + Gamma::Algebra al; +}; + +MODULE_REGISTER_TMP(SigmaToNucleonEye, ARG(TSigmaToNucleonEye), MContraction); + +/****************************************************************************** + * TSigmaToNucleonEye implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TSigmaToNucleonEye::TSigmaToNucleonEye(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TSigmaToNucleonEye::getInput(void) +{ + std::vector input = {par().qq_loop, par().qu_spec, par().qd_xf, par().qs_xi, par().sink}; + + return input; +} + +template +std::vector TSigmaToNucleonEye::getOutput(void) +{ + std::vector out = {}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TSigmaToNucleonEye::setup(void) +{ + envTmpLat(SpinMatrixField1, "c"); +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TSigmaToNucleonEye::execute(void) +{ + const int parity {par().parity.size()>0 ? std::stoi(par().parity) : 1}; + const Gamma GammaB(Gamma::Algebra::SigmaXZ); // C*gamma_5 + const Gamma Id(Gamma::Algebra::Identity); // C*gamma_5 + + LOG(Message) << "Computing sigma-to-nucleon contractions '" << getName() << "'" << std::endl; + LOG(Message) << "' with (Gamma^A,Gamma^B)_sigma = ( Identity, C*gamma_5 ) and (Gamma^A,Gamma^B)_nucl = ( Identity, C*gamma_5 )" << std::endl; + LOG(Message) << "and parity " << parity << " using sink " << par().sink << "." << std::endl; + + envGetTmp(SpinMatrixField1, c); + std::vector buf; + + std::vector result; + Result r; + r.info.parity = parity; + r.info.gammaA_sigma = Id.g; + r.info.gammaB_sigma = GammaB.g; + r.info.gammaA_nucl = Id.g; + r.info.gammaB_nucl = GammaB.g; + + auto &qq_loop = envGet(PropagatorField1, par().qq_loop); + auto &qu_spec = envGet(SlicedPropagator2, par().qu_spec); + auto &qd_xf = envGet(PropagatorField3, par().qd_xf); + auto &qs_xi = envGet(PropagatorField4, par().qs_xi); + auto qut = qu_spec[par().tOut]; + for (auto &G: Gamma::gall) + { + r.info.gamma_H = G.g; + //Operator Q1, equivalent to the two-trace case in the rare-kaons module + c=Zero(); + BaryonUtils::Sigma_to_Nucleon(qq_loop,qq_loop,qut,qd_xf,qs_xi,G,GammaB,GammaB,parity,"Q1_Eye",c); + sliceSum(c,buf,Tp); + r.corr.clear(); + for (unsigned int t = 0; t < buf.size(); ++t) + { + r.corr.push_back(buf[t]); + } + r.info.trace = 2; + result.push_back(r); + //Operator Q2, equivalent to the one-trace case in the rare-kaons module + c=Zero(); + BaryonUtils::Sigma_to_Nucleon(qq_loop,qq_loop,qut,qd_xf,qs_xi,G,GammaB,GammaB,parity,"Q2_Eye",c); + sliceSum(c,buf,Tp); + r.corr.clear(); + for (unsigned int t = 0; t < buf.size(); ++t) + { + r.corr.push_back(buf[t]); + } + r.info.trace = 1; + result.push_back(r); + } + + saveResult(par().output, "StN_Eye", result); + +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_MContraction_SigmaToNucleonEye_hpp_ diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.cc b/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.cc new file mode 100644 index 00000000..7d5ee247 --- /dev/null +++ b/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.cc @@ -0,0 +1,7 @@ +#include + +using namespace Grid; +using namespace Hadrons; +using namespace MContraction; + +template class Grid::Hadrons::MContraction::TSigmaToNucleonNonEye; diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp b/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp new file mode 100644 index 00000000..15dc5eaa --- /dev/null +++ b/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp @@ -0,0 +1,225 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp + +Copyright (C) 2015-2019 + +Author: Antonin Portelli +Author: Felix Erben + +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_MContraction_SigmaToNucleonNonEye_hpp_ +#define Hadrons_MContraction_SigmaToNucleonNonEye_hpp_ + +#include +#include +#include +#include + +BEGIN_HADRONS_NAMESPACE + +/****************************************************************************** + * SigmaToNucleonNonEye * + ******************************************************************************/ +/* + * Sigma-to-Nucleon 3-pt diagrams, non-eye topologies. + * + * Schematic: + * qs_xi qd_xf | qs_xi qd_xf + * /--<--¬ /--<--¬ | /--<--¬ /--<--¬ + * / \ / \ | / \ / \ + * / \ / \ | / \ / \ + * / \ / \ | / \ / \ + * * * G * | * G * * G * + * |\ * G | | |\ / \ /| + * | \ / \ /| | | \ / \ / | + * | \ / \ / | | | \ / \ / | + * | \ / \ / | | | \-->--/ \-->--/ | + * \ \-->--/ \-->--/ / | \ qu_xi qu_xf / + * \ qu_xf qu_xf / | \ / + * \ / | \ / + * \--------->----------/ | \--------->-----------/ + * qu_spec | qu_spec + * + * + * analogously to the rare-kaon naming, the left diagram is named 'one-trace' and + * the diagram on the right 'two-trace' + * + */ +BEGIN_MODULE_NAMESPACE(MContraction) + +class SigmaToNucleonNonEyePar: Serializable +{ +public: + GRID_SERIALIZABLE_CLASS_MEMBERS(SigmaToNucleonNonEyePar, + std::string, qu_xi, + std::string, qu_xf, + std::string, qu_spec, + std::string, qd_xf, + std::string, qs_xi, + unsigned int, tOut, + std::string, parity, + std::string, sink, + std::string, output); +}; + +template +class TSigmaToNucleonNonEye: public Module +{ +public: + FERM_TYPE_ALIASES(FImpl1, 1); + FERM_TYPE_ALIASES(FImpl2, 2); + FERM_TYPE_ALIASES(FImpl3, 3); + FERM_TYPE_ALIASES(FImpl3, 4); + BASIC_TYPE_ALIASES(ScalarImplCR, Scalar); + SINK_TYPE_ALIASES(Scalar); + typedef typename SpinMatrixField1::vector_object::scalar_object SpinMatrix; + class Metadata: Serializable + { + public: + GRID_SERIALIZABLE_CLASS_MEMBERS(Metadata, + Gamma::Algebra, gamma_H, + Gamma::Algebra, gammaA_sigma, + Gamma::Algebra, gammaB_sigma, + Gamma::Algebra, gammaA_nucl, + Gamma::Algebra, gammaB_nucl, + int, trace, + int, parity); + }; + typedef Correlator Result; +public: + // constructor + TSigmaToNucleonNonEye(const std::string name); + // destructor + virtual ~TSigmaToNucleonNonEye(void) {}; + // dependency relation + virtual std::vector getInput(void); + virtual std::vector getOutput(void); +protected: + // setup + virtual void setup(void); + // execution + virtual void execute(void); + // Which gamma algebra was specified + Gamma::Algebra al; +}; + +MODULE_REGISTER_TMP(SigmaToNucleonNonEye, ARG(TSigmaToNucleonNonEye), MContraction); + +/****************************************************************************** + * TSigmaToNucleonNonEye implementation * + ******************************************************************************/ +// constructor ///////////////////////////////////////////////////////////////// +template +TSigmaToNucleonNonEye::TSigmaToNucleonNonEye(const std::string name) +: Module(name) +{} + +// dependencies/products /////////////////////////////////////////////////////// +template +std::vector TSigmaToNucleonNonEye::getInput(void) +{ + std::vector input = {par().qu_xi, par().qu_xf, par().qu_spec, par().qd_xf, par().qs_xi, par().sink}; + + return input; +} + +template +std::vector TSigmaToNucleonNonEye::getOutput(void) +{ + std::vector out = {}; + + return out; +} + +// setup /////////////////////////////////////////////////////////////////////// +template +void TSigmaToNucleonNonEye::setup(void) +{ + envTmpLat(SpinMatrixField1, "c"); +} + +// execution /////////////////////////////////////////////////////////////////// +template +void TSigmaToNucleonNonEye::execute(void) +{ + const int parity {par().parity.size()>0 ? std::stoi(par().parity) : 1}; + const Gamma GammaB(Gamma::Algebra::SigmaXZ); // C*gamma_5 + const Gamma Id(Gamma::Algebra::Identity); // C*gamma_5 + + LOG(Message) << "Computing sigma-to-nucleon contractions '" << getName() << "'" << std::endl; + LOG(Message) << "' with (Gamma^A,Gamma^B)_sigma = ( Identity, C*gamma_5 ) and (Gamma^A,Gamma^B)_nucl = ( Identity, C*gamma_5 )" << std::endl; + LOG(Message) << "and parity " << parity << " using sink " << par().sink << "." << std::endl; + + envGetTmp(SpinMatrixField1, c); + std::vector buf; + + std::vector result; + Result r; + r.info.parity = parity; + r.info.gammaA_sigma = Id.g; + r.info.gammaB_sigma = GammaB.g; + r.info.gammaA_nucl = Id.g; + r.info.gammaB_nucl = GammaB.g; + + auto &qu_xi = envGet(PropagatorField1, par().qu_xi); + auto &qu_xf = envGet(PropagatorField1, par().qu_xf); + auto &qu_spec = envGet(SlicedPropagator2, par().qu_spec); + auto &qd_xf = envGet(PropagatorField3, par().qd_xf); + auto &qs_xi = envGet(PropagatorField4, par().qs_xi); + auto qut = qu_spec[par().tOut]; + for (auto &G: Gamma::gall) + { + r.info.gamma_H = G.g; + //Operator Q1, equivalent to the two-trace case in the rare-kaons module + c=Zero(); + BaryonUtils::Sigma_to_Nucleon(qu_xi,qu_xf,qut,qd_xf,qs_xi,G,GammaB,GammaB,parity,"Q1_NonEye",c); + sliceSum(c,buf,Tp); + r.corr.clear(); + for (unsigned int t = 0; t < buf.size(); ++t) + { + r.corr.push_back(buf[t]); + } + r.info.trace = 2; + result.push_back(r); + //Operator Q2, equivalent to the one-trace case in the rare-kaons module + c=Zero(); + BaryonUtils::Sigma_to_Nucleon(qu_xi,qu_xf,qut,qd_xf,qs_xi,G,GammaB,GammaB,parity,"Q2_NonEye",c); + sliceSum(c,buf,Tp); + r.corr.clear(); + for (unsigned int t = 0; t < buf.size(); ++t) + { + r.corr.push_back(buf[t]); + } + r.info.trace = 1; + result.push_back(r); + } + + saveResult(par().output, "StN_NonEye", result); + +} + +END_MODULE_NAMESPACE + +END_HADRONS_NAMESPACE + +#endif // Hadrons_MContraction_SigmaToNucleonNonEye_hpp_ diff --git a/Hadrons/Modules/MContraction/WeakEye3pt.hpp b/Hadrons/Modules/MContraction/WeakEye3pt.hpp index ea7ff529..b4165098 100644 --- a/Hadrons/Modules/MContraction/WeakEye3pt.hpp +++ b/Hadrons/Modules/MContraction/WeakEye3pt.hpp @@ -144,7 +144,7 @@ void TWeakEye3pt::execute(void) { LOG(Message) << "Computing mesonic weak 3pt contractions, eye topologies" << std::endl; LOG(Message) << "gIn : " << par().gammaIn << std::endl; - LOG(Message) << "gOut: " << par().gammaIn << std::endl; + LOG(Message) << "gOut: " << par().gammaOut << std::endl; LOG(Message) << "tOut: " << par().tOut << std::endl; LOG(Message) << "qbl : " << par().qBarLeft << std::endl; LOG(Message) << "qbr : " << par().qBarRight << std::endl; diff --git a/Hadrons/Modules/MContraction/WeakNonEye3pt.hpp b/Hadrons/Modules/MContraction/WeakNonEye3pt.hpp index 08a1188b..4068cd8c 100644 --- a/Hadrons/Modules/MContraction/WeakNonEye3pt.hpp +++ b/Hadrons/Modules/MContraction/WeakNonEye3pt.hpp @@ -144,7 +144,7 @@ void TWeakNonEye3pt::execute(void) { LOG(Message) << "Computing mesonic weak 3pt contractions, non-eye topologies" << std::endl; LOG(Message) << "gIn : " << par().gammaIn << std::endl; - LOG(Message) << "gOut: " << par().gammaIn << std::endl; + LOG(Message) << "gOut: " << par().gammaOut << std::endl; LOG(Message) << "ql : " << par().qLeft << std::endl; LOG(Message) << "qbl : " << par().qBarLeft << std::endl; LOG(Message) << "qr : " << par().qRight << std::endl; diff --git a/Hadrons/Modules/MSource/MomentumPhase.hpp b/Hadrons/Modules/MSource/MomentumPhase.hpp index 89bd0c8e..f2f94af1 100644 --- a/Hadrons/Modules/MSource/MomentumPhase.hpp +++ b/Hadrons/Modules/MSource/MomentumPhase.hpp @@ -140,7 +140,7 @@ void TMomentumPhase::execute(void) envGetTmp(LatticeComplex, coor); p = strToVec(par().mom); - ph = zero; + ph = Zero(); for(unsigned int mu = 0; mu < env().getNd(); mu++) { LatticeCoordinate(coor, mu); diff --git a/Hadrons/modules.inc b/Hadrons/modules.inc index f4ede1bb..bcf58d00 100644 --- a/Hadrons/modules.inc +++ b/Hadrons/modules.inc @@ -1,147 +1,153 @@ modules_cc =\ - Modules/MFermion/FreeProp.cc \ - Modules/MFermion/GaugeProp.cc \ - Modules/MFermion/EMLepton.cc \ - Modules/MIO/LoadA2AVectors.cc \ - Modules/MIO/LoadEigenPack.cc \ - Modules/MIO/LoadCosmHol.cc \ - Modules/MIO/LoadBinary.cc \ - Modules/MIO/LoadA2AMatrixDiskVector.cc \ - Modules/MIO/LoadCoarseEigenPack.cc \ - Modules/MIO/LoadNersc.cc \ - Modules/MAction/ZMobiusDWF.cc \ - Modules/MAction/ScaledDWF.cc \ - Modules/MAction/Wilson.cc \ - Modules/MAction/DWF.cc \ - Modules/MAction/WilsonClover.cc \ - Modules/MAction/MobiusDWF.cc \ Modules/MUtilities/RandomVectors.cc \ Modules/MUtilities/PrecisionCast.cc \ - Modules/MNoise/FullVolumeSpinColorDiagonal.cc \ - Modules/MNoise/TimeDilutedSpinColorDiagonal.cc \ - Modules/MContraction/Gamma3pt.cc \ - Modules/MContraction/A2AFourQuarkContraction.cc \ - Modules/MContraction/A2AAslashField.cc \ - Modules/MContraction/A2ALoop.cc \ - Modules/MContraction/WeakEye3pt.cc \ - Modules/MContraction/WeakNonEye3pt.cc \ - Modules/MContraction/A2AMesonField.cc \ - Modules/MContraction/DiscLoop.cc \ - Modules/MContraction/Baryon.cc \ - Modules/MContraction/WeakMesonDecayKl2.cc \ - Modules/MContraction/Meson.cc \ - Modules/MSink/Point.cc \ - Modules/MSink/Smear.cc \ - Modules/MScalarSUN/TrPhi.cc \ - Modules/MScalarSUN/TrMag.cc \ - Modules/MScalarSUN/TrKinetic.cc \ - Modules/MScalarSUN/TwoPoint.cc \ - Modules/MScalarSUN/Grad.cc \ - Modules/MScalarSUN/TwoPointNPR.cc \ - Modules/MScalarSUN/StochFreeField.cc \ - Modules/MScalarSUN/TransProj.cc \ - Modules/MScalarSUN/EMT.cc \ - Modules/MScalarSUN/Div.cc \ - Modules/MNPR/Amputate.cc \ - Modules/MNPR/Bilinear.cc \ - Modules/MNPR/FourQuark.cc \ - Modules/MSource/SeqGamma.cc \ + Modules/MGauge/FundtoHirep.cc \ + Modules/MGauge/UnitEm.cc \ + Modules/MGauge/StoutSmearing.cc \ + Modules/MGauge/Electrify.cc \ + Modules/MGauge/Unit.cc \ + Modules/MGauge/StochEm.cc \ + Modules/MGauge/GaugeFix.cc \ + Modules/MGauge/Random.cc \ + Modules/MSolver/MixedPrecisionRBPrecCG.cc \ + Modules/MSolver/RBPrecCG.cc \ + Modules/MSolver/LocalCoherenceLanczos.cc \ + Modules/MSolver/A2AAslashVectors.cc \ + Modules/MSolver/A2AVectors.cc \ Modules/MSource/Z2.cc \ - Modules/MSource/Convolution.cc \ - Modules/MSource/Momentum.cc \ Modules/MSource/Wall.cc \ Modules/MSource/Point.cc \ - Modules/MSource/SeqAslash.cc \ + Modules/MSource/MomentumPhase.cc \ Modules/MSource/Gauss.cc \ + Modules/MSource/Convolution.cc \ + Modules/MSource/SeqGamma.cc \ + Modules/MSource/Momentum.cc \ Modules/MSource/SeqConserved.cc \ - Modules/MGauge/StoutSmearing.cc \ - Modules/MGauge/GaugeFix.cc \ - Modules/MGauge/Electrify.cc \ - Modules/MGauge/Random.cc \ - Modules/MGauge/Unit.cc \ - Modules/MGauge/UnitEm.cc \ - Modules/MGauge/FundtoHirep.cc \ - Modules/MGauge/StochEm.cc \ - Modules/MSolver/RBPrecCG.cc \ - Modules/MSolver/A2AAslashVectors.cc \ - Modules/MSolver/MixedPrecisionRBPrecCG.cc \ - Modules/MSolver/A2AVectors.cc \ - Modules/MSolver/LocalCoherenceLanczos.cc \ + Modules/MSource/SeqAslash.cc \ + Modules/MNPR/Bilinear.cc \ + Modules/MNPR/FourQuark.cc \ + Modules/MNPR/Amputate.cc \ + Modules/MContraction/Baryon.cc \ + Modules/MContraction/A2ALoop.cc \ + Modules/MContraction/A2AFourQuarkContraction.cc \ + Modules/MContraction/DiscLoop.cc \ + Modules/MContraction/SigmaToNucleonEye.cc \ + Modules/MContraction/WeakEye3pt.cc \ + Modules/MContraction/A2AAslashField.cc \ + Modules/MContraction/Meson.cc \ + Modules/MContraction/WeakMesonDecayKl2.cc \ + Modules/MContraction/WeakNonEye3pt.cc \ + Modules/MContraction/SigmaToNucleonNonEye.cc \ + Modules/MContraction/Gamma3pt.cc \ + Modules/MContraction/A2AMesonField.cc \ + Modules/MScalar/FreeProp.cc \ Modules/MScalar/ChargedProp.cc \ - Modules/MScalar/FreeProp.cc + Modules/MSink/Point.cc \ + Modules/MSink/Smear.cc \ + Modules/MNoise/TimeDilutedSpinColorDiagonal.cc \ + Modules/MNoise/FullVolumeSpinColorDiagonal.cc \ + Modules/MIO/LoadA2AVectors.cc \ + Modules/MIO/LoadBinary.cc \ + Modules/MIO/LoadA2AMatrixDiskVector.cc \ + Modules/MIO/LoadNersc.cc \ + Modules/MIO/LoadCoarseEigenPack.cc \ + Modules/MIO/LoadCosmHol.cc \ + Modules/MIO/LoadEigenPack.cc \ + Modules/MScalarSUN/Div.cc \ + Modules/MScalarSUN/TwoPointNPR.cc \ + Modules/MScalarSUN/TrPhi.cc \ + Modules/MScalarSUN/TransProj.cc \ + Modules/MScalarSUN/TwoPoint.cc \ + Modules/MScalarSUN/Grad.cc \ + Modules/MScalarSUN/EMT.cc \ + Modules/MScalarSUN/TrKinetic.cc \ + Modules/MScalarSUN/StochFreeField.cc \ + Modules/MScalarSUN/TrMag.cc \ + Modules/MAction/MobiusDWF.cc \ + Modules/MAction/DWF.cc \ + Modules/MAction/ScaledDWF.cc \ + Modules/MAction/Wilson.cc \ + Modules/MAction/ZMobiusDWF.cc \ + Modules/MAction/WilsonClover.cc \ + Modules/MFermion/EMLepton.cc \ + Modules/MFermion/FreeProp.cc \ + Modules/MFermion/GaugeProp.cc modules_hpp =\ - Modules/MFermion/GaugeProp.hpp \ - Modules/MFermion/EMLepton.hpp \ - Modules/MFermion/FreeProp.hpp \ - Modules/MIO/LoadCosmHol.hpp \ - Modules/MIO/LoadEigenPack.hpp \ - Modules/MIO/LoadA2AVectors.hpp \ - Modules/MIO/LoadA2AMatrixDiskVector.hpp \ - Modules/MIO/LoadCoarseEigenPack.hpp \ - Modules/MIO/LoadNersc.hpp \ - Modules/MIO/LoadBinary.hpp \ - Modules/MAction/ZMobiusDWF.hpp \ - Modules/MAction/MobiusDWF.hpp \ - Modules/MAction/Wilson.hpp \ - Modules/MAction/DWF.hpp \ - Modules/MAction/WilsonClover.hpp \ - Modules/MAction/ScaledDWF.hpp \ - Modules/MUtilities/RandomVectors.hpp \ Modules/MUtilities/PrecisionCast.hpp \ - Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp \ - Modules/MNoise/FullVolumeSpinColorDiagonal.hpp \ - Modules/MContraction/DiscLoop.hpp \ - Modules/MContraction/Meson.hpp \ - Modules/MContraction/WeakMesonDecayKl2.hpp \ - Modules/MContraction/A2AMesonField.hpp \ - Modules/MContraction/WeakNonEye3pt.hpp \ - Modules/MContraction/Gamma3pt.hpp \ - Modules/MContraction/A2AAslashField.hpp \ - Modules/MContraction/A2AFourQuarkContraction.hpp \ - Modules/MContraction/Baryon.hpp \ - Modules/MContraction/WeakEye3pt.hpp \ - Modules/MContraction/A2ALoop.hpp \ - Modules/MSink/Point.hpp \ - Modules/MSink/Smear.hpp \ - Modules/MScalarSUN/StochFreeField.hpp \ - Modules/MScalarSUN/EMT.hpp \ - Modules/MScalarSUN/Utils.hpp \ - Modules/MScalarSUN/TwoPoint.hpp \ - Modules/MScalarSUN/TransProj.hpp \ - Modules/MScalarSUN/TwoPointNPR.hpp \ - Modules/MScalarSUN/TrPhi.hpp \ - Modules/MScalarSUN/Grad.hpp \ - Modules/MScalarSUN/TrMag.hpp \ - Modules/MScalarSUN/Div.hpp \ - Modules/MScalarSUN/TrKinetic.hpp \ - Modules/MNPR/Amputate.hpp \ - Modules/MNPR/FourQuark.hpp \ - Modules/MNPR/Bilinear.hpp \ - Modules/MSource/SeqAslash.hpp \ - Modules/MSource/Momentum.hpp \ - Modules/MSource/Z2.hpp \ - Modules/MSource/Point.hpp \ - Modules/MSource/Gauss.hpp \ - Modules/MSource/SeqConserved.hpp \ - Modules/MSource/Wall.hpp \ - Modules/MSource/SeqGamma.hpp \ - Modules/MSource/Convolution.hpp \ - Modules/MGauge/Random.hpp \ + Modules/MUtilities/RandomVectors.hpp \ Modules/MGauge/FundtoHirep.hpp \ - Modules/MGauge/StochEm.hpp \ - Modules/MGauge/UnitEm.hpp \ + Modules/MGauge/Electrify.hpp \ Modules/MGauge/GaugeFix.hpp \ Modules/MGauge/StoutSmearing.hpp \ Modules/MGauge/Unit.hpp \ - Modules/MGauge/Electrify.hpp \ - Modules/MSolver/A2AVectors.hpp \ - Modules/MSolver/RBPrecCG.hpp \ - Modules/MSolver/LocalCoherenceLanczos.hpp \ + Modules/MGauge/UnitEm.hpp \ + Modules/MGauge/Random.hpp \ + Modules/MGauge/StochEm.hpp \ Modules/MSolver/Guesser.hpp \ Modules/MSolver/MixedPrecisionRBPrecCG.hpp \ + Modules/MSolver/A2AVectors.hpp \ + Modules/MSolver/LocalCoherenceLanczos.hpp \ Modules/MSolver/A2AAslashVectors.hpp \ + Modules/MSolver/RBPrecCG.hpp \ + Modules/MSource/Convolution.hpp \ + Modules/MSource/Point.hpp \ + Modules/MSource/Gauss.hpp \ + Modules/MSource/MomentumPhase.hpp \ + Modules/MSource/Z2.hpp \ + Modules/MSource/SeqAslash.hpp \ + Modules/MSource/SeqConserved.hpp \ + Modules/MSource/SeqGamma.hpp \ + Modules/MSource/Momentum.hpp \ + Modules/MSource/Wall.hpp \ + Modules/MNPR/Amputate.hpp \ + Modules/MNPR/Bilinear.hpp \ + Modules/MNPR/FourQuark.hpp \ + Modules/MContraction/Meson.hpp \ + Modules/MContraction/WeakMesonDecayKl2.hpp \ + Modules/MContraction/WeakNonEye3pt.hpp \ + Modules/MContraction/A2AFourQuarkContraction.hpp \ + Modules/MContraction/DiscLoop.hpp \ + Modules/MContraction/WeakEye3pt.hpp \ + Modules/MContraction/A2AAslashField.hpp \ + Modules/MContraction/Gamma3pt.hpp \ + Modules/MContraction/A2AMesonField.hpp \ + Modules/MContraction/SigmaToNucleonEye.hpp \ + Modules/MContraction/A2ALoop.hpp \ + Modules/MContraction/Baryon.hpp \ + Modules/MContraction/SigmaToNucleonNonEye.hpp \ + Modules/MScalar/FreeProp.hpp \ Modules/MScalar/ChargedProp.hpp \ Modules/MScalar/Scalar.hpp \ - Modules/MScalar/FreeProp.hpp + Modules/MSink/Point.hpp \ + Modules/MSink/Smear.hpp \ + Modules/MNoise/FullVolumeSpinColorDiagonal.hpp \ + Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp \ + Modules/MIO/LoadBinary.hpp \ + Modules/MIO/LoadNersc.hpp \ + Modules/MIO/LoadEigenPack.hpp \ + Modules/MIO/LoadA2AMatrixDiskVector.hpp \ + Modules/MIO/LoadCoarseEigenPack.hpp \ + Modules/MIO/LoadA2AVectors.hpp \ + Modules/MIO/LoadCosmHol.hpp \ + Modules/MScalarSUN/TwoPointNPR.hpp \ + Modules/MScalarSUN/TransProj.hpp \ + Modules/MScalarSUN/TwoPoint.hpp \ + Modules/MScalarSUN/TrPhi.hpp \ + Modules/MScalarSUN/Utils.hpp \ + Modules/MScalarSUN/TrMag.hpp \ + Modules/MScalarSUN/EMT.hpp \ + Modules/MScalarSUN/Grad.hpp \ + Modules/MScalarSUN/StochFreeField.hpp \ + Modules/MScalarSUN/Div.hpp \ + Modules/MScalarSUN/TrKinetic.hpp \ + Modules/MAction/ZMobiusDWF.hpp \ + Modules/MAction/ScaledDWF.hpp \ + Modules/MAction/WilsonClover.hpp \ + Modules/MAction/Wilson.hpp \ + Modules/MAction/MobiusDWF.hpp \ + Modules/MAction/DWF.hpp \ + Modules/MFermion/FreeProp.hpp \ + Modules/MFermion/EMLepton.hpp \ + Modules/MFermion/GaugeProp.hpp diff --git a/tests/hadrons/Test_sigma_to_nucleon.cc b/tests/hadrons/Test_sigma_to_nucleon.cc new file mode 100644 index 00000000..621a8f7c --- /dev/null +++ b/tests/hadrons/Test_sigma_to_nucleon.cc @@ -0,0 +1,154 @@ +/************************************************************************************* + +Grid physics library, www.github.com/paboyle/Grid + +Source file: Tests/Hadrons/Test_hadrons_spectrum.cc + +Copyright (C) 2015-2018 + + Author: Antonin Portelli + +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 + +using namespace Grid; +using namespace Hadrons; + +int main(int argc, char *argv[]) +{ + // initialization ////////////////////////////////////////////////////////// + Grid_init(&argc, &argv); + HadronsLogError.Active(GridLogError.isActive()); + HadronsLogWarning.Active(GridLogWarning.isActive()); + HadronsLogMessage.Active(GridLogMessage.isActive()); + HadronsLogIterative.Active(GridLogIterative.isActive()); + HadronsLogDebug.Active(GridLogDebug.isActive()); + LOG(Message) << "Grid initialized" << std::endl; + + // run setup /////////////////////////////////////////////////////////////// + Application application; + std::vector flavour = {"l", "s", "c"}; + std::vector mass = {.01, .04, .2 }; + + // global parameters + Application::GlobalPar globalPar; + globalPar.trajCounter.start = 1500; + globalPar.trajCounter.end = 1520; + globalPar.trajCounter.step = 20; + globalPar.runId = "test"; + application.setPar(globalPar); + // gauge field + application.createModule("gauge"); + // sources + MSource::Point::Par ptPar; + ptPar.position = "0 0 0 0"; + application.createModule("pt_0", ptPar); + ptPar.position = "0 0 0 4"; + application.createModule("pt_4", ptPar); + // sink + MSink::Point::Par sinkPar; + sinkPar.mom = "0 0 0"; + application.createModule("sink", sinkPar); + application.createModule("sink_spec", sinkPar); + + // set fermion boundary conditions to be periodic space, antiperiodic time. + std::string boundary = "1 1 1 -1"; + std::string twist = "0. 0. 0. 0."; + + for (unsigned int i = 0; i < flavour.size(); ++i) + { + // actions + MAction::DWF::Par actionPar; + actionPar.gauge = "gauge"; + actionPar.Ls = 12; + actionPar.M5 = 1.8; + actionPar.mass = mass[i]; + actionPar.boundary = boundary; + actionPar.twist = twist; + application.createModule("DWF_" + flavour[i], actionPar); + + // solvers + MSolver::RBPrecCG::Par solverPar; + solverPar.action = "DWF_" + flavour[i]; + solverPar.residual = 1.0e-8; + solverPar.maxIteration = 10000; + application.createModule("CG_" + flavour[i], + solverPar); + + } + + // propagators + MFermion::GaugeProp::Par quarkPar; + quarkPar.solver = "CG_l"; + quarkPar.source = "pt_0"; + application.createModule("Qpt_l_0", quarkPar); + quarkPar.source = "pt_4"; + application.createModule("Qpt_l_4", quarkPar); + quarkPar.solver = "CG_s"; + quarkPar.source = "pt_0"; + application.createModule("Qpt_s_0", quarkPar); + //This should be a loop - how do I make this? + quarkPar.solver = "CG_c"; + quarkPar.source = "pt_0"; + application.createModule("Qpt_c_loop", quarkPar); + quarkPar.solver = "CG_l"; + quarkPar.source = "pt_0"; + application.createModule("Qpt_l_loop", quarkPar); + + MSink::Smear::Par smearPar; + smearPar.q="Qpt_l_0"; + smearPar.sink = "sink_spec"; + application.createModule("Qpt_u_spec",smearPar); + + + MContraction::SigmaToNucleonEye::Par EyePar; + EyePar.output = "SigmaToNucleon/Eye_u"; + EyePar.qq_loop = "Qpt_l_loop"; + EyePar.qu_spec = "Qpt_u_spec"; + EyePar.qd_xf = "Qpt_l_4"; + EyePar.qs_xi = "Qpt_s_0"; + EyePar.tOut = 0; + EyePar.sink = "sink"; + application.createModule("SigmaToNucleonEye_u", EyePar); + EyePar.output = "SigmaToNucleon/Eye_c"; + EyePar.qq_loop = "Qpt_c_loop"; + application.createModule("SigmaToNucleonEye_c", EyePar); + MContraction::SigmaToNucleonNonEye::Par NonEyePar; + NonEyePar.output = "SigmaToNucleon/NonEye"; + NonEyePar.qu_xi = "Qpt_l_0"; + NonEyePar.qu_xf = "Qpt_l_4"; + NonEyePar.qu_spec = "Qpt_u_spec"; + NonEyePar.qd_xf = "Qpt_l_4"; + NonEyePar.qs_xi = "Qpt_s_0"; + NonEyePar.tOut = 0; + NonEyePar.sink = "sink"; + application.createModule("SigmaToNucleonNonEye", NonEyePar); + + // execution + application.saveParameterFile("stn.xml"); + application.run(); + + // epilogue + LOG(Message) << "Grid is finalizing now" << std::endl; + Grid_finalize(); + + return EXIT_SUCCESS; +}