portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-04-04 19:25:56 +01:00
Code Releases Activity

Added generators for the adjoint representation

Browse Source
This commit is contained in:
Guido Cossu 2016-07-08 15:40:11 +01:00
parent fbf96b1bbb
commit 5028969d4b
15 changed files with 780 additions and 665 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
benchmarks/Benchmark_dwf_ntpf
View File

Binary file not shown.

BIN
benchmarks/Benchmark_zmm
View File

Binary file not shown.

224
lib/qcd/hmc/integrators/Integrator.h
View File

@ -1,33 +1,34 @@
/************************************************************************************* /*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid Grid physics library, www.github.com/paboyle/Grid
Source file: ./lib/qcd/hmc/integrators/Integrator.h Source file: ./lib/qcd/hmc/integrators/Integrator.h
Copyright (C) 2015 Copyright (C) 2015
Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk> Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
Author: Peter Boyle <paboyle@ph.ed.ac.uk> Author: Peter Boyle <paboyle@ph.ed.ac.uk>
Author: neo <cossu@post.kek.jp> Author: neo <cossu@post.kek.jp>
Author: paboyle <paboyle@ph.ed.ac.uk> Author: paboyle <paboyle@ph.ed.ac.uk>
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License along 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., with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
See the full license in the file "LICENSE" in the top level distribution directory See the full license in the file "LICENSE" in the top level distribution
*************************************************************************************/ directory
/* END LEGAL */ *************************************************************************************/
/* END LEGAL */
//-------------------------------------------------------------------- //--------------------------------------------------------------------
/*! @file Integrator.h /*! @file Integrator.h
* @brief Classes for the Molecular Dynamics integrator * @brief Classes for the Molecular Dynamics integrator
@ -40,39 +41,32 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
#ifndef INTEGRATOR_INCLUDED #ifndef INTEGRATOR_INCLUDED
#define INTEGRATOR_INCLUDED #define INTEGRATOR_INCLUDED
//class Observer; // class Observer;
#include <memory> #include <memory>
namespace Grid{ namespace Grid {
namespace QCD{ namespace QCD {
struct IntegratorParameters{
struct IntegratorParameters {
int Nexp; int Nexp;
int MDsteps; // number of outer steps int MDsteps; // number of outer steps
RealD trajL; // trajectory length RealD trajL; // trajectory length
RealD stepsize; RealD stepsize;
IntegratorParameters(int MDsteps_, IntegratorParameters(int MDsteps_, RealD trajL_ = 1.0, int Nexp_ = 12)
RealD trajL_=1.0, : Nexp(Nexp_),
int Nexp_=12):
Nexp(Nexp_),
MDsteps(MDsteps_), MDsteps(MDsteps_),
trajL(trajL_), trajL(trajL_),
stepsize(trajL/MDsteps) stepsize(trajL / MDsteps){
{
// empty body constructor // empty body constructor
}; };
};
}; /*! @brief Class for Molecular Dynamics management */
template <class GaugeField, class SmearingPolicy>
/*! @brief Class for Molecular Dynamics management */ class Integrator {
template<class GaugeField, class SmearingPolicy>
class Integrator {
protected: protected:
typedef IntegratorParameters ParameterType; typedef IntegratorParameters ParameterType;
IntegratorParameters Params; IntegratorParameters Params;
@ -85,64 +79,71 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
GaugeField P; GaugeField P;
SmearingPolicy &Smearer; SmearingPolicy& Smearer;
// Should match any legal (SU(n)) gauge field // Should match any legal (SU(n)) gauge field
// Need to use this template to match Ncol to pass to SU<N> class // Need to use this template to match Ncol to pass to SU<N> class
template<int Ncol,class vec> void generate_momenta(Lattice< iVector< iScalar< iMatrix<vec,Ncol> >, Nd> > & P,GridParallelRNG& pRNG){ template <int Ncol, class vec>
typedef Lattice< iScalar< iScalar< iMatrix<vec,Ncol> > > > GaugeLinkField; void generate_momenta(Lattice<iVector<iScalar<iMatrix<vec, Ncol> >, Nd> >& P,
GridParallelRNG& pRNG) {
typedef Lattice<iScalar<iScalar<iMatrix<vec, Ncol> > > > GaugeLinkField;
GaugeLinkField Pmu(P._grid); GaugeLinkField Pmu(P._grid);
Pmu = zero; Pmu = zero;
for(int mu=0;mu<Nd;mu++){ for (int mu = 0; mu < Nd; mu++) {
SU<Ncol>::GaussianLieAlgebraMatrix(pRNG, Pmu); SU<Ncol>::GaussianFundamentalLieAlgebraMatrix(pRNG, Pmu);
PokeIndex<LorentzIndex>(P, Pmu, mu); PokeIndex<LorentzIndex>(P, Pmu, mu);
} }
} }
// ObserverList observers; // not yet
//ObserverList observers; // not yet
// typedef std::vector<Observer*> ObserverList; // typedef std::vector<Observer*> ObserverList;
// void register_observers(); // void register_observers();
// void notify_observers(); // void notify_observers();
void update_P(GaugeField&U, int level, double ep){ void update_P(GaugeField& U, int level, double ep) {
t_P[level]+=ep; t_P[level] += ep;
update_P(P,U,level,ep); update_P(P, U, level, ep);
std::cout<<GridLogIntegrator<<"["<<level<<"] P " << " dt "<< ep <<" : t_P "<< t_P[level] <<std::endl; std::cout << GridLogIntegrator << "[" << level << "] P "
<< " dt " << ep << " : t_P " << t_P[level] << std::endl;
} }
void update_P(GaugeField &Mom,GaugeField&U, int level,double ep){ void update_P(GaugeField& Mom, GaugeField& U, int level, double ep) {
// input U actually not used... // input U actually not used...
for(int a=0; a<as[level].actions.size(); ++a){ for (int a = 0; a < as[level].actions.size(); ++a) {
GaugeField force(U._grid); GaugeField force(U._grid);
GaugeField& Us = Smearer.get_U(as[level].actions.at(a)->is_smeared); GaugeField& Us = Smearer.get_U(as[level].actions.at(a)->is_smeared);
as[level].actions.at(a)->deriv(Us,force); // deriv should NOT include Ta as[level].actions.at(a)->deriv(Us, force); // deriv should NOT include Ta
std::cout<< GridLogIntegrator << "Smearing (on/off): "<<as[level].actions.at(a)->is_smeared <<std::endl; std::cout << GridLogIntegrator
<< "Smearing (on/off): " << as[level].actions.at(a)->is_smeared
<< std::endl;
if (as[level].actions.at(a)->is_smeared) Smearer.smeared_force(force); if (as[level].actions.at(a)->is_smeared) Smearer.smeared_force(force);
force = Ta(force); force = Ta(force);
std::cout<< GridLogIntegrator << "Force average: "<< norm2(force)/(U._grid->gSites()) <<std::endl; std::cout << GridLogIntegrator
Mom -= force*ep; << "Force average: " << norm2(force) / (U._grid->gSites())
<< std::endl;
Mom -= force * ep;
} }
} }
void update_U(GaugeField&U, double ep){ void update_U(GaugeField& U, double ep) {
update_U(P,U,ep); update_U(P, U, ep);
t_U+=ep;
int fl = levels-1;
std::cout<< GridLogIntegrator <<" "<<"["<<fl<<"] U " << " dt "<< ep <<" : t_U "<< t_U <<std::endl;
t_U += ep;
int fl = levels - 1;
std::cout << GridLogIntegrator << " "
<< "[" << fl << "] U "
<< " dt " << ep << " : t_U " << t_U << std::endl;
} }
void update_U(GaugeField &Mom, GaugeField&U, double ep){ void update_U(GaugeField& Mom, GaugeField& U, double ep) {
//rewrite exponential to deal automatically with the lorentz index? // rewrite exponential to deal automatically with the lorentz index?
// GaugeLinkField Umu(U._grid); // GaugeLinkField Umu(U._grid);
// GaugeLinkField Pmu(U._grid); // GaugeLinkField Pmu(U._grid);
for (int mu = 0; mu < Nd; mu++){ for (int mu = 0; mu < Nd; mu++) {
auto Umu=PeekIndex<LorentzIndex>(U, mu); auto Umu = PeekIndex<LorentzIndex>(U, mu);
auto Pmu=PeekIndex<LorentzIndex>(Mom, mu); auto Pmu = PeekIndex<LorentzIndex>(Mom, mu);
Umu = expMat(Pmu, ep, Params.Nexp)*Umu; Umu = expMat(Pmu, ep, Params.Nexp) * Umu;
ProjectOnGroup(Umu); ProjectOnGroup(Umu);
PokeIndex<LorentzIndex>(U, Umu, mu); PokeIndex<LorentzIndex>(U, Umu, mu);
} }
@ -150,64 +151,60 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
Smearer.set_GaugeField(U); Smearer.set_GaugeField(U);
} }
virtual void step (GaugeField& U,int level, int first,int last)=0; virtual void step(GaugeField& U, int level, int first, int last) = 0;
public: public:
Integrator(GridBase* grid, IntegratorParameters Par,
Integrator(GridBase* grid, ActionSet<GaugeField>& Aset, SmearingPolicy& Sm)
IntegratorParameters Par, : Params(Par), as(Aset), P(grid), levels(Aset.size()), Smearer(Sm) {
ActionSet<GaugeField> & Aset, t_P.resize(levels, 0.0);
SmearingPolicy &Sm): t_U = 0.0;
Params(Par),
as(Aset),
P(grid),
levels(Aset.size()),
Smearer(Sm)
{
t_P.resize(levels,0.0);
t_U=0.0;
// initialization of smearer delegated outside of Integrator // initialization of smearer delegated outside of Integrator
}; };
virtual ~Integrator(){} virtual ~Integrator() {}
//Initialization of momenta and actions // Initialization of momenta and actions
void refresh(GaugeField& U,GridParallelRNG &pRNG){ void refresh(GaugeField& U, GridParallelRNG& pRNG) {
std::cout<<GridLogIntegrator<< "Integrator refresh\n"; std::cout << GridLogIntegrator << "Integrator refresh\n";
generate_momenta(P,pRNG); generate_momenta(P, pRNG);
for(int level=0; level< as.size(); ++level){ for (int level = 0; level < as.size(); ++level) {
for(int actionID=0; actionID<as[level].actions.size(); ++actionID){ for (int actionID = 0; actionID < as[level].actions.size(); ++actionID) {
// get gauge field from the SmearingPolicy and // get gauge field from the SmearingPolicy and
// based on the boolean is_smeared in actionID // based on the boolean is_smeared in actionID
GaugeField& Us = Smearer.get_U(as[level].actions.at(actionID)->is_smeared); GaugeField& Us =
Smearer.get_U(as[level].actions.at(actionID)->is_smeared);
as[level].actions.at(actionID)->refresh(Us, pRNG); as[level].actions.at(actionID)->refresh(Us, pRNG);
} }
} }
} }
// Calculate action // Calculate action
RealD S(GaugeField& U){// here also U not used RealD S(GaugeField& U) { // here also U not used
LatticeComplex Hloc(U._grid); Hloc = zero; LatticeComplex Hloc(U._grid);
Hloc = zero;
// Momenta // Momenta
for (int mu=0; mu <Nd; mu++){ for (int mu = 0; mu < Nd; mu++) {
auto Pmu = PeekIndex<LorentzIndex>(P, mu); auto Pmu = PeekIndex<LorentzIndex>(P, mu);
Hloc -= trace(Pmu*Pmu); Hloc -= trace(Pmu * Pmu);
} }
Complex Hsum = sum(Hloc); Complex Hsum = sum(Hloc);
RealD H = Hsum.real(); RealD H = Hsum.real();
RealD Hterm; RealD Hterm;
std::cout<<GridLogMessage << "Momentum action H_p = "<< H << "\n"; std::cout << GridLogMessage << "Momentum action H_p = " << H << "\n";
// Actions // Actions
for(int level=0; level<as.size(); ++level){ for (int level = 0; level < as.size(); ++level) {
for(int actionID=0; actionID<as[level].actions.size(); ++actionID){ for (int actionID = 0; actionID < as[level].actions.size(); ++actionID) {
// get gauge field from the SmearingPolicy and // get gauge field from the SmearingPolicy and
// based on the boolean is_smeared in actionID // based on the boolean is_smeared in actionID
GaugeField& Us = Smearer.get_U(as[level].actions.at(actionID)->is_smeared); GaugeField& Us =
Smearer.get_U(as[level].actions.at(actionID)->is_smeared);
Hterm = as[level].actions.at(actionID)->S(Us); Hterm = as[level].actions.at(actionID)->S(Us);
std::cout<<GridLogMessage << "S Level "<<level<<" term "<<actionID<<" H = "<<Hterm<<std::endl; std::cout << GridLogMessage << "S Level " << level << " term "
<< actionID << " H = " << Hterm << std::endl;
H += Hterm; H += Hterm;
} }
} }
@ -215,33 +212,30 @@ public:
return H; return H;
} }
void integrate(GaugeField& U){ void integrate(GaugeField& U) {
// reset the clocks // reset the clocks
t_U=0; t_U = 0;
for(int level=0; level<as.size(); ++level){ for (int level = 0; level < as.size(); ++level) {
t_P[level]=0; t_P[level] = 0;
} }
for(int step=0; step< Params.MDsteps; ++step){ // MD step for (int step = 0; step < Params.MDsteps; ++step) { // MD step
int first_step = (step==0); int first_step = (step == 0);
int last_step = (step==Params.MDsteps-1); int last_step = (step == Params.MDsteps - 1);
this->step(U,0,first_step,last_step); this->step(U, 0, first_step, last_step);
} }
// Check the clocks all match on all levels // Check the clocks all match on all levels
for(int level=0; level<as.size(); ++level){ for (int level = 0; level < as.size(); ++level) {
assert(fabs(t_U - t_P[level])<1.0e-6); // must be the same assert(fabs(t_U - t_P[level]) < 1.0e-6); // must be the same
std::cout<<GridLogIntegrator<<" times["<<level<<"]= "<<t_P[level]<< " " << t_U <<std::endl; std::cout << GridLogIntegrator << " times[" << level
<< "]= " << t_P[level] << " " << t_U << std::endl;
} }
// and that we indeed got to the end of the trajectory // and that we indeed got to the end of the trajectory
assert(fabs(t_U-Params.trajL) < 1.0e-6); assert(fabs(t_U - Params.trajL) < 1.0e-6);
}
}
}; };
} }
} }
#endif//INTEGRATOR_INCLUDED #endif // INTEGRATOR_INCLUDED

