From 9c31305b8dc59b6e1dc8ee5079200b161f06d87c Mon Sep 17 00:00:00 2001 From: Antonin Portelli Date: Mon, 4 Feb 2019 21:26:25 +0000 Subject: [PATCH] Hadrons: test cleaning --- tests/hadrons/Test_hadrons.hpp | 665 ------------------ .../hadrons/Test_hadrons_3pt_contractions.cc | 123 ---- .../hadrons/Test_hadrons_conserved_current.cc | 151 ---- .../Test_hadrons_meson_conserved_3pt.cc | 116 --- tests/hadrons/Test_hadrons_seq_gamma.cc | 90 --- tests/hadrons/Test_hadrons_wilsonFund.cc | 159 ----- 6 files changed, 1304 deletions(-) delete mode 100644 tests/hadrons/Test_hadrons.hpp delete mode 100644 tests/hadrons/Test_hadrons_3pt_contractions.cc delete mode 100644 tests/hadrons/Test_hadrons_conserved_current.cc delete mode 100644 tests/hadrons/Test_hadrons_meson_conserved_3pt.cc delete mode 100644 tests/hadrons/Test_hadrons_seq_gamma.cc delete mode 100644 tests/hadrons/Test_hadrons_wilsonFund.cc diff --git a/tests/hadrons/Test_hadrons.hpp b/tests/hadrons/Test_hadrons.hpp deleted file mode 100644 index 7f07bea5..00000000 --- a/tests/hadrons/Test_hadrons.hpp +++ /dev/null @@ -1,665 +0,0 @@ -/************************************************************************************* - -Grid physics library, www.github.com/paboyle/Grid - -Source file: Tests/Hadrons/Test_hadrons.hpp - -Copyright (C) 2015-2018 - - Author: Andrew Lawson - -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; - -/******************************************************************************* - * Macros to reduce code duplication. - ******************************************************************************/ -// Common initialisation -#define HADRONS_DEFAULT_INIT \ - 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; - -#define HADRONS_DEFAULT_GLOBALS(application) \ -{ \ - Application::GlobalPar globalPar; \ - globalPar.trajCounter.start = 1500; \ - globalPar.trajCounter.end = 1520; \ - globalPar.trajCounter.step = 20; \ - globalPar.runId = "test"; \ - globalPar.genetic.maxGen = 1000; \ - globalPar.genetic.maxCstGen = 200; \ - globalPar.genetic.popSize = 20; \ - globalPar.genetic.mutationRate = .1; \ - application.setPar(globalPar); \ -} - -// Useful definitions -#define ZERO_MOM "0. 0. 0. 0." -#define INIT_INDEX(s, n) (std::string(s) + "_" + std::to_string(n)) -#define ADD_INDEX(s, n) (s + "_" + std::to_string(n)) -#define LABEL_3PT(s, t1, t2) ADD_INDEX(INIT_INDEX(s, t1), t2) -#define LABEL_4PT(s, t1, t2, t3) ADD_INDEX(ADD_INDEX(INIT_INDEX(s, t1), t2), t3) -#define LABEL_4PT_NOISE(s, t1, t2, t3, nn) ADD_INDEX(ADD_INDEX(ADD_INDEX(INIT_INDEX(s, t1), t2), t3), nn) -#define LABEL_5D(s) s + "_5d"; - -// Wall source/sink macros -#define NAME_3MOM_WALL_SOURCE(t, mom) ("wall_" + std::to_string(t) + "_" + mom) -#define NAME_WALL_SOURCE(t) NAME_3MOM_WALL_SOURCE(t, ZERO_MOM) -#define NAME_POINT_SOURCE(pos) ("point_" + pos) - -// Meson module "gammas" special values -#define ALL_GAMMAS "all" - -#define MAKE_3MOM_WALL_PROP(tW, mom, propName, solver)\ -{\ - std::string srcName = NAME_3MOM_WALL_SOURCE(tW, mom);\ - makeWallSource(application, srcName, tW, mom);\ - makePropagator(application, propName, srcName, solver);\ -} - -#define MAKE_WALL_PROP(tW, propName, solver)\ - MAKE_3MOM_WALL_PROP(tW, ZERO_MOM, propName, solver) - -// Sequential source macros -#define MAKE_SEQUENTIAL_PROP(tS, qSrc, mom, seqPropName, solver, gamma)\ -{\ - std::string srcName = seqPropName + "_src";\ - makeSequentialSource(application, srcName, qSrc, tS, gamma, mom);\ - makePropagator(application, seqPropName, srcName, solver);\ -} - -// Point source macros -#define MAKE_POINT_PROP(pos, propName, solver)\ -{\ - std::string srcName = NAME_POINT_SOURCE(pos);\ - makePointSource(application, srcName, pos);\ - makePropagator(application, propName, srcName, solver);\ -} - -/******************************************************************************* - * Action setups. - ******************************************************************************/ - -/******************************************************************************* - * Name: makeWilsonAction - * Parameters: application - main application that stores modules. - * actionName - name of action module to create. - * gaugeField - gauge field module. - * mass - quark mass. - * boundary - fermion boundary conditions (default to periodic - * space, antiperiodic time). - * Returns: None. - ******************************************************************************/ -inline void makeWilsonAction(Application &application, std::string actionName, - std::string &gaugeField, double mass, - std::string boundary = "1 1 1 -1") -{ - if (!(VirtualMachine::getInstance().hasModule(actionName))) - { - MAction::Wilson::Par actionPar; - actionPar.gauge = gaugeField; - actionPar.mass = mass; - actionPar.boundary = boundary; - actionPar.twist = "0. 0. 0. 0."; - application.createModule(actionName, actionPar); - } -} - -/******************************************************************************* - * Name: makeDWFAction - * Parameters: application - main application that stores modules. - * actionName - name of action module to create. - * gaugeField - gauge field module. - * mass - quark mass. - * M5 - domain wall height. - * Ls - fifth dimension extent. - * boundary - fermion boundary conditions (default to periodic - * space, antiperiodic time). - * Returns: None. - ******************************************************************************/ -inline void makeDWFAction(Application &application, std::string actionName, - std::string &gaugeField, double mass, double M5, - unsigned int Ls, std::string boundary = "1 1 1 -1") -{ - if (!(VirtualMachine::getInstance().hasModule(actionName))) - { - MAction::DWF::Par actionPar; - actionPar.gauge = gaugeField; - actionPar.Ls = Ls; - actionPar.M5 = M5; - actionPar.mass = mass; - actionPar.boundary = boundary; - actionPar.twist = "0. 0. 0. 0."; - application.createModule(actionName, actionPar); - } -} - -/******************************************************************************* - * Functions for propagator construction. - ******************************************************************************/ - -/******************************************************************************* - * Name: makeRBPrecCGSolver - * Purpose: Make RBPrecCG solver module for specified action. - * Parameters: application - main application that stores modules. - * solverName - name of solver module to create. - * actionName - action module corresponding to propagators to be - * computed. - * residual - CG target residual. - * Returns: None. - ******************************************************************************/ -inline void makeRBPrecCGSolver(Application &application, std::string &solverName, - std::string &actionName, double residual = 1e-8) -{ - if (!(VirtualMachine::getInstance().hasModule(solverName))) - { - MSolver::RBPrecCG::Par solverPar; - solverPar.action = actionName; - solverPar.residual = residual; - solverPar.maxIteration = 10000; - application.createModule(solverName, - solverPar); - } -} - -/******************************************************************************* - * Name: makePointSource - * Purpose: Construct point source and add to application module. - * Parameters: application - main application that stores modules. - * srcName - name of source module to create. - * pos - Position of point source. - * Returns: None. - ******************************************************************************/ -inline void makePointSource(Application &application, std::string srcName, - std::string pos) -{ - // If the source already exists, don't make the module again. - if (!(VirtualMachine::getInstance().hasModule(srcName))) - { - MSource::Point::Par pointPar; - pointPar.position = pos; - application.createModule(srcName, pointPar); - } -} - -/******************************************************************************* - * Name: makeSequentialSource - * Purpose: Construct sequential source and add to application module. - * Parameters: application - main application that stores modules. - * srcName - name of source module to create. - * qSrc - Input quark for sequential inversion. - * tS - sequential source timeslice. - * mom - momentum insertion (default is zero). - * Returns: None. - ******************************************************************************/ -inline void makeSequentialSource(Application &application, std::string srcName, - std::string qSrc, unsigned int tS, - Gamma::Algebra gamma = Gamma::Algebra::GammaT, - std::string mom = ZERO_MOM) -{ - // If the source already exists, don't make the module again. - if (!(VirtualMachine::getInstance().hasModule(srcName))) - { - MSource::SeqGamma::Par seqPar; - seqPar.q = qSrc; - seqPar.tA = tS; - seqPar.tB = tS; - seqPar.mom = mom; - seqPar.gamma = gamma; - application.createModule(srcName, seqPar); - } -} - -/******************************************************************************* - * Name: makeConservedSequentialSource - * Purpose: Construct sequential source with conserved current insertion and - * add to application module. - * Parameters: application - main application that stores modules. - * srcName - name of source module to create. - * qSrc - Input quark for sequential inversion. - * actionName - action corresponding to quark. - * tS - sequential source timeslice. - * curr - conserved current type to insert. - * mu - Lorentz index of current to insert. - * mom - momentum insertion (default is zero). - * Returns: None. - ******************************************************************************/ -inline void makeConservedSequentialSource(Application &application, - std::string &srcName, - std::string &qSrc, - std::string &actionName, - unsigned int tS, - Current curr, - unsigned int mu, - std::string mom = ZERO_MOM) -{ - // If the source already exists, don't make the module again. - if (!(VirtualMachine::getInstance().hasModule(srcName))) - { - MSource::SeqConserved::Par seqPar; - seqPar.q = qSrc; - seqPar.action = actionName; - seqPar.tA = tS; - seqPar.tB = tS; - seqPar.curr_type = curr; - seqPar.mu_min = mu; - seqPar.mu_min = mu; - seqPar.mom = mom; - application.createModule(srcName, seqPar); - } -} - -/******************************************************************************* - * Name: makeNoiseSource - * Parameters: application - main application that stores modules. - * srcName - name of source module to create. - * tA - lower source timeslice limit. - * tB - upper source timeslice limit. - * Returns: None. - ******************************************************************************/ -inline void makeNoiseSource(Application &application, std::string &srcName, - unsigned int tA, unsigned int tB) -{ - if (!(VirtualMachine::getInstance().hasModule(srcName))) - { - MSource::Z2::Par noisePar; - noisePar.tA = tA; - noisePar.tB = tB; - application.createModule(srcName, noisePar); - } - } - -/******************************************************************************* - * Name: makeWallSource - * Purpose: Construct wall source and add to application module. - * Parameters: application - main application that stores modules. - * srcName - name of source module to create. - * tW - wall source timeslice. - * mom - momentum insertion (default is zero). - * Returns: None. - ******************************************************************************/ -inline void makeWallSource(Application &application, std::string &srcName, - unsigned int tW, std::string mom = ZERO_MOM) -{ - // If the source already exists, don't make the module again. - if (!(VirtualMachine::getInstance().hasModule(srcName))) - { - MSource::Wall::Par wallPar; - wallPar.tW = tW; - wallPar.mom = mom; - application.createModule(srcName, wallPar); - } -} - -/******************************************************************************* - * Name: makePointSink - * Purpose: Create function for point sink smearing of a propagator. - * Parameters: application - main application that stores modules. - * propName - name of input propagator. - * sinkFnct - name of output sink smearing module. - * mom - momentum insertion (default is zero). - * Returns: None. - ******************************************************************************/ -inline void makePointSink(Application &application, std::string &sinkFnct, - std::string mom = ZERO_MOM) -{ - // If the sink function already exists, don't make it again. - if (!(VirtualMachine::getInstance().hasModule(sinkFnct))) - { - MSink::Point::Par pointPar; - pointPar.mom = mom; - application.createModule(sinkFnct, pointPar); - } -} - -/******************************************************************************* - * Name: sinkSmear - * Purpose: Perform sink smearing of a propagator. - * Parameters: application - main application that stores modules. - * sinkFnct - sink smearing module. - * propName - propagator to smear. - * smearedProp - name of output smeared propagator. - * Returns: None. - ******************************************************************************/ -inline void sinkSmear(Application &application, std::string &sinkFnct, - std::string &propName, std::string &smearedProp) -{ - // If the propagator has already been smeared, don't smear it again. - if (!(VirtualMachine::getInstance().hasModule(smearedProp))) - { - MSink::Smear::Par smearPar; - smearPar.q = propName; - smearPar.sink = sinkFnct; - application.createModule(smearedProp, smearPar); - } -} - -/******************************************************************************* - * Name: makePropagator - * Purpose: Construct source and propagator then add to application module. - * Parameters: application - main application that stores modules. - * propName - name of propagator module to create. - * srcName - name of source module to use. - * solver - solver to use (default is CG). - * Returns: None. - ******************************************************************************/ -inline void makePropagator(Application &application, std::string &propName, - std::string &srcName, std::string &solver) -{ - // If the propagator already exists, don't make the module again. - if (!(VirtualMachine::getInstance().hasModule(propName))) - { - MFermion::GaugeProp::Par quarkPar; - quarkPar.source = srcName; - quarkPar.solver = solver; - application.createModule(propName, quarkPar); - } -} - -/******************************************************************************* - * Name: makeLoop - * Purpose: Use noise source and inversion result to make loop propagator, then - * add to application module. - * Parameters: application - main application that stores modules. - * propName - name of propagator module to create. - * srcName - name of noise source module to use. - * resName - name of inversion result on given noise source. - * Returns: None. - ******************************************************************************/ -inline void makeLoop(Application &application, std::string &propName, - std::string &srcName, std::string &resName) -{ - // If the loop propagator already exists, don't make the module again. - if (!(VirtualMachine::getInstance().hasModule(propName))) - { - MLoop::NoiseLoop::Par loopPar; - loopPar.q = resName; - loopPar.eta = srcName; - application.createModule(propName, loopPar); - } -} - -/******************************************************************************* - * Contraction module creation. - ******************************************************************************/ - -/******************************************************************************* - * Name: mesonContraction - * Purpose: Create meson contraction module and add to application module. - * Parameters: application - main application that stores modules. - * modName - unique module name. - * output - name of output files. - * q1 - quark propagator 1. - * q2 - quark propagator 2. - * sink - sink smearing module. - * gammas - gamma insertions at source and sink. - * Returns: None. - ******************************************************************************/ -inline void mesonContraction(Application &application, - std::string &modName, std::string &output, - std::string &q1, std::string &q2, - std::string &sink, - std::string gammas = "") -{ - if (!(VirtualMachine::getInstance().hasModule(modName))) - { - MContraction::Meson::Par mesPar; - mesPar.output = output; - mesPar.q1 = q1; - mesPar.q2 = q2; - mesPar.sink = sink; - mesPar.gammas = gammas; - application.createModule(modName, mesPar); - } - } - -/******************************************************************************* - * Name: gamma3ptContraction - * Purpose: Create gamma3pt contraction module and add to application module. - * Parameters: application - main application that stores modules. - * npt - specify n-point correlator (for labelling). - * q1 - quark propagator 1, sink smeared. - * q2 - quark propagator 2. - * q3 - quark propagator 3. - * label - unique label to construct module name. - * tSnk - sink position of sink for q1. - * gamma - gamma insertions between q2 and q3. - * Returns: None. - ******************************************************************************/ -inline void gamma3ptContraction(Application &application, unsigned int npt, - std::string &q1, std::string &q2, - std::string &q3, std::string &label, - unsigned int tSnk = 0, - Gamma::Algebra gamma = Gamma::Algebra::Identity) -{ - std::string modName = std::to_string(npt) + "pt_" + label; - if (!(VirtualMachine::getInstance().hasModule(modName))) - { - MContraction::Gamma3pt::Par gamma3ptPar; - gamma3ptPar.output = std::to_string(npt) + "pt/" + label; - gamma3ptPar.q1 = q1; - gamma3ptPar.q2 = q2; - gamma3ptPar.q3 = q3; - gamma3ptPar.tSnk = tSnk; - gamma3ptPar.gamma = gamma; - application.createModule(modName, gamma3ptPar); - } - } - -/******************************************************************************* - * Name: weakContraction[Eye,NonEye] - * Purpose: Create Weak Hamiltonian contraction module for Eye/NonEye topology - * and add to application module. - * Parameters: application - main application that stores modules. - * npt - specify n-point correlator (for labelling). - * q1 - quark propagator 1. - * q2 - quark propagator 2. - * q3 - quark propagator 3. - * q4 - quark propagator 4. - * label - unique label to construct module name. - * tSnk - time position of sink (for sink smearing). - * Returns: None. - ******************************************************************************/ -#define HW_CONTRACTION(top) \ -inline void weakContraction##top(Application &application, unsigned int npt,\ - std::string &q1, std::string &q2, \ - std::string &q3, std::string &q4, \ - std::string &label, unsigned int tSnk = 0)\ -{\ - std::string modName = std::to_string(npt) + "pt_" + label;\ - if (!(VirtualMachine::getInstance().hasModule(modName)))\ - {\ - MContraction::WeakHamiltonian##top::Par weakPar;\ - weakPar.output = std::to_string(npt) + "pt/" + label;\ - weakPar.q1 = q1;\ - weakPar.q2 = q2;\ - weakPar.q3 = q3;\ - weakPar.q4 = q4;\ - weakPar.tSnk = tSnk;\ - application.createModule(modName, weakPar);\ - }\ -} -HW_CONTRACTION(Eye) // weakContractionEye -HW_CONTRACTION(NonEye) // weakContractionNonEye - -/******************************************************************************* - * Name: disc0Contraction - * Purpose: Create contraction module for 4pt Weak Hamiltonian + current - * disconnected topology for neutral mesons and add to application - * module. - * Parameters: application - main application that stores modules. - * q1 - quark propagator 1. - * q2 - quark propagator 2. - * q3 - quark propagator 3. - * q4 - quark propagator 4. - * label - unique label to construct module name. - * Returns: None. - ******************************************************************************/ -inline void disc0Contraction(Application &application, - std::string &q1, std::string &q2, - std::string &q3, std::string &q4, - std::string &label) -{ - std::string modName = "4pt_" + label; - if (!(VirtualMachine::getInstance().hasModule(modName))) - { - MContraction::WeakNeutral4ptDisc::Par disc0Par; - disc0Par.output = "4pt/" + label; - disc0Par.q1 = q1; - disc0Par.q2 = q2; - disc0Par.q3 = q3; - disc0Par.q4 = q4; - application.createModule(modName, disc0Par); - } - } - -/******************************************************************************* - * Name: discLoopContraction - * Purpose: Create contraction module for disconnected loop and add to - * application module. - * Parameters: application - main application that stores modules. - * q_loop - loop quark propagator. - * modName - unique module name. - * gamma - gamma matrix to use in contraction. - * Returns: None. - ******************************************************************************/ -inline void discLoopContraction(Application &application, - std::string &q_loop, std::string &modName, - Gamma::Algebra gamma = Gamma::Algebra::Identity) -{ - if (!(VirtualMachine::getInstance().hasModule(modName))) - { - MContraction::DiscLoop::Par discPar; - discPar.output = "disc/" + modName; - discPar.q_loop = q_loop; - discPar.gamma = gamma; - application.createModule(modName, discPar); - } -} - -/******************************************************************************* - * Name: makeWITest - * Purpose: Create module to test Ward Identities for conserved current - * contractions and add to application module. - * Parameters: application - main application that stores modules. - * modName - name of module to create. - * propName - 4D quark propagator. - * actionName - action used to compute quark propagator. - * mass - mass of quark. - * Ls - length of 5th dimension (default = 1). - * test_axial - whether or not to check PCAC relation. - * Returns: None. - ******************************************************************************/ -inline void makeWITest(Application &application, std::string &modName, - std::string &propName, std::string &actionName, - double mass, unsigned int Ls = 1, bool test_axial = false) -{ - if (!(VirtualMachine::getInstance().hasModule(modName))) - { - MContraction::WardIdentity::Par wiPar; - if (Ls > 1) - { - wiPar.q = LABEL_5D(propName); - } - else - { - wiPar.q = propName; - } - wiPar.action = actionName; - wiPar.mass = mass; - wiPar.test_axial = test_axial; - application.createModule(modName, wiPar); - } -} - -/******************************************************************************* - * Name: makeSeqCurrComparison - * Purpose: Create module to compare sequential insertion of conserved current - * against sink contraction and add to application module. - * Parameters: application - main application that stores modules. - * modName - name of module to create. - * propName - quark propagator (point source), 5D if available. - * seqName - 4D quark propagator with sequential insertion of - * conserved current. - * actionName - action used to compute quark propagators. - * origin - origin of point source propagator. - * t_J - time at which sequential current is inserted. - * mu - Lorentz index of sequential current. - * curr - type of conserved current inserted. - * Returns: None. - ******************************************************************************/ -inline void makeSeqCurrComparison(Application &application, std::string &modName, - std::string &propName, std::string &seqName, - std::string &actionName, std::string &origin, - unsigned int t_J, unsigned int mu, Current curr) -{ - if (!(VirtualMachine::getInstance().hasModule(modName))) - { - MUtilities::TestSeqConserved::Par seqPar; - seqPar.q = propName; - seqPar.qSeq = seqName; - seqPar.action = actionName; - seqPar.origin = origin; - seqPar.t_J = t_J; - seqPar.mu = mu; - seqPar.curr = curr; - application.createModule(modName, seqPar); - } -} - -/******************************************************************************* - * Name: makeSeqGamComparison - * Purpose: Create module to compare sequential insertion of gamma matrix - * against sink contraction and add to application module. - * Parameters: application - main application that stores modules. - * modName - name of module to create. - * propName - 4D quark propagator. - * seqProp - 4D quark propagator with sequential insertion of - * gamma matrix. - * gamma - Inserted gamma matrix. - * t_g - time at which gamma matrix is inserted - * sequentially. - * Returns: None. - ******************************************************************************/ -inline void makeSeqGamComparison(Application &application, std::string &modName, - std::string &propName, std::string &seqProp, - std::string &origin, Gamma::Algebra gamma, - unsigned int t_g) -{ - if (!(VirtualMachine::getInstance().hasModule(modName))) - { - MUtilities::TestSeqGamma::Par seqPar; - seqPar.q = propName; - seqPar.qSeq = seqProp; - seqPar.origin = origin; - seqPar.t_g = t_g; - seqPar.gamma = gamma; - application.createModule(modName, seqPar); - } -} diff --git a/tests/hadrons/Test_hadrons_3pt_contractions.cc b/tests/hadrons/Test_hadrons_3pt_contractions.cc deleted file mode 100644 index 09c478bb..00000000 --- a/tests/hadrons/Test_hadrons_3pt_contractions.cc +++ /dev/null @@ -1,123 +0,0 @@ -/************************************************************************************* - -Grid physics library, www.github.com/paboyle/Grid - -Source file: Tests/Hadrons/Test_hadrons_3pt_contractions.cc - -Copyright (C) 2015-2018 - - Author: Andrew Lawson - -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 "Test_hadrons.hpp" - -using namespace Grid; -using namespace Hadrons; - -int main(int argc, char *argv[]) -{ - // initialization ////////////////////////////////////////////////////////// - HADRONS_DEFAULT_INIT; - - // run setup /////////////////////////////////////////////////////////////// - Application application; - double mass = 0.04; - double M5 = 1.8; - unsigned int Ls = 12; - unsigned int nt = GridDefaultLatt()[Tp]; - unsigned int t_i = 0; - unsigned int t_f = nt / 2; - std::string mom = "1. 0. 0. 0."; - - // global parameters - HADRONS_DEFAULT_GLOBALS(application); - - // gauge field - std::string gaugeField = "gauge"; - application.createModule(gaugeField); - - // Action & solver setup. - std::string action = "DWF"; - std::string solver = "CG"; - makeDWFAction(application, action, gaugeField, mass, M5, Ls); - makeRBPrecCGSolver(application, solver, action); - - /*************************************************************************** - * Weak Contraction test: Non-Eye class. - **************************************************************************/ - // Make wall source propagators for each leg of 4-quark vertex. - std::string q_i_0 = "q_i_0"; - std::string q_i_p = "q_i_p"; - std::string q_f_0 = "q_f_0"; - std::string q_f_p = "q_f_p"; - MAKE_WALL_PROP(t_i, q_i_0, solver); - MAKE_WALL_PROP(t_f, q_f_0, solver); - MAKE_3MOM_WALL_PROP(t_i, mom, q_i_p, solver); - MAKE_3MOM_WALL_PROP(t_f, mom, q_f_p, solver); - - // Perform contractions, zero and non-zero momentum. - std::string HW_CW_0 = LABEL_3PT("HW_CW_0", t_i, t_f); - std::string HW_CW_p = LABEL_3PT("HW_CW_p", t_i, t_f); - weakContractionNonEye(application, 3, q_i_0, q_i_0, q_f_0, q_f_0, HW_CW_0); - weakContractionNonEye(application, 3, q_i_0, q_i_p, q_f_p, q_f_0, HW_CW_p); - - /*************************************************************************** - * Weak Contraction test: Eye-class. - **************************************************************************/ - // Create random propagator for loop. - std::string eta = "noise_source"; - makeNoiseSource(application, eta, 0, nt - 1); - std::string loopProp = "loop"; - std::string loopRes = loopProp + "_res"; - makePropagator(application, loopRes, eta, solver); - makeLoop(application, loopProp, eta, loopRes); - - // Wall sink smear the propagator directly connecting the source & sink. - // (i.e. make point sink but smear before the contraction) - std::string wallSink = "wall_sink"; - std::string qWall = "q_wall"; - makePointSink(application, wallSink); - sinkSmear(application, wallSink, q_i_0, qWall); - - // Perform contractions, zero and non-zero momentum. - std::string HW_SE_0 = LABEL_3PT("HW_SE_0", t_i, t_f); - std::string HW_SE_p = LABEL_3PT("HW_SE_p", t_i, t_f); - weakContractionEye(application, 3, qWall, q_i_0, q_f_p, loopProp, HW_SE_0, t_f); - weakContractionEye(application, 3, qWall, q_i_p, q_f_p, loopProp, HW_SE_p, t_f); - - /*************************************************************************** - * Gamma insertion test. - **************************************************************************/ - Gamma::Algebra gamma = Gamma::Algebra::GammaT; - std::string sd_0 = LABEL_3PT("sd_0", t_i, t_f); - std::string sd_p = LABEL_3PT("sd_p", t_i, t_f); - gamma3ptContraction(application, 3, qWall, q_i_0, q_f_0, sd_0, t_f, gamma); - gamma3ptContraction(application, 3, qWall, q_i_p, q_f_p, sd_p, t_f, gamma); - - // execution - application.saveParameterFile("ContractionTest3pt.xml"); - application.run(); - - // epilogue - LOG(Message) << "Grid is finalizing now" << std::endl; - Grid_finalize(); - - return EXIT_SUCCESS; -} diff --git a/tests/hadrons/Test_hadrons_conserved_current.cc b/tests/hadrons/Test_hadrons_conserved_current.cc deleted file mode 100644 index b8345af7..00000000 --- a/tests/hadrons/Test_hadrons_conserved_current.cc +++ /dev/null @@ -1,151 +0,0 @@ -/************************************************************************************* - -Grid physics library, www.github.com/paboyle/Grid - -Source file: Tests/Hadrons/Test_hadrons_conserved_current.cc - -Copyright (C) 2015-2018 - - Author: Andrew Lawson - -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 "Test_hadrons.hpp" - -using namespace Grid; -using namespace Hadrons; - -inline void setupSeqCurrTests(Application &application, std::string modStem, - std::string &pointProp, std::string &seqStem, - std::string &actionName, std::string &solverName, - std::string &origin, Current curr, - unsigned int t_J, unsigned int mu, - unsigned int Ls = 1) -{ - std::string modName = ADD_INDEX(modStem, mu); - std::string seqProp = ADD_INDEX(seqStem, mu); - std::string seqSrc = seqProp + "_src"; - - // 5D actions require 5D propagator as input for conserved current - // insertions. - std::string propIn; - if (Ls > 1) - { - propIn = LABEL_5D(pointProp); - } - else - { - propIn = pointProp; - } - - makeConservedSequentialSource(application, seqSrc, propIn, - actionName, t_J, curr, mu); - makePropagator(application, seqProp, seqSrc, solverName); - makeSeqCurrComparison(application, modName, propIn, seqProp, - actionName, origin, t_J, mu, curr); -} - -inline void setupWardIdentityTests(Application &application, - std::string &actionName, - double mass, - unsigned int Ls = 1, - bool perform_axial_tests = false) -{ - // solver - std::string solverName = actionName + "_CG"; - makeRBPrecCGSolver(application, solverName, actionName); - - unsigned int nt = GridDefaultLatt()[Tp]; - unsigned int t_J = nt/2; - - /*************************************************************************** - * Conserved current sink contractions: use a single point propagator for - * the Ward Identity test. - **************************************************************************/ - std::string pointProp = actionName + "_q_0"; - std::string origin = "0 0 0 0"; - std::string modName = actionName + " Ward Identity Test"; - MAKE_POINT_PROP(origin, pointProp, solverName); - makeWITest(application, modName, pointProp, actionName, mass, Ls, - perform_axial_tests); - - /*************************************************************************** - * Conserved current tests with sequential insertion of vector/axial - * current. If above Ward Identity passes, sufficient to test sequential - * insertion of conserved current agrees with contracted version. - **************************************************************************/ - // Compare sequential insertion to contraction. Should be enough to perform - // for time and one space component. - std::string seqStem = ADD_INDEX(pointProp + "seq_V", t_J); - std::string modStem = actionName + " Vector Sequential Test mu"; - setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, - solverName, origin, Current::Vector, t_J, Tp, Ls); - setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, - solverName, origin, Current::Vector, t_J, Xp, Ls); - - // Perform axial tests only if partially-conserved axial current exists for - // the action. - if (perform_axial_tests) - { - seqStem = ADD_INDEX(pointProp + "seq_A", t_J); - modStem = actionName + " Axial Sequential Test mu"; - setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, - solverName, origin, Current::Axial, t_J, Tp, Ls); - setupSeqCurrTests(application, modStem, pointProp, seqStem, actionName, - solverName, origin, Current::Axial, t_J, Xp, Ls); - } -} - -int main(int argc, char *argv[]) -{ - // initialization ////////////////////////////////////////////////////////// - HADRONS_DEFAULT_INIT; - - // run setup /////////////////////////////////////////////////////////////// - Application application; - double mass = 0.04; - double M5 = 1.8; - unsigned int Ls = 12; - - // global parameters - HADRONS_DEFAULT_GLOBALS(application); - - // gauge field - std::string gaugeField = "gauge"; - application.createModule(gaugeField); - - // Setup each action and the conserved current tests relevant to it. - std::string actionName = "DWF"; - makeDWFAction(application, actionName, gaugeField, mass, M5, Ls); - setupWardIdentityTests(application, actionName, mass, Ls, true); - - actionName = "Wilson"; - makeWilsonAction(application, actionName, gaugeField, mass); - setupWardIdentityTests(application, actionName, mass); - - // execution - application.saveParameterFile("ConservedCurrentTest.xml"); - application.run(); - - // epilogue - LOG(Message) << "Grid is finalizing now" << std::endl; - Grid_finalize(); - - return EXIT_SUCCESS; -} diff --git a/tests/hadrons/Test_hadrons_meson_conserved_3pt.cc b/tests/hadrons/Test_hadrons_meson_conserved_3pt.cc deleted file mode 100644 index 1246de02..00000000 --- a/tests/hadrons/Test_hadrons_meson_conserved_3pt.cc +++ /dev/null @@ -1,116 +0,0 @@ -/************************************************************************************* - -Grid physics library, www.github.com/paboyle/Grid - -Source file: Tests/Hadrons/Test_hadrons_meson_conserved_3pt.cc - -Copyright (C) 2015-2018 - - Author: Andrew Lawson - -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 "Test_hadrons.hpp" - -using namespace Grid; -using namespace Hadrons; - -int main(int argc, char *argv[]) -{ - // initialization ////////////////////////////////////////////////////////// - HADRONS_DEFAULT_INIT; - - // run setup /////////////////////////////////////////////////////////////// - Application application; - - // actions parameters - double mass = 0.04; - unsigned int Ls = 16; - double M5 = 1.8; - - // kinematics - unsigned int nt = GridDefaultLatt()[Tp]; - unsigned int tSrc = 0; - unsigned int tJ = nt / 4; - std::string kmom = "0. 0. 0. 0."; - std::string pmom = "1. 0. 0. 0."; - - // Global parameters. - HADRONS_DEFAULT_GLOBALS(application); - - // Unit gauge field. - std::string gaugeField = "Unit gauge"; - application.createModule(gaugeField); - - // DWF action - std::string actionName = "DWF"; - makeDWFAction(application, actionName, gaugeField, mass, M5, Ls); - - // Solver - std::string solver = "CG"; - makeRBPrecCGSolver(application, solver, actionName); - - // main test body ////////////////////////////////////////////////////////// - // Point sink modules. - std::string sink_0 = "sink_0"; - std::string sink_p = "sink_p"; - MSink::Point::Par sinkPar; - sinkPar.mom = kmom; - application.createModule(sink_0, sinkPar); - sinkPar.mom = pmom; - application.createModule(sink_p, sinkPar); - - // 2pt pion contraction, zero momentum. - std::string q_0 = "Q_0"; - MAKE_WALL_PROP(tSrc, q_0, solver); - std::string modName = INIT_INDEX("2pt_pion_WP", tSrc); - std::string output = "2pt/pion_WP_0"; - mesonContraction(application, modName, output, q_0, q_0, sink_0); - - // 2pt pion contraction, with momentum p. - std::string q_p = "Q_p"; - MAKE_3MOM_WALL_PROP(tSrc, pmom, q_p, solver); - modName = INIT_INDEX("2pt_pion_WP_p", tSrc); - output = "2pt/pion_WP_p"; - mesonContraction(application, modName, output, q_0, q_p, sink_p); - - // 3pt pion(0) -> pion(p), with sequentially inserted vector current in - // time direction. - std::string qSeq = q_0 + INIT_INDEX("_seq_Vc3", tJ); - std::string q5d = LABEL_5D(q_0); // Need 5D prop for DWF conserved current. - std::string srcName = qSeq + "_src"; - modName = LABEL_3PT("3pt_pion_Vc3", tSrc, tJ); - output = "3pt/pion_Vc3_p"; - makeConservedSequentialSource(application, srcName, q5d, actionName, - tJ, Current::Vector, Tp, pmom); - makePropagator(application, qSeq, srcName, solver); - mesonContraction(application, modName, output, q_0, qSeq, sink_p); - - std::string par_file_name = "conserved_3pt.xml"; - application.saveParameterFile(par_file_name); - application.run(); - - // epilogue - LOG(Message) << "Grid is finalizing now" << std::endl; - Grid_finalize(); - - return EXIT_SUCCESS; -} - - diff --git a/tests/hadrons/Test_hadrons_seq_gamma.cc b/tests/hadrons/Test_hadrons_seq_gamma.cc deleted file mode 100644 index 5e10b9f5..00000000 --- a/tests/hadrons/Test_hadrons_seq_gamma.cc +++ /dev/null @@ -1,90 +0,0 @@ -/************************************************************************************* - -Grid physics library, www.github.com/paboyle/Grid - -Source file: Tests/Hadrons/Test_hadrons_seq_gamma.cc - -Copyright (C) 2015-2018 - - Author: Andrew Lawson - -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 "Test_hadrons.hpp" - -using namespace Grid; -using namespace QCD; -using namespace Hadrons; - -/******************************************************************************* - * Consistency test for sequential gamma insertion. - ******************************************************************************/ - -int main(int argc, char *argv[]) -{ - // initialization ////////////////////////////////////////////////////////// - HADRONS_DEFAULT_INIT; - - // run setup /////////////////////////////////////////////////////////////// - Application application; - unsigned int nt = GridDefaultLatt()[Tp]; - unsigned int tS = nt / 2; - unsigned int Ls = 12; - double mass = 0.04; - double M5 = 1.8; - - // global parameters - HADRONS_DEFAULT_GLOBALS(application); - - // gauge field - std::string gaugeField = "gauge"; - application.createModule(gaugeField); - - // action - std::string actionName = "DWF"; - makeDWFAction(application, actionName, gaugeField, mass, M5, Ls); - - // solver - std::string solverName = "CG"; - makeRBPrecCGSolver(application, solverName, actionName); - - // test sequential propagator, with g5 insertion. - Gamma::Algebra g = Gamma::Algebra::Gamma5; - std::string pointProp = "q_0"; - std::string point5d = LABEL_5D(pointProp); - std::string origin = "0 0 0 0"; - MAKE_POINT_PROP(origin, pointProp, solverName); - - std::string seqProp = ADD_INDEX(pointProp + "_seqg5", tS); - std::string seqSrc = seqProp + "_src"; - MAKE_SEQUENTIAL_PROP(tS, pointProp, ZERO_MOM, seqProp, solverName, g); - - std::string modName = "Test g5 sequential insertion"; - makeSeqGamComparison(application, modName, pointProp, seqProp, origin, g, tS); - - // execution - application.saveParameterFile("SeqGamma5Test.xml"); - application.run(); - - // epilogue - LOG(Message) << "Grid is finalizing now" << std::endl; - Grid_finalize(); - - return EXIT_SUCCESS; -} diff --git a/tests/hadrons/Test_hadrons_wilsonFund.cc b/tests/hadrons/Test_hadrons_wilsonFund.cc deleted file mode 100644 index df621812..00000000 --- a/tests/hadrons/Test_hadrons_wilsonFund.cc +++ /dev/null @@ -1,159 +0,0 @@ -/************************************************************************************* - -Grid physics library, www.github.com/paboyle/Grid - -Source file: Tests/Hadrons/Test_hadrons_wilsonFund.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"}; - std::vector mass = {-0.1}; - double csw = 0.0; - - // global parameters - Application::GlobalPar globalPar; - - globalPar.trajCounter.start = 309; - globalPar.trajCounter.end = 310; - globalPar.trajCounter.step = 1; - globalPar.runId = "test"; - - application.setPar(globalPar); - // gauge field - application.createModule("gauge"); - - // sources - //MSource::Z2::Par z2Par; - //z2Par.tA = 0; - //z2Par.tB = 0; - //application.createModule("z2", z2Par); - MSource::Point::Par ptPar; - ptPar.position = "0 0 0 0"; - application.createModule("pt", ptPar); - // sink - MSink::Point::Par sinkPar; - sinkPar.mom = "0 0 0"; - application.createModule("sink", sinkPar); - - // set fermion boundary conditions to be periodic space, antiperiodic time. - std::string boundary = "1 1 1 -1"; - - for (unsigned int i = 0; i < flavour.size(); ++i) - { - // actions - MAction::WilsonClover::Par actionPar; - actionPar.gauge = "gauge"; - actionPar.mass = mass[i]; - actionPar.boundary = boundary; - actionPar.csw_r = csw; - actionPar.csw_t = csw; - - // !!!!! Check if Anisotropy works !!!!! - actionPar.clover_anisotropy.isAnisotropic= false; - actionPar.clover_anisotropy.t_direction = 3 ; // Explicit for D=4 - actionPar.clover_anisotropy.xi_0 = 1.0 ; - actionPar.clover_anisotropy.nu = 1.0 ; - - application.createModule("WilsonClover_" + flavour[i], actionPar); - - // solvers - MSolver::RBPrecCG::Par solverPar; - solverPar.action = "WilsonClover_" + flavour[i]; - solverPar.residual = 1.0e-8; - solverPar.maxIteration = 10000; - application.createModule("CG_" + flavour[i], - solverPar); - - // propagators - MFermion::GaugeProp::Par quarkPar; - quarkPar.solver = "CG_" + flavour[i]; - quarkPar.source = "pt"; - application.createModule("Qpt_" + flavour[i], quarkPar); - // quarkPar.source = "z2"; - // application.createModule("QZ2_" + flavour[i], quarkPar); - } - for (unsigned int i = 0; i < flavour.size(); ++i) - for (unsigned int j = i; j < flavour.size(); ++j) - { - MContraction::Meson::Par mesPar; - - mesPar.output = "Fund_mesons/pt_" + flavour[i] + flavour[j]; - mesPar.q1 = "Qpt_" + flavour[i]; - mesPar.q2 = "Qpt_" + flavour[j]; - mesPar.gammas = "all"; - mesPar.sink = "sink"; - application.createModule("meson_pt_" - + flavour[i] + flavour[j], - mesPar); - // mesPar.output = "mesons/Z2_" + flavour[i] + flavour[j]; - // mesPar.q1 = "QZ2_" + flavour[i]; - // mesPar.q2 = "QZ2_" + flavour[j]; - // mesPar.gammas = "all"; - // mesPar.sink = "sink"; - // application.createModule("meson_Z2_" - // + flavour[i] + flavour[j], - // mesPar); - } - for (unsigned int i = 0; i < flavour.size(); ++i) - for (unsigned int j = i; j < flavour.size(); ++j) - for (unsigned int k = j; k < flavour.size(); ++k) - { - MContraction::Baryon::Par barPar; - - barPar.output = "Fund_baryons/pt_" + flavour[i] + flavour[j] + flavour[k]; - barPar.q1 = "Qpt_" + flavour[i]; - barPar.q2 = "Qpt_" + flavour[j]; - barPar.q3 = "Qpt_" + flavour[k]; - application.createModule( - "baryon_pt_" + flavour[i] + flavour[j] + flavour[k], barPar); - } - - // execution - application.saveParameterFile("WilsonClover_spectrum.xml"); - application.run(); - - // epilogue - LOG(Message) << "Grid is finalizing now" << std::endl; - Grid_finalize(); - - return EXIT_SUCCESS; -}