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

Debugged set_fj,

Browse Source 
to be fixed: BUG in imag()
This commit is contained in:
Guido Cossu 2016-07-01 16:06:20 +01:00
parent 565e9329ba
commit 092fa0d8da
5 changed files with 233 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/Log.h
View File

@ -63,7 +63,6 @@ namespace Grid {
colour["WHITE"] ="\033[37m";
colour["NORMAL"] ="\033[0;39m";
} else {
std::cout << "Switching off colours\n";
colour["BLACK"] ="";
colour["RED"] ="";
colour["GREEN"] ="";

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

@ -117,10 +117,10 @@ namespace Grid{
GaugeField force(U._grid);
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
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);
force = Ta(force);
std::cout<<GridLogIntegrator<< "Force average: "<< norm2(force)/(U._grid->gSites()) <<std::endl;
std::cout<< GridLogIntegrator << "Force average: "<< norm2(force)/(U._grid->gSites()) <<std::endl;
Mom = Mom - force*ep;
}
}
@ -130,7 +130,7 @@ namespace Grid{
t_U+=ep;
int fl = levels-1;
std::cout<<GridLogIntegrator<<" "<<"["<<fl<<"] U " << " dt "<< ep <<" : t_U "<< t_U <<std::endl;
std::cout<< GridLogIntegrator <<" "<<"["<<fl<<"] U " << " dt "<< ep <<" : t_U "<< t_U <<std::endl;
}
void update_U(GaugeField &Mom, GaugeField&U, double ep){

16
lib/qcd/smearing/APEsmearing.h
View File

@ -5,7 +5,7 @@
#ifndef APE_SMEAR_
#define APE_SMEAR_
namespace Grid {
namespace Grid {
namespace QCD {
@ -56,16 +56,18 @@ namespace Grid {
// save the Cup link-field on the u_smr gauge-field
pokeLorentz(u_smr, adj(Cup), mu); // u_smr[mu] = Cup^dag
}
}
}
////////////////////////////////////////////////////////////////////////////////
void derivative(GaugeField& SigmaTerm,
////////////////////////////////////////////////////////////////////////////////
void derivative(GaugeField& SigmaTerm,
const GaugeField& iLambda,
const GaugeField& U)const{
// Reference
// Morningstar, Peardon, Phys.Rev.D69,054501(2004)
// Equation 75
// Computing Sigma_mu, derivative of S[fat links] with respect to the thin links
// Output SigmaTerm
GridBase *grid = U._grid;
int vol = U._grid->gSites();
@ -120,9 +122,9 @@ namespace Grid {
Gimpl::AddGaugeLink(SigmaTerm, sh_field, mu);
}
}
}
};
}
}
};

39
lib/qcd/smearing/GaugeConfiguration.h
View File

@ -6,7 +6,7 @@
#ifndef GAUGE_CONFIG_
#define GAUGE_CONFIG_
namespace Grid {
namespace Grid {
namespace QCD {
@ -49,15 +49,16 @@ namespace Grid {
StoutSmearing.smear(SmearedSet[smearLvl],previous_u);
previous_u = SmearedSet[smearLvl];
// For debug purposes
RealD impl_plaq = WilsonLoops<Gimpl>::avgPlaquette(previous_u);
std::cout<< GridLogDebug << "[SmearedConfiguration] Plaq: " << impl_plaq<< std::endl;
}
}
}
}
//====================================================================
GaugeField AnalyticSmearedForce(const GaugeField& SigmaKPrime,
GaugeField AnalyticSmearedForce(const GaugeField& SigmaKPrime,
const GaugeField& GaugeK) const{
GridBase *grid = GaugeK._grid;
GaugeField C(grid), SigmaK(grid), iLambda(grid);
@ -79,13 +80,13 @@ namespace Grid {
}
StoutSmearing.derivative(SigmaK, iLambda, GaugeK);// derivative of SmearBase
return SigmaK;
}
}
/*! @brief Returns smeared configuration at level 'Level' */
const GaugeField& get_smeared_conf(int Level) const{
const GaugeField& get_smeared_conf(int Level) const{
return SmearedSet[Level];
}
}
//====================================================================
void set_iLambda(GaugeLinkField& iLambda,
void set_iLambda(GaugeLinkField& iLambda,
GaugeLinkField& e_iQ,
const GaugeLinkField& iQ,
const GaugeLinkField& Sigmap,
@ -103,9 +104,9 @@ namespace Grid {
LatticeComplex r01(grid), r11(grid), r21(grid), r02(grid), r12(grid);
LatticeComplex r22(grid), tr1(grid), tr2(grid);
LatticeComplex b10(grid), b11(grid), b12(grid), b20(grid), b21(grid), b22(grid);
LatticeReal unitReal(grid);
LatticeReal LatticeUnitReal(grid);
unitReal = 1.0;
LatticeUnitReal = 1.0;
// Exponential
iQ2 = iQ * iQ;
@ -128,11 +129,11 @@ namespace Grid {
+ emiu * (toComplex(16.0*u*cosw + 2.0*u*(3.0*u2+w2)*xi0) +
timesI(toComplex(-8.0*u2*cosw + 2.0*(9.0*u2+w2)*xi0)));
r11 = (toComplex(2.0*unitReal) + timesI(toComplex(4.0*u)))* e2iu
r11 = (toComplex(2.0*LatticeUnitReal) + timesI(toComplex(4.0*u)))* e2iu
+ emiu * (toComplex(-2.0*cosw + (3.0*u2-w2)*xi0) +
timesI(toComplex(2.0*u*cosw + 6.0*u*xi0)));
r21 = timesI(toComplex(2.0*unitReal)) * e2iu
r21 = 2.0*timesI(e2iu)
+ emiu * (toComplex(-3.0*u*xi0) + timesI(toComplex(cosw - 3.0*xi0)));
@ -177,9 +178,9 @@ namespace Grid {
iLambda = Ta(iGamma);
}
}
//====================================================================
public:
public:
GaugeField* ThinLinks; /*!< @brief Pointer to the thin
links configuration */
@ -226,15 +227,15 @@ namespace Grid {
pokeLorentz(SigmaTilde, tmp_mu, mu);
}
}// if smearingLevels = 0 do nothing
}
}
//====================================================================
GaugeField& get_SmearedU(){
GaugeField& get_SmearedU(){
return SmearedSet[smearingLevels-1];
}
}
GaugeField& get_U(bool smeared=false) {
GaugeField& get_U(bool smeared=false) {
// get the config, thin links by default
if (smeared){
if (smearingLevels){
@ -255,10 +256,10 @@ namespace Grid {
return *ThinLinks;}
}
};
};
}
}
}