758
lib/qcd/utils/SUn.h
View File

File diff suppressed because it is too large Load Diff

2
tests/Test_contfrac_force.cc
View File

@ -96,7 +96,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg
PokeIndex<LorentzIndex>(mom,mommu,mu); PokeIndex<LorentzIndex>(mom,mommu,mu);

2
tests/Test_dwf_force.cc
View File

@ -96,7 +96,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg
PokeIndex<LorentzIndex>(mom,mommu,mu); PokeIndex<LorentzIndex>(mom,mommu,mu);

2
tests/Test_dwf_gpforce.cc
View File

@ -113,7 +113,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg
Hmom -= real(sum(trace(mommu*mommu))); Hmom -= real(sum(trace(mommu*mommu)));

2
tests/Test_gp_rect_force.cc
View File

@ -82,7 +82,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg
PokeIndex<LorentzIndex>(mom,mommu,mu); PokeIndex<LorentzIndex>(mom,mommu,mu);

4
tests/Test_gpdwf_force.cc
View File

@ -100,7 +100,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg
PokeIndex<LorentzIndex>(mom,mommu,mu); PokeIndex<LorentzIndex>(mom,mommu,mu);
@ -169,7 +169,7 @@ int main (int argc, char ** argv)
// //
// Pmu = zero; // Pmu = zero;
// for(int mu=0;mu<Nd;mu++){ // for(int mu=0;mu<Nd;mu++){
// SU<Ncol>::GaussianLieAlgebraMatrix(pRNG, Pmu); // SU<Ncol>::GaussianFundamentalLieAlgebraMatrix(pRNG, Pmu);
// PokeIndex<LorentzIndex>(P, Pmu, mu); // PokeIndex<LorentzIndex>(P, Pmu, mu);
// } // }
// //

