portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-06-14 13:57:07 +01:00
Code Releases Activity

Adding fermions actions support in the factories

Browse Source
This commit is contained in:
Guido Cossu
2017-01-19 10:00:02 +00:00
parent 23e0561dd6
commit 851f2ad8ef
12 changed files with 382 additions and 258 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/lattice/Lattice_rng.h
View File

@ -278,7 +278,7 @@ namespace Grid {
GridBase *_grid;
unsigned int _vol;
int generator_idx(int os,int is){
int generator_idx(int os,int is) {
return is*_grid->oSites()+os;
}

4
lib/qcd/action/ActionBase.h
View File

@ -37,11 +37,11 @@ class Action {
public:
bool is_smeared = false;
// Heatbath?
virtual void refresh(const GaugeField& U, const GridParallelRNG& pRNG) = 0; // refresh pseudofermions
virtual void refresh(const GaugeField& U, GridParallelRNG& pRNG) = 0; // refresh pseudofermions
virtual RealD S(const GaugeField& U) = 0; // evaluate the action
virtual void deriv(const GaugeField& U, GaugeField& dSdU) = 0; // evaluate the action derivative
virtual std::string action_name() = 0; // return the action name
virtual std::string LogParameters() = 0; // prints action parameters
virtual std::string LogParameters() = 0; // prints action parameters
virtual ~Action(){}
};

8
lib/qcd/action/gauge/PlaqPlusRectangleAction.h
View File

@ -52,6 +52,14 @@ namespace Grid{
virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {}; // noop as no pseudoferms
virtual std::string LogParameters(){
std::stringstream sstream;
sstream << GridLogMessage << "["<<action_name() <<"] c_plaq: " << c_plaq << std::endl;
sstream << GridLogMessage << "["<<action_name() <<"] c_rect: " << c_rect << std::endl;
return sstream.str();
}
virtual RealD S(const GaugeField &U) {
RealD vol = U._grid->gSites();

2
lib/qcd/action/gauge/WilsonGaugeAction.h
View File

@ -56,7 +56,7 @@ class WilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
}
virtual void refresh(const GaugeField &U,
const GridParallelRNG &pRNG){}; // noop as no pseudoferms
GridParallelRNG &pRNG){}; // noop as no pseudoferms
virtual RealD S(const GaugeField &U) {
RealD plaq = WilsonLoops<Gimpl>::avgPlaquette(U);

8
lib/qcd/action/pseudofermion/TwoFlavour.h
View File

@ -64,6 +64,12 @@ class TwoFlavourPseudoFermionAction : public Action<typename Impl::GaugeField> {
virtual std::string action_name(){return "TwoFlavourPseudoFermionAction";}
virtual std::string LogParameters(){
std::stringstream sstream;
sstream << GridLogMessage << "["<<action_name()<<"] has no parameters" << std::endl;
return sstream.str();
}
//////////////////////////////////////////////////////////////////////////////////////
// Push the gauge field in to the dops. Assume any BC's and smearing already
@ -85,7 +91,7 @@ class TwoFlavourPseudoFermionAction : public Action<typename Impl::GaugeField> {
// the partition function.
//
RealD scale = std::sqrt(0.5);
RealD scale = std::sqrt(0.5);
FermionField eta(FermOp.FermionGrid());

56
lib/qcd/hmc/HMCResourceManager.h
View File

@ -48,7 +48,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
} \
}
namespace Grid {
namespace QCD {
@ -131,31 +130,7 @@ class HMCResourceManager {
}
// this private
template <class ReaderClass >
void fill_ActionsLevel(ReaderClass &Read){
// Actions set
int m;
Read.readDefault("multiplier",m);
multipliers.push_back(m);
std::cout << "Level : " << multipliers.size() << " with multiplier : " << m << std::endl;
// here gauge
Read.push("Action");
do{
auto &ActionFactory = HMC_LGTActionModuleFactory<gauge_string, ReaderClass>::getInstance();
std::string action_type;
Read.readDefault("name", action_type);
std::cout << "Registered types " << std::endl;
std::cout << ActionFactory.getBuilderList() << std::endl;
ActionsList.emplace(m, ActionFactory.create(action_type, Read));
} while (Read.nextElement("Action"));
ActionsList.find(m)->second->print_parameters();
}
template <class RepresentationPolicy>
void GetActionSet(ActionSet<typename ImplementationPolicy::Field, RepresentationPolicy>& Aset){
Aset.resize(multipliers.size());
@ -271,6 +246,35 @@ class HMCResourceManager {
}
private:
// this private
template <class ReaderClass >
void fill_ActionsLevel(ReaderClass &Read){
// Actions set
int m;
Read.readDefault("multiplier",m);
multipliers.push_back(m);
std::cout << "Level : " << multipliers.size() << " with multiplier : " << m << std::endl;
// here gauge
Read.push("Action");
do{
auto &ActionFactory = HMC_LGTActionModuleFactory<gauge_string, ReaderClass>::getInstance();
std::string action_type;
Read.readDefault("name", action_type);
std::cout << "Registered types " << std::endl;
std::cout << ActionFactory.getBuilderList() << std::endl;
ActionsList.emplace(m, ActionFactory.create(action_type, Read));
} while (Read.nextElement("Action"));
ActionsList.find(m)->second->print_parameters();
}
};
}
}

246
lib/qcd/modules/ActionModules.h Normal file
View File

@ -0,0 +1,246 @@
/*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid
Source file: ./lib/qcd/modules/ActionModules.h
Copyright (C) 2016
Author: Guido Cossu <guido.cossu@ed.ac.uk>
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 */
#ifndef ACTION_MODULES_H
#define ACTION_MODULES_H
/*
Define loadable, serializable modules
for the HMC execution
*/
namespace Grid {
//////////////////////////////////////////////
// Actions
//////////////////////////////////////////////
template <class ActionType, class APar>
class ActionModule
: public Parametrized<APar>,
public HMCModuleBase<QCD::Action<typename ActionType::GaugeField> > {
public:
typedef HMCModuleBase< QCD::Action<typename ActionType::GaugeField> > Base;
typedef typename Base::Product Product;
std::unique_ptr<ActionType> ActionPtr;
ActionModule(APar Par) : Parametrized<APar>(Par) {}
template <class ReaderClass>
ActionModule(Reader<ReaderClass>& Reader) : Parametrized<APar>(Reader){};
virtual void print_parameters(){
std::cout << this->Par_ << std::endl;
}
Product* getPtr() {
if (!ActionPtr) initialize();
return ActionPtr.get();
}
private:
virtual void initialize() = 0;
};
////////////////
// Modules
////////////////
namespace QCD{
class PlaqPlusRectangleGaugeActionParameters : Serializable {
public:
GRID_SERIALIZABLE_CLASS_MEMBERS(PlaqPlusRectangleGaugeActionParameters,
RealD, c_plaq,
RealD, c_rect);
};
class RBCGaugeActionParameters : Serializable {
public:
GRID_SERIALIZABLE_CLASS_MEMBERS(RBCGaugeActionParameters,
RealD, beta,
RealD, c1);
};
class BetaGaugeActionParameters : Serializable {
public:
GRID_SERIALIZABLE_CLASS_MEMBERS(BetaGaugeActionParameters,
RealD, beta);
};
template <class Impl >
class WilsonGModule: public ActionModule<WilsonGaugeAction<Impl>, BetaGaugeActionParameters> {
typedef ActionModule<WilsonGaugeAction<Impl>, BetaGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; // for constructors
// acquire resource
virtual void initialize(){
this->ActionPtr.reset(new WilsonGaugeAction<Impl>(this->Par_.beta));
}
};
template <class Impl >
class PlaqPlusRectangleGModule: public ActionModule<PlaqPlusRectangleAction<Impl>, PlaqPlusRectangleGaugeActionParameters> {
typedef ActionModule<PlaqPlusRectangleAction<Impl>, PlaqPlusRectangleGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; // for constructors
// acquire resource
virtual void initialize(){
this->ActionPtr.reset(new PlaqPlusRectangleAction<Impl>(this->Par_.c_plaq, this->Par_.c_rect));
}
};
template <class Impl >
class RBCGModule: public ActionModule<RBCGaugeAction<Impl>, RBCGaugeActionParameters> {
typedef ActionModule<RBCGaugeAction<Impl>, RBCGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; // for constructors
// acquire resource
virtual void initialize(){
this->ActionPtr.reset(new RBCGaugeAction<Impl>(this->Par_.beta, this->Par_.c1));
}
};
template <class Impl >
class SymanzikGModule: public ActionModule<SymanzikGaugeAction<Impl>, BetaGaugeActionParameters> {
typedef ActionModule<SymanzikGaugeAction<Impl>, BetaGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; // for constructors
// acquire resource
virtual void initialize(){
this->ActionPtr.reset(new SymanzikGaugeAction<Impl>(this->Par_.beta));
}
};
template <class Impl >
class IwasakiGModule: public ActionModule<IwasakiGaugeAction<Impl>, BetaGaugeActionParameters> {
typedef ActionModule<IwasakiGaugeAction<Impl>, BetaGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; // for constructors
// acquire resource
virtual void initialize(){
this->ActionPtr.reset(new IwasakiGaugeAction<Impl>(this->Par_.beta));
}
};
template <class Impl >
class DBW2GModule: public ActionModule<DBW2GaugeAction<Impl>, BetaGaugeActionParameters> {
typedef ActionModule<DBW2GaugeAction<Impl>, BetaGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; // for constructors
// acquire resource
virtual void initialize(){
this->ActionPtr.reset(new DBW2GaugeAction<Impl>(this->Par_.beta));
}
};
typedef WilsonGModule<PeriodicGimplR> WilsonGMod;
typedef SymanzikGModule<PeriodicGimplR> SymanzikGMod;
typedef IwasakiGModule<PeriodicGimplR> IwasakiGMod;
typedef DBW2GModule<PeriodicGimplR> DBW2GMod;
typedef RBCGModule<PeriodicGimplR> RBCGMod;
typedef PlaqPlusRectangleGModule<PeriodicGimplR> PlaqPlusRectangleGMod;
}// QCD temporarily here
////////////////////////////////////////
// Factories specialisations
////////////////////////////////////////
// use the same classed defined by Antonin, does not make sense to rewrite
// Factory is perfectly fine
// Registar must be changed because I do not want to use the ModuleFactory
// explicit ref to LatticeGaugeField must be changed of put in the factory
typedef HMCModuleBase< QCD::Action< QCD::LatticeGaugeField > > HMC_LGTActionModBase;
template <char const *str, class ReaderClass >
class HMC_LGTActionModuleFactory
: public Factory < HMC_LGTActionModBase , Reader<ReaderClass> > {
public:
typedef Reader<ReaderClass> TheReader;
// use SINGLETON FUNCTOR MACRO HERE
HMC_LGTActionModuleFactory(const HMC_LGTActionModuleFactory& e) = delete;
void operator=(const HMC_LGTActionModuleFactory& e) = delete;
static HMC_LGTActionModuleFactory& getInstance(void) {
static HMC_LGTActionModuleFactory e;
return e;
}
private:
HMC_LGTActionModuleFactory(void) = default;
std::string obj_type() const {
return std::string(str);
}
};
extern char gauge_string[];
static Registrar<QCD::WilsonGMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __WGmodXMLInit("Wilson");
static Registrar<QCD::SymanzikGMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __SymGmodXMLInit("Symanzik");
static Registrar<QCD::IwasakiGMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __IwGmodXMLInit("Iwasaki");
static Registrar<QCD::DBW2GMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __DBW2GmodXMLInit("DBW2");
static Registrar<QCD::RBCGMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __RBCGmodXMLInit("RBC");
static Registrar<QCD::PlaqPlusRectangleGMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __PPRectGmodXMLInit("PlaqPlusRect");
// add here the registration for other implementations and readers
}
#endif //HMC_MODULES_H

4
lib/qcd/modules/Modules.cc
View File

@ -34,4 +34,8 @@ char cp_string[] = "CheckPointer";
char hmc_string[] = "HMC";
char observable_string[] = "Observable";
}

124
lib/qcd/modules/Modules.h
View File

@ -102,43 +102,6 @@ class HMCModuleBase {
virtual void print_parameters(){}; // default to nothing
};
//////////////////////////////////////////////
// Actions
//////////////////////////////////////////////
template <class ActionType, class APar>
class ActionModule
: public Parametrized<APar>,
public HMCModuleBase<QCD::Action<typename ActionType::GaugeField> > {
public:
typedef HMCModuleBase< QCD::Action<typename ActionType::GaugeField> > Base;
typedef typename Base::Product Product;
std::unique_ptr<ActionType> ActionPtr;
ActionModule(APar Par) : Parametrized<APar>(Par) {}
template <class ReaderClass>
ActionModule(Reader<ReaderClass>& Reader) : Parametrized<APar>(Reader){};
virtual void print_parameters(){
std::cout << this->Par_ << std::endl;
}
Product* getPtr() {
if (!ActionPtr) initialize();
return ActionPtr.get();
}
private:
virtual void initialize() = 0;
};
/////////////////////////////
// Observables
/////////////////////////////
@ -174,48 +137,12 @@ class ObservableModule
////////////////
// Modules
////////////////
namespace QCD{
class WilsonGaugeActionParameters : Serializable {
public:
GRID_SERIALIZABLE_CLASS_MEMBERS(WilsonGaugeActionParameters,
RealD, beta);
};
template <class Impl >
class WilsonGModule: public ActionModule<WilsonGaugeAction<Impl>, WilsonGaugeActionParameters> {
typedef ActionModule<WilsonGaugeAction<Impl>, WilsonGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; // for constructors
// acquire resource
virtual void initialize(){
this->ActionPtr.reset(new WilsonGaugeAction<Impl>(this->Par_.beta));
}
};
typedef WilsonGModule<PeriodicGimplR> WilsonGMod;
//// Observables module
class PlaquetteObsParameters : Serializable {
public:
@ -235,18 +162,6 @@ class PlaquetteMod: public ObservableModule<PlaquetteLogger<Impl>, PlaquetteObsP
};
}// QCD temporarily here
@ -260,34 +175,6 @@ class PlaquetteMod: public ObservableModule<PlaquetteLogger<Impl>, PlaquetteObsP
////////////////////////////////////////
// use the same classed defined by Antonin, does not make sense to rewrite
// Factory is perfectly fine
// Registar must be changed because I do not want to use the ModuleFactory
// explicit ref to LatticeGaugeField must be changed of put in the factory
typedef HMCModuleBase< QCD::Action< QCD::LatticeGaugeField > > HMC_LGTActionModBase;
template <char const *str, class ReaderClass >
class HMC_LGTActionModuleFactory
: public Factory < HMC_LGTActionModBase , Reader<ReaderClass> > {
public:
typedef Reader<ReaderClass> TheReader;
// use SINGLETON FUNCTOR MACRO HERE
HMC_LGTActionModuleFactory(const HMC_LGTActionModuleFactory& e) = delete;
void operator=(const HMC_LGTActionModuleFactory& e) = delete;
static HMC_LGTActionModuleFactory& getInstance(void) {
static HMC_LGTActionModuleFactory e;
return e;
}
private:
HMC_LGTActionModuleFactory(void) = default;
std::string obj_type() const {
return std::string(str);
}
};
// explicit ref to LatticeGaugeField must be changed of put in the factory
typedef HMCModuleBase< QCD::HmcObservable<QCD::LatticeGaugeField> > HMC_ObsModBase;
@ -313,11 +200,6 @@ class HMC_ObservablesModuleFactory
template <class T, class TheFactory>
class Registrar {
public:
@ -330,12 +212,6 @@ class Registrar {
extern char gauge_string[];
static Registrar<QCD::WilsonGMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __WGmodXMLInit("Wilson");
// add here the registration for other implementations and readers
extern char observable_string[];
static Registrar<QCD::PlaquetteMod<QCD::PeriodicGimplR>, HMC_ObservablesModuleFactory<observable_string, XmlReader> > __OBSPLmodXMLInit("Plaquette");

2
lib/qcd/modules/mods.h
View File

@ -34,5 +34,7 @@ directory
#include <Grid/qcd/modules/Factory.h>
#include <Grid/qcd/modules/Modules.h>
#include <Grid/qcd/modules/ActionModules.h>
#endif //MODS_H