47
lib/qcd/smearing/StoutSmearing.h
View File

@ -5,7 +5,7 @@
#ifndef STOUT_SMEAR_
#define STOUT_SMEAR_
namespace Grid {
namespace Grid {
namespace QCD {
/*! @brief Stout smearing of link variable. */
@ -48,20 +48,20 @@ namespace Grid {
}
std::cout<< GridLogDebug << "Stout smearing completed\n";
}
void derivative(GaugeField& SigmaTerm,
}
void derivative(GaugeField& SigmaTerm,
const GaugeField& iLambda,
const GaugeField& Gauge) const{
SmearBase->derivative(SigmaTerm, iLambda, Gauge);
}
}
void BaseSmear(GaugeField& C,
void BaseSmear(GaugeField& C,
const GaugeField& U) const{
SmearBase->smear(C, U);
}
}
void exponentiate_iQ(GaugeLinkField& e_iQ,
void exponentiate_iQ(GaugeLinkField& e_iQ,
const GaugeLinkField& iQ) const{
// Put this outside
// only valid for SU(3) matrices
@ -87,10 +87,10 @@ namespace Grid {
set_uw(u, w, iQ2, iQ3);
set_fj(f0, f1, f2, u, w);
e_iQ = f0*unity + timesMinusI(f1) * iQ - f2 * iQ2;
};
};
void set_uw(LatticeReal& u, LatticeReal& w,
void set_uw(LatticeReal& u, LatticeReal& w,
GaugeLinkField& iQ2, GaugeLinkField& iQ3) const{
Real one_over_three = 1.0/3.0;
Real one_over_two = 1.0/2.0;
@ -99,7 +99,8 @@ namespace Grid {
LatticeReal c0(grid), c1(grid), tmp(grid), c0max(grid), theta(grid);
// sign in c0 from the conventions on the Ta
c0 = - toReal(imag(trace(iQ3))) * one_over_three;
// c0 = - toReal(imag(trace(iQ3))) * one_over_three;
c0 = - toReal(real(timesMinusI(trace(iQ3)))) * one_over_three; //temporary, FIX the bug in imag
c1 = - toReal(real(trace(iQ2))) * one_over_two;
tmp = c1 * one_over_three;
c0max = 2.0 * pow(tmp, 1.5);
@ -107,9 +108,10 @@ namespace Grid {
theta = acos(c0/c0max);
u = sqrt(tmp) * cos( theta * one_over_three);
w = sqrt(c1) * sin( theta * one_over_three);
}
void set_fj(LatticeComplex& f0, LatticeComplex& f1, LatticeComplex& f2,
}
void set_fj(LatticeComplex& f0, LatticeComplex& f1, LatticeComplex& f2,
const LatticeReal& u, const LatticeReal& w) const{
GridBase *grid = u._grid;
@ -124,8 +126,8 @@ namespace Grid {
cosw = cos(w);
ixi0 = timesI(toComplex(xi0));
emiu = toComplex(cos(u)) - timesI(toComplex(u));
e2iu = toComplex(cos(2.0*u)) + timesI(toComplex(2.0*u));
emiu = toComplex(cos(u)) - timesI(toComplex(sin(u)));
e2iu = toComplex(cos(2.0*u)) + timesI(toComplex(sin(2.0*u)));
h0 = e2iu * toComplex(u2 - w2) + emiu *( toComplex(8.0*u2*cosw) +
toComplex(2.0*u*(3.0*u2 + w2))*ixi0);
@ -135,30 +137,31 @@ namespace Grid {
h2 = e2iu - emiu * (toComplex(cosw) + toComplex(3.0*u)*ixi0);
tmp = 9.0*u2 - w2;
fden = toComplex(pow(tmp, -1.0));
f0 = h0 * fden;
f1 = h1 * fden;
f2 = h2 * fden;
}
LatticeReal func_xi0(const LatticeReal& w) const{
}
LatticeReal func_xi0(const LatticeReal& w) const{
// Define a function to do the check
//if( w < 1e-4 ) std::cout << GridLogWarning<< "[Smear_stout] w too small: "<< w <<"\n";
return sin(w)/w;
}
}
LatticeReal func_xi1(const LatticeReal& w) const{
LatticeReal func_xi1(const LatticeReal& w) const{
// Define a function to do the check
//if( w < 1e-4 ) std::cout << GridLogWarning << "[Smear_stout] w too small: "<< w <<"\n";
return cos(w)/(w*w) - sin(w)/(w*w*w);
}
}
};
};
}
}
}
#endif