Debugged set_fj,

to be fixed: BUG in imag()

lib/Log.h

@@ -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"] ="";

lib/qcd/hmc/integrators/Integrator.h

@@ -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){

lib/qcd/smearing/APEsmearing.h

@@ -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);
 	    
 	}
-	}
+}
-      }
+}
-    };
+};
 
 
 

lib/qcd/smearing/GaugeConfiguration.h

@@ -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;}
 	}
 
-    };
+};
 
 
-  }
+}
 
 }
 

lib/qcd/smearing/StoutSmearing.h

@@ -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));
+	emiu  = toComplex(cos(u)) - timesI(toComplex(sin(u)));
-	e2iu  = toComplex(cos(2.0*u)) + timesI(toComplex(2.0*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