85
tests/Test_lie_generators.cc
View File

@ -1,70 +1,74 @@
/************************************************************************************* /*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid Grid physics library, www.github.com/paboyle/Grid
Source file: ./tests/Test_lie_generators.cc Source file: ./tests/Test_lie_generators.cc
Copyright (C) 2015 Copyright (C) 2015
Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk> Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
Author: Peter Boyle <paboyle@ph.ed.ac.uk> Author: Peter Boyle <paboyle@ph.ed.ac.uk>
This program is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License along 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., with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
See the full license in the file "LICENSE" in the top level distribution directory See the full license in the file "LICENSE" in the top level distribution
*************************************************************************************/ directory
/* END LEGAL */ *************************************************************************************/
/* END LEGAL */
#include <Grid.h> #include <Grid.h>
#include <qcd/utils/CovariantCshift.h> #include <qcd/utils/CovariantCshift.h>
#include <qcd/utils/WilsonLoops.h>
#include <qcd/utils/SUn.h> #include <qcd/utils/SUn.h>
#include <qcd/utils/WilsonLoops.h>
using namespace std; using namespace std;
using namespace Grid; using namespace Grid;
using namespace Grid::QCD; using namespace Grid::QCD;
int main(int argc, char** argv) {
Grid_init(&argc, &argv);
int main (int argc, char ** argv) std::vector<int> latt({4, 4, 4, 8});
{ GridCartesian* grid = SpaceTimeGrid::makeFourDimGrid(
Grid_init(&argc,&argv); latt, GridDefaultSimd(Nd, vComplex::Nsimd()), GridDefaultMpi());
std::vector<int> latt({4,4,4,8}); GridRedBlackCartesian* rbGrid = SpaceTimeGrid::makeFourDimRedBlackGrid(grid);
GridCartesian * grid = SpaceTimeGrid::makeFourDimGrid(latt,
GridDefaultSimd(Nd,vComplex::Nsimd()),
GridDefaultMpi());
GridRedBlackCartesian * rbGrid = SpaceTimeGrid::makeFourDimRedBlackGrid(grid); std::cout << GridLogMessage << "*********************************************"
<< std::endl;
std::cout<<GridLogMessage<<"*********************************************"<<std::endl; std::cout << GridLogMessage << "* Generators for SU(2)" << std::endl;
std::cout<<GridLogMessage<<"* Generators for SU(2)"<<std::endl; std::cout << GridLogMessage << "*********************************************"
std::cout<<GridLogMessage<<"*********************************************"<<std::endl; << std::endl;
SU2::printGenerators(); SU2::printGenerators();
SU2::printAdjointGenerators();
SU2::testGenerators(); SU2::testGenerators();
std::cout<<GridLogMessage<<"*********************************************"<<std::endl; std::cout << GridLogMessage << "*********************************************"
std::cout<<GridLogMessage<<"* Generators for SU(3)"<<std::endl; << std::endl;
std::cout<<GridLogMessage<<"*********************************************"<<std::endl; std::cout << GridLogMessage << "* Generators for SU(3)" << std::endl;
std::cout << GridLogMessage << "*********************************************"
<< std::endl;
SU3::printGenerators(); SU3::printGenerators();
SU3::printAdjointGenerators();
SU3::testGenerators(); SU3::testGenerators();
// std::cout<<GridLogMessage<<"*********************************************"<<std::endl; std::cout<<GridLogMessage<<"*********************************************"<<std::endl;
// std::cout<<GridLogMessage<<"* Generators for SU(4)"<<std::endl; std::cout<<GridLogMessage<<"* Generators for SU(4)"<<std::endl;
// std::cout<<GridLogMessage<<"*********************************************"<<std::endl; std::cout<<GridLogMessage<<"*********************************************"<<std::endl;
// SU4::printGenerators(); SU4::printGenerators();
// SU4::testGenerators(); SU4::testGenerators();
// std::cout<<GridLogMessage<<"*********************************************"<<std::endl; // std::cout<<GridLogMessage<<"*********************************************"<<std::endl;
// std::cout<<GridLogMessage<<"* Generators for SU(5)"<<std::endl; // std::cout<<GridLogMessage<<"* Generators for SU(5)"<<std::endl;
@ -72,8 +76,5 @@ int main (int argc, char ** argv)
// SU5::printGenerators(); // SU5::printGenerators();
// SU5::testGenerators(); // SU5::testGenerators();
Grid_finalize(); Grid_finalize();
} }

