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

First cut on generalised HMC

Browse Source 
Backward compatibility OK
This commit is contained in:
Guido Cossu 2016-10-03 15:28:00 +01:00
parent 7ea4b959a4
commit e415260961
7 changed files with 376 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
lib/qcd/action/gauge/GaugeImpl.h
View File

@ -38,14 +38,18 @@ namespace QCD {
template <class Gimpl> class WilsonLoops; template <class Gimpl> class WilsonLoops;
//
#define INHERIT_GIMPL_TYPES(GImpl) \ #define INHERIT_GIMPL_TYPES(GImpl) \
typedef typename GImpl::Simd Simd; \ typedef typename GImpl::Simd Simd; \
typedef typename GImpl::GaugeLinkField GaugeLinkField; \ typedef typename GImpl::LinkField GaugeLinkField; \
typedef typename GImpl::GaugeField GaugeField; \ typedef typename GImpl::Field GaugeField; \
typedef typename GImpl::SiteGaugeField SiteGaugeField; \ typedef typename GImpl::SiteField SiteGaugeField; \
typedef typename GImpl::SiteGaugeLink SiteGaugeLink; typedef typename GImpl::SiteLink SiteGaugeLink;
#define INHERIT_FIELD_TYPES(Impl) \
typedef typename Impl::Field Field;
//
template <class S, int Nrepresentation = Nc > class GaugeImplTypes { template <class S, int Nrepresentation = Nc > class GaugeImplTypes {
public: public:
typedef S Simd; typedef S Simd;
@ -55,16 +59,14 @@ public:
template <typename vtype> template <typename vtype>
using iImplGaugeField = iVector<iScalar<iMatrix<vtype, Nrepresentation>>, Nd>; using iImplGaugeField = iVector<iScalar<iMatrix<vtype, Nrepresentation>>, Nd>;
typedef iImplGaugeLink<Simd> SiteGaugeLink; typedef iImplGaugeLink<Simd> SiteLink;
typedef iImplGaugeField<Simd> SiteGaugeField; typedef iImplGaugeField<Simd> SiteField;
typedef Lattice<SiteGaugeLink> GaugeLinkField; // bit ugly naming; polarised typedef Lattice<SiteLink> LinkField;
// gauge field, lorentz... all typedef Lattice<SiteField> Field;
// ugly
typedef Lattice<SiteGaugeField> GaugeField;
// Move this elsewhere? FIXME // Move this elsewhere? FIXME
static inline void AddGaugeLink(GaugeField &U, GaugeLinkField &W, static inline void AddLink(Field &U, LinkField &W,
int mu) { // U[mu] += W int mu) { // U[mu] += W
PARALLEL_FOR_LOOP PARALLEL_FOR_LOOP
for (auto ss = 0; ss < U._grid->oSites(); ss++) { for (auto ss = 0; ss < U._grid->oSites(); ss++) {
@ -72,6 +74,28 @@ public:
U._odata[ss]._internal[mu] + W._odata[ss]._internal; U._odata[ss]._internal[mu] + W._odata[ss]._internal;
} }
} }
static inline void generate_momenta(Field& P, GridParallelRNG& pRNG){
// specific for SU gauge fields
LinkField Pmu(P._grid);
Pmu = zero;
for (int mu = 0; mu < Nd; mu++) {
SU<Nrepresentation>::GaussianFundamentalLieAlgebraMatrix(pRNG, Pmu);
PokeIndex<LorentzIndex>(P, Pmu, mu);
}
}
static inline void update_field(Field& P, Field& U, double ep, unsigned int Nexp){
for (int mu = 0; mu < Nd; mu++) {
auto Umu = PeekIndex<LorentzIndex>(U, mu);
auto Pmu = PeekIndex<LorentzIndex>(P, mu);
Umu = expMat(Pmu, ep, Nexp) * Umu;
PokeIndex<LorentzIndex>(U, ProjectOnGroup(Umu), mu);
}
}
}; };
// Composition with smeared link, bc's etc.. probably need multiple inheritance // Composition with smeared link, bc's etc.. probably need multiple inheritance

38
lib/qcd/hmc/HMC.h
View File

@ -60,24 +60,25 @@ struct HMCparameters {
///////////////////////////////// /////////////////////////////////
} }
void print() const { void print_parameters() const {
std::cout << GridLogMessage << "[HMC parameter] Trajectories : " << Trajectories << "\n"; std::cout << GridLogMessage << "[HMC parameters] Trajectories : " << Trajectories << "\n";
std::cout << GridLogMessage << "[HMC parameter] Start trajectory : " << StartTrajectory << "\n"; std::cout << GridLogMessage << "[HMC parameters] Start trajectory : " << StartTrajectory << "\n";
std::cout << GridLogMessage << "[HMC parameter] Metropolis test (on/off): " << MetropolisTest << "\n"; std::cout << GridLogMessage << "[HMC parameters] Metropolis test (on/off): " << MetropolisTest << "\n";
std::cout << GridLogMessage << "[HMC parameter] Thermalization trajs : " << NoMetropolisUntil << "\n"; std::cout << GridLogMessage << "[HMC parameters] Thermalization trajs : " << NoMetropolisUntil << "\n";
} }
}; };
template <class GaugeField> template <class Field>
class HmcObservable { class HmcObservable {
public: public:
virtual void TrajectoryComplete(int traj, GaugeField &U, GridSerialRNG &sRNG, virtual void TrajectoryComplete(int traj, Field &U, GridSerialRNG &sRNG,
GridParallelRNG &pRNG) = 0; GridParallelRNG &pRNG) = 0;
}; };
// this is only defined for a gauge theory
template <class Gimpl> template <class Gimpl>
class PlaquetteLogger : public HmcObservable<typename Gimpl::GaugeField> { class PlaquetteLogger : public HmcObservable<typename Gimpl::Field> {
private: private:
std::string Stem; std::string Stem;
@ -117,19 +118,19 @@ class PlaquetteLogger : public HmcObservable<typename Gimpl::GaugeField> {
} }
}; };
// template <class GaugeField, class Integrator, class Smearer, class template <class IntegratorType>
// Boundary>
template <class GaugeField, class IntegratorType>
class HybridMonteCarlo { class HybridMonteCarlo {
private: private:
const HMCparameters Params; const HMCparameters Params;
typedef typename IntegratorType::Field Field;
GridSerialRNG &sRNG; // Fixme: need a RNG management strategy. GridSerialRNG &sRNG; // Fixme: need a RNG management strategy.
GridParallelRNG &pRNG; // Fixme: need a RNG management strategy. GridParallelRNG &pRNG; // Fixme: need a RNG management strategy.
GaugeField &Ucur; Field &Ucur;
IntegratorType &TheIntegrator; IntegratorType &TheIntegrator;
std::vector<HmcObservable<GaugeField> *> Observables; std::vector<HmcObservable<Field> *> Observables;
///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////
// Metropolis step // Metropolis step
@ -164,7 +165,7 @@ class HybridMonteCarlo {
///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////
// Evolution // Evolution
///////////////////////////////////////////////////////// /////////////////////////////////////////////////////////
RealD evolve_step(GaugeField &U) { RealD evolve_step(Field &U) {
TheIntegrator.refresh(U, pRNG); // set U and initialize P and phi's TheIntegrator.refresh(U, pRNG); // set U and initialize P and phi's
RealD H0 = TheIntegrator.S(U); // initial state action RealD H0 = TheIntegrator.S(U); // initial state action
@ -191,20 +192,21 @@ class HybridMonteCarlo {
// Constructor // Constructor
///////////////////////////////////////// /////////////////////////////////////////
HybridMonteCarlo(HMCparameters Pams, IntegratorType &_Int, HybridMonteCarlo(HMCparameters Pams, IntegratorType &_Int,
GridSerialRNG &_sRNG, GridParallelRNG &_pRNG, GaugeField &_U) GridSerialRNG &_sRNG, GridParallelRNG &_pRNG, Field &_U)
: Params(Pams), TheIntegrator(_Int), sRNG(_sRNG), pRNG(_pRNG), Ucur(_U) {} : Params(Pams), TheIntegrator(_Int), sRNG(_sRNG), pRNG(_pRNG), Ucur(_U) {}
~HybridMonteCarlo(){}; ~HybridMonteCarlo(){};
void AddObservable(HmcObservable<GaugeField> *obs) { void AddObservable(HmcObservable<Field> *obs) {
Observables.push_back(obs); Observables.push_back(obs);
} }
void evolve(void) { void evolve(void) {
Real DeltaH; Real DeltaH;
GaugeField Ucopy(Ucur._grid); Field Ucopy(Ucur._grid);
Params.print(); Params.print_parameters();
TheIntegrator.print_parameters();
// Actual updates (evolve a copy Ucopy then copy back eventually) // Actual updates (evolve a copy Ucopy then copy back eventually)
for (int traj = Params.StartTrajectory; for (int traj = Params.StartTrajectory;

8
lib/qcd/hmc/HmcRunner.h
View File

@ -32,6 +32,7 @@ directory
namespace Grid { namespace Grid {
namespace QCD { namespace QCD {
// Class for HMC specific for gauge theories
template <class Gimpl, class RepresentationsPolicy = NoHirep > template <class Gimpl, class RepresentationsPolicy = NoHirep >
class NerscHmcRunnerTemplate { class NerscHmcRunnerTemplate {
public: public:
@ -114,7 +115,7 @@ class NerscHmcRunnerTemplate {
*/ */
////////////// //////////////
NoSmearing<Gimpl> SmearingPolicy; NoSmearing<Gimpl> SmearingPolicy;
typedef MinimumNorm2<GaugeField, NoSmearing<Gimpl>, RepresentationsPolicy > typedef MinimumNorm2<Gimpl, NoSmearing<Gimpl>, RepresentationsPolicy >
IntegratorType; // change here to change the algorithm IntegratorType; // change here to change the algorithm
IntegratorParameters MDpar(20, 1.0); IntegratorParameters MDpar(20, 1.0);
IntegratorType MDynamics(UGrid, MDpar, TheAction, SmearingPolicy); IntegratorType MDynamics(UGrid, MDpar, TheAction, SmearingPolicy);
@ -157,10 +158,9 @@ class NerscHmcRunnerTemplate {
// smeared set // smeared set
// notice that the unit configuration is singular in this procedure // notice that the unit configuration is singular in this procedure
std::cout << GridLogMessage << "Filling the smeared set\n"; std::cout << GridLogMessage << "Filling the smeared set\n";
SmearingPolicy.set_GaugeField(U); SmearingPolicy.set_Field(U);
HybridMonteCarlo<GaugeField, IntegratorType> HMC(HMCpar, MDynamics, sRNG, HybridMonteCarlo<IntegratorType> HMC(HMCpar, MDynamics, sRNG, pRNG, U);
pRNG, U);
HMC.AddObservable(&Checkpoint); HMC.AddObservable(&Checkpoint);
HMC.AddObservable(&PlaqLog); HMC.AddObservable(&PlaqLog);

2
lib/qcd/hmc/NerscCheckpointer.h
View File

@ -36,7 +36,7 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
namespace Grid{ namespace Grid{
namespace QCD{ namespace QCD{
// Only for gauge fields
template<class Gimpl> template<class Gimpl>
class NerscHmcCheckpointer : public HmcObservable<typename Gimpl::GaugeField> { class NerscHmcCheckpointer : public HmcObservable<typename Gimpl::GaugeField> {
private: private:

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

@ -49,60 +49,53 @@ namespace Grid {
namespace QCD { namespace QCD {
struct IntegratorParameters { struct IntegratorParameters {
int Nexp; unsigned int
int MDsteps; // number of outer steps Nexp; // number of terms in the Taylor expansion of the exponential
unsigned int MDsteps; // number of outer steps
RealD trajL; // trajectory length RealD trajL; // trajectory length
RealD stepsize; RealD stepsize; // trajectory stepsize
IntegratorParameters(int MDsteps_, RealD trajL_ = 1.0, int Nexp_ = 12) IntegratorParameters(int MDsteps_, RealD trajL_ = 1.0,
unsigned int Nexp_ = 12)
: Nexp(Nexp_), : Nexp(Nexp_),
MDsteps(MDsteps_), MDsteps(MDsteps_),
trajL(trajL_), trajL(trajL_),
stepsize(trajL / MDsteps){ stepsize(trajL / MDsteps){
// empty body constructor // empty body constructor
}; };
void print_parameters() {
std::cout << GridLogMessage << "[Integrator] Trajectory length : " << trajL << std::endl;
std::cout << GridLogMessage << "[Integrator] Number of MD steps : " << MDsteps << std::endl;
std::cout << GridLogMessage << "[Integrator] Step size : " << stepsize << std::endl;
std::cout << GridLogMessage << "[Integrator] Exponential approx.: " << Nexp << std::endl;
}
}; };
/*! @brief Class for Molecular Dynamics management */ /*! @brief Class for Molecular Dynamics management */
template <class GaugeField, class SmearingPolicy, class RepresentationPolicy> template <class FieldImplementation, class SmearingPolicy, class RepresentationPolicy>
class Integrator { class Integrator {
protected: protected:
typedef IntegratorParameters ParameterType; typedef IntegratorParameters ParameterType;
typedef typename FieldImplementation::Field MomentaField; //for readability
typedef typename FieldImplementation::Field Field;
IntegratorParameters Params; IntegratorParameters Params;
const ActionSet<GaugeField, RepresentationPolicy> as; const ActionSet<Field, RepresentationPolicy> as;
int levels; // int levels; //
double t_U; // Track time passing on each level and for U and for P double t_U; // Track time passing on each level and for U and for P
std::vector<double> t_P; // std::vector<double> t_P; //
GaugeField P; MomentaField P;
SmearingPolicy& Smearer; SmearingPolicy& Smearer;
RepresentationPolicy Representations; RepresentationPolicy Representations;
// Should match any legal (SU(n)) gauge field void update_P(Field& U, int level, double ep) {
// 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) {
typedef Lattice<iScalar<iScalar<iMatrix<vec, Ncol> > > > GaugeLinkField;
GaugeLinkField Pmu(P._grid);
Pmu = zero;
for (int mu = 0; mu < Nd; mu++) {
SU<Ncol>::GaussianFundamentalLieAlgebraMatrix(pRNG, Pmu);
PokeIndex<LorentzIndex>(P, Pmu, mu);
}
}
// ObserverList observers; // not yet
// typedef std::vector<Observer*> ObserverList;
// void register_observers();
// void notify_observers();
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);
@ -129,12 +122,12 @@ class Integrator {
} }
} update_P_hireps{}; } update_P_hireps{};
void update_P(GaugeField& Mom, GaugeField& U, int level, double ep) { void update_P(MomentaField& Mom, Field& U, int level, double ep) {
// input U actually not used in the fundamental case // input U actually not used in the fundamental case
// Fundamental updates, include smearing // Fundamental updates, include smearing
for (int a = 0; a < as[level].actions.size(); ++a) { for (int a = 0; a < as[level].actions.size(); ++a) {
GaugeField force(U._grid); Field force(U._grid);
GaugeField& Us = Smearer.get_U(as[level].actions.at(a)->is_smeared); Field& 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 std::cout << GridLogIntegrator
@ -152,7 +145,7 @@ class Integrator {
as[level].apply(update_P_hireps, Representations, Mom, U, ep); as[level].apply(update_P_hireps, Representations, Mom, U, ep);
} }
void update_U(GaugeField& U, double ep) { void update_U(Field& U, double ep) {
update_U(P, U, ep); update_U(P, U, ep);
t_U += ep; t_U += ep;
@ -161,26 +154,21 @@ class Integrator {
<< "[" << fl << "] U " << "[" << fl << "] U "
<< " dt " << ep << " : t_U " << t_U << std::endl; << " dt " << ep << " : t_U " << t_U << std::endl;
} }
void update_U(GaugeField& Mom, GaugeField& U, double ep) { void update_U(MomentaField& Mom, Field& U, double ep) {
// rewrite exponential to deal internally with the lorentz index? FieldImplementation::update_field(Mom, U, ep, Params.Nexp);
for (int mu = 0; mu < Nd; mu++) {
auto Umu = PeekIndex<LorentzIndex>(U, mu);
auto Pmu = PeekIndex<LorentzIndex>(Mom, mu);
Umu = expMat(Pmu, ep, Params.Nexp) * Umu;
PokeIndex<LorentzIndex>(U, ProjectOnGroup(Umu), mu);
}
// Update the smeared fields, can be implemented as observer // Update the smeared fields, can be implemented as observer
Smearer.set_GaugeField(U); Smearer.set_Field(U);
// Update the higher representations fields // Update the higher representations fields
Representations.update(U); // void functions if fundamental representation Representations.update(U); // void functions if fundamental representation
} }
virtual void step(GaugeField& U, int level, int first, int last) = 0; virtual void step(Field& U, int level, int first, int last) = 0;
public: public:
Integrator(GridBase* grid, IntegratorParameters Par, Integrator(GridBase* grid, IntegratorParameters Par,
ActionSet<GaugeField, RepresentationPolicy>& Aset, ActionSet<Field, RepresentationPolicy>& Aset,
SmearingPolicy& Sm) SmearingPolicy& Sm)
: Params(Par), : Params(Par),
as(Aset), as(Aset),
@ -195,6 +183,13 @@ class Integrator {
virtual ~Integrator() {} virtual ~Integrator() {}
virtual std::string integrator_name() = 0;
void print_parameters(){
std::cout << GridLogMessage << "[Integrator] Name : "<< integrator_name() << std::endl;
Params.print_parameters();
}
// to be used by the actionlevel class to iterate // to be used by the actionlevel class to iterate
// over the representations // over the representations
struct _refresh { struct _refresh {
@ -210,14 +205,14 @@ class Integrator {
} refresh_hireps{}; } refresh_hireps{};
// Initialization of momenta and actions // Initialization of momenta and actions
void refresh(GaugeField& U, GridParallelRNG& pRNG) { void refresh(Field& U, GridParallelRNG& pRNG) {
std::cout << GridLogIntegrator << "Integrator refresh\n"; std::cout << GridLogIntegrator << "Integrator refresh\n";
generate_momenta(P, pRNG); FieldImplementation::generate_momenta(P, pRNG);
// Update the smeared fields, can be implemented as observer // Update the smeared fields, can be implemented as observer
// necessary to keep the fields updated even after a reject // necessary to keep the fields updated even after a reject
// of the Metropolis // of the Metropolis
Smearer.set_GaugeField(U); Smearer.set_Field(U);
// Set the (eventual) representations gauge fields // Set the (eventual) representations gauge fields
Representations.update(U); Representations.update(U);
@ -228,7 +223,7 @@ class Integrator {
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 = Field& Us =
Smearer.get_U(as[level].actions.at(actionID)->is_smeared); 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);
} }
@ -256,11 +251,12 @@ class Integrator {
} S_hireps{}; } S_hireps{};
// Calculate action // Calculate action
RealD S(GaugeField& U) { // here also U not used RealD S(Field& U) { // here also U not used
LatticeComplex Hloc(U._grid); LatticeComplex Hloc(U._grid);
Hloc = zero; Hloc = zero;
// Momenta // Momenta --- modify this (take the trace of field)
// momenta_action()
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);
@ -276,7 +272,7 @@ class Integrator {
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 = Field& Us =
Smearer.get_U(as[level].actions.at(actionID)->is_smeared); 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 " std::cout << GridLogMessage << "S Level " << level << " term "
@ -289,7 +285,7 @@ class Integrator {
return H; return H;
} }
void integrate(GaugeField& U) { void integrate(Field& 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) {
@ -312,7 +308,12 @@ class Integrator {
// 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

102
lib/qcd/hmc/integrators/Integrator_algorithm.h
View File

@ -23,14 +23,16 @@ Author: neo <cossu@post.kek.jp>
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_algorithm.h /*! @file Integrator_algorithm.h
* @brief Declaration of classes for the Molecular Dynamics algorithms * @brief Declaration of classes for the Molecular Dynamics algorithms
* *
* @author Guido Cossu
*/ */
//-------------------------------------------------------------------- //--------------------------------------------------------------------
@ -91,23 +93,24 @@ namespace Grid{
* P 1/2 P 1/2 * P 1/2 P 1/2
*/ */
template<class GaugeField, template <class FieldImplementation, class SmearingPolicy,
class SmearingPolicy, class RepresentationPolicy =
class RepresentationPolicy = Representations< FundamentalRepresentation > > class LeapFrog : Representations<FundamentalRepresentation> >
public Integrator<GaugeField, SmearingPolicy, RepresentationPolicy> { class LeapFrog : public Integrator<FieldImplementation, SmearingPolicy,
RepresentationPolicy> {
public: public:
typedef LeapFrog<FieldImplementation, SmearingPolicy, RepresentationPolicy>
Algorithm;
INHERIT_FIELD_TYPES(FieldImplementation);
typedef LeapFrog<GaugeField, SmearingPolicy, RepresentationPolicy> Algorithm; std::string integrator_name(){return "LeapFrog";}
LeapFrog(GridBase* grid, LeapFrog(GridBase* grid, IntegratorParameters Par,
IntegratorParameters Par, ActionSet<Field, RepresentationPolicy>& Aset, SmearingPolicy& Sm)
ActionSet<GaugeField, RepresentationPolicy> & Aset, : Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy>(
SmearingPolicy & Sm): grid, Par, Aset, Sm){};
Integrator<GaugeField, SmearingPolicy, RepresentationPolicy>(grid,Par,Aset,Sm) {};
void step (GaugeField& U, int level,int _first, int _last){
void step(Field& U, int level, int _first, int _last) {
int fl = this->as.size() - 1; int fl = this->as.size() - 1;
// level : current level // level : current level
// fl : final level // fl : final level
@ -119,7 +122,6 @@ namespace Grid{
int multiplier = this->as[level].multiplier; int multiplier = this->as[level].multiplier;
for (int e = 0; e < multiplier; ++e) { for (int e = 0; e < multiplier; ++e) {
int first_step = _first && (e == 0); int first_step = _first && (e == 0);
int last_step = _last && (e == multiplier - 1); int last_step = _last && (e == multiplier - 1);
@ -135,28 +137,29 @@ namespace Grid{
int mm = last_step ? 1 : 2; int mm = last_step ? 1 : 2;
this->update_P(U, level, mm * eps / 2.0); this->update_P(U, level, mm * eps / 2.0);
} }
} }
}; };
template<class GaugeField, template <class FieldImplementation, class SmearingPolicy,
class SmearingPolicy, class RepresentationPolicy =
class RepresentationPolicy = Representations < FundamentalRepresentation > > class MinimumNorm2 : Representations<FundamentalRepresentation> >
public Integrator<GaugeField, SmearingPolicy, RepresentationPolicy> { class MinimumNorm2 : public Integrator<FieldImplementation, SmearingPolicy,
RepresentationPolicy> {
private: private:
const RealD lambda = 0.1931833275037836; const RealD lambda = 0.1931833275037836;
public: public:
INHERIT_FIELD_TYPES(FieldImplementation);
MinimumNorm2(GridBase* grid, MinimumNorm2(GridBase* grid, IntegratorParameters Par,
IntegratorParameters Par, ActionSet<Field, RepresentationPolicy>& Aset, SmearingPolicy& Sm)
ActionSet<GaugeField, RepresentationPolicy> & Aset, : Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy>(
SmearingPolicy& Sm): grid, Par, Aset, Sm){};
Integrator<GaugeField, SmearingPolicy, RepresentationPolicy>(grid,Par,Aset,Sm) {};
void step (GaugeField& U, int level, int _first,int _last){ std::string integrator_name(){return "MininumNorm2";}
void step(Field& U, int level, int _first, int _last) {
// level : current level // level : current level
// fl : final level // fl : final level
// eps : current step size // eps : current step size
@ -195,37 +198,41 @@ namespace Grid{
int mm = (last_step) ? 1 : 2; int mm = (last_step) ? 1 : 2;
this->update_P(U, level, lambda * eps * mm); this->update_P(U, level, lambda * eps * mm);
} }
} }
}; };
template <class FieldImplementation, class SmearingPolicy,
template<class GaugeField, class RepresentationPolicy =
class SmearingPolicy, Representations<FundamentalRepresentation> >
class RepresentationPolicy = Representations< FundamentalRepresentation > > class ForceGradient : class ForceGradient : public Integrator<FieldImplementation, SmearingPolicy,
public Integrator<GaugeField, SmearingPolicy, RepresentationPolicy> { RepresentationPolicy> {
private: private:
const RealD lambda = 1.0/6.0;; const RealD lambda = 1.0 / 6.0;
;
const RealD chi = 1.0 / 72.0; const RealD chi = 1.0 / 72.0;
const RealD xi = 0.0; const RealD xi = 0.0;
const RealD theta = 0.0; const RealD theta = 0.0;
public: public:
INHERIT_FIELD_TYPES(FieldImplementation);
// Looks like dH scales as dt^4. tested wilson/wilson 2 level. // Looks like dH scales as dt^4. tested wilson/wilson 2 level.
ForceGradient(GridBase* grid, ForceGradient(GridBase* grid, IntegratorParameters Par,
IntegratorParameters Par, ActionSet<Field, RepresentationPolicy>& Aset,
ActionSet<GaugeField, RepresentationPolicy> & Aset, SmearingPolicy& Sm)
SmearingPolicy &Sm): : Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy>(
Integrator<GaugeField, SmearingPolicy, RepresentationPolicy>(grid,Par,Aset, Sm) {}; grid, Par, Aset, Sm){};
std::string integrator_name(){return "ForceGradient";}
void FG_update_P(GaugeField&U, int level,double fg_dt,double ep){ void FG_update_P(Field& U, int level, double fg_dt, double ep) {
GaugeField Ufg(U._grid); Field Ufg(U._grid);
GaugeField Pfg(U._grid); Field Pfg(U._grid);
Ufg = U; Ufg = U;
Pfg = zero; Pfg = zero;
std::cout << GridLogMessage << "FG update "<<fg_dt<<" "<<ep<<std::endl; std::cout << GridLogMessage << "FG update " << fg_dt << " " << ep
<< std::endl;
// prepare_fg; no prediction/result cache for now // prepare_fg; no prediction/result cache for now
// could relax CG stopping conditions for the // could relax CG stopping conditions for the
// derivatives in the small step since the force gets multiplied by // derivatives in the small step since the force gets multiplied by
@ -239,8 +246,7 @@ namespace Grid{
this->update_P(Ufg, level, ep); this->update_P(Ufg, level, ep);
} }
void step (GaugeField& U, int level, int _first,int _last){ void step(Field& U, int level, int _first, int _last) {
RealD eps = this->Params.stepsize * 2.0; RealD eps = this->Params.stepsize * 2.0;
for (int l = 0; l <= level; ++l) eps /= 2.0 * this->as[l].multiplier; for (int l = 0; l <= level; ++l) eps /= 2.0 * this->as[l].multiplier;
@ -252,7 +258,6 @@ namespace Grid{
for (int e = 0; e < multiplier; ++e) { // steps per step for (int e = 0; e < multiplier; ++e) { // steps per step
int first_step = _first && (e == 0); int first_step = _first && (e == 0);
int last_step = _last && (e == multiplier - 1); int last_step = _last && (e == multiplier - 1);
@ -266,7 +271,8 @@ namespace Grid{
this->step(U, level + 1, first_step, 0); this->step(U, level + 1, first_step, 0);
} }
this->FG_update_P(U,level,2*Chi/((1.0-2.0*lambda)*eps),(1.0-2.0*lambda)*eps); this->FG_update_P(U, level, 2 * Chi / ((1.0 - 2.0 * lambda) * eps),
(1.0 - 2.0 * lambda) * eps);
if (level == fl) { // lowest level if (level == fl) { // lowest level
this->update_U(U, 0.5 * eps); this->update_U(U, 0.5 * eps);
@ -276,11 +282,9 @@ namespace Grid{
int mm = (last_step) ? 1 : 2; int mm = (last_step) ? 1 : 2;
this->update_P(U, level, lambda * eps * mm); this->update_P(U, level, lambda * eps * mm);
} }
} }
}; };
} }
} }

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

@ -21,7 +21,7 @@ public:
NoSmearing(): ThinLinks(NULL) {} NoSmearing(): ThinLinks(NULL) {}
void set_GaugeField(GaugeField& U) { ThinLinks = &U; } void set_Field(GaugeField& U) { ThinLinks = &U; }
void smeared_force(GaugeField& SigmaTilde) const {} void smeared_force(GaugeField& SigmaTilde) const {}
@ -227,7 +227,7 @@ class SmearedConfiguration {
// attach the smeared routines to the thin links U and fill the smeared set // attach the smeared routines to the thin links U and fill the smeared set
void set_GaugeField(GaugeField& U) { fill_smearedSet(U); } void set_Field(GaugeField& U) { fill_smearedSet(U); }
//==================================================================== //====================================================================
void smeared_force(GaugeField& SigmaTilde) const { void smeared_force(GaugeField& SigmaTilde) const {