2
tests/Test_partfrac_force.cc
View File

@ -96,7 +96,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(RNG4, mommu); // Traceless antihermitian momentum; gaussian in lie alg
PokeIndex<LorentzIndex>(mom,mommu,mu); PokeIndex<LorentzIndex>(mom,mommu,mu);

2
tests/Test_rect_force.cc
View File

@ -81,7 +81,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg
PokeIndex<LorentzIndex>(mom,mommu,mu); PokeIndex<LorentzIndex>(mom,mommu,mu);

2
tests/Test_wilson_force.cc
View File

@ -93,7 +93,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg
Hmom -= real(sum(trace(mommu*mommu))); Hmom -= real(sum(trace(mommu*mommu)));

2
tests/Test_wilson_force_phiMdagMphi.cc
View File

@ -103,7 +103,7 @@ int main (int argc, char ** argv)
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
SU3::GaussianLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(pRNG, mommu); // Traceless antihermitian momentum; gaussian in lie alg
// Dw.DoubleStore(Dw.Umu,Uprime); // update U _and_ Udag // Dw.DoubleStore(Dw.Umu,Uprime); // update U _and_ Udag
Dw.DhopDirDisp(phi,Ftmp,mu,mu+4,DaggerYes); Dw.DhopDirDisp(phi,Ftmp,mu,mu+4,DaggerYes);

2
tests/Test_wilson_force_phiMphi.cc
View File

@ -86,7 +86,7 @@ int main (int argc, char ** argv)
LatticeColourMatrix Umu_save(&Grid); LatticeColourMatrix Umu_save(&Grid);
LatticeColourMatrix dU (&Grid); LatticeColourMatrix dU (&Grid);
LatticeColourMatrix mom(&Grid); LatticeColourMatrix mom(&Grid);
SU3::GaussianLieAlgebraMatrix(pRNG, mom); // Traceless antihermitian momentum; gaussian in lie alg SU3::GaussianFundamentalLieAlgebraMatrix(pRNG, mom); // Traceless antihermitian momentum; gaussian in lie alg
// check mom is as i expect // check mom is as i expect