portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2024-11-10 07:55:35 +00:00
Code Releases Activity

Added support for input file HMC modules (missing the actions yet)

Browse Source
This commit is contained in:
Guido Cossu 2017-01-16 16:07:12 +00:00
parent c6f59c2933
commit 87e8aad5a0
11 changed files with 418 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/Grid.h
View File

@ -84,10 +84,7 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
#include <Grid/parallelIO/BinaryIO.h> #include <Grid/parallelIO/BinaryIO.h>
#include <Grid/parallelIO/IldgIO.h> #include <Grid/parallelIO/IldgIO.h>
#include <Grid/parallelIO/NerscIO.h> #include <Grid/parallelIO/NerscIO.h>
#include <Grid/qcd/hmc/checkpointers/BaseCheckpointer.h> #include <Grid/qcd/hmc/checkpointers/CheckPointers.h>
#include <Grid/qcd/hmc/checkpointers/NerscCheckpointer.h>
#include <Grid/qcd/hmc/checkpointers/BinaryCheckpointer.h>
#include <Grid/qcd/hmc/checkpointers/ILDGCheckpointer.h>
#include <Grid/qcd/hmc/HMCModules.h> #include <Grid/qcd/hmc/HMCModules.h>
#include <Grid/qcd/hmc/HMCResourceManager.h> #include <Grid/qcd/hmc/HMCResourceManager.h>
#include <Grid/qcd/hmc/HmcRunner.h> #include <Grid/qcd/hmc/HmcRunner.h>

22
lib/qcd/hmc/HMCModules.h
View File

@ -34,7 +34,7 @@ namespace Grid {
namespace QCD { namespace QCD {
// Some modules for the basic setup
/////////////////////////////////////////////////// ///////////////////////////////////////////////////
@ -165,6 +165,9 @@ public:
} }
}; };
/*
/////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////
/// Smearing module /// Smearing module
template <class ImplementationPolicy> template <class ImplementationPolicy>
@ -177,24 +180,9 @@ class StoutSmearingModule: public SmearingModule<ImplementationPolicy>{
SmearedConfiguration<ImplementationPolicy> SmearingPolicy; SmearedConfiguration<ImplementationPolicy> SmearingPolicy;
}; };
*/
////////////////////////////////////////////////////////////////////////
// Checkpoint module, owns the Checkpointer
template <class ImplementationPolicy>
class CheckPointModule {
std::unique_ptr<BaseHmcCheckpointer<ImplementationPolicy> > cp_;
public:
void set_Checkpointer(BaseHmcCheckpointer<ImplementationPolicy>* cp) {
cp_.reset(cp);
};
BaseHmcCheckpointer<ImplementationPolicy>* get_CheckPointer() {
return cp_.get();
}
void initialize(CheckpointerParameters& P) { cp_.initialize(P); }
};
} // namespace QCD } // namespace QCD
} // namespace Grid } // namespace Grid

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

@ -38,8 +38,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
if (!have_CheckPointer) { \ if (!have_CheckPointer) { \
std::cout << GridLogDebug << "Loading Checkpointer " << #NAME \ std::cout << GridLogDebug << "Loading Checkpointer " << #NAME \
<< std::endl; \ << std::endl; \
CP.set_Checkpointer( \ CP = std::unique_ptr<CheckpointerBaseModule>( \
new NAME##HmcCheckpointer<ImplementationPolicy>(Params_)); \ new NAME##CPModule<ImplementationPolicy>(Params_)); \
have_CheckPointer = true; \ have_CheckPointer = true; \
} else { \ } else { \
std::cout << GridLogError << "Checkpointer already loaded " \ std::cout << GridLogError << "Checkpointer already loaded " \
@ -48,24 +48,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
} \ } \
} }
/*
// One function per Checkpointer using the reader, use a macro to simplify
#define RegisterLoadCheckPointerReaderFunction(NAME) \
template <class Reader> \
void Load##NAME##Checkpointer(Reader& Reader_) { \
if (!have_CheckPointer) { \
std::cout << GridLogDebug << "Loading Checkpointer " << #NAME \
<< std::endl; \
CP.set_Checkpointer(new NAME##HmcCheckpointer<ImplementationPolicy>( \
CheckpointerParameters(Reader_))); \
have_CheckPointer = true; \
} else { \
std::cout << GridLogError << "Checkpointer already loaded " \
<< std::endl; \
exit(1); \
} \
}
*/
namespace Grid { namespace Grid {
namespace QCD { namespace QCD {
@ -73,20 +55,49 @@ namespace QCD {
// HMC Resource manager // HMC Resource manager
template <class ImplementationPolicy> template <class ImplementationPolicy>
class HMCResourceManager { class HMCResourceManager {
typedef HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> > CheckpointerBaseModule;
// Named storage for grid pairs (std + red-black) // Named storage for grid pairs (std + red-black)
std::unordered_map<std::string, GridModule> Grids; std::unordered_map<std::string, GridModule> Grids;
RNGModule RNGs; RNGModule RNGs;
// SmearingModule<ImplementationPolicy> Smearing; // SmearingModule<ImplementationPolicy> Smearing;
CheckPointModule<ImplementationPolicy> CP; std::unique_ptr<CheckpointerBaseModule > CP;
bool have_RNG; bool have_RNG;
bool have_CheckPointer; bool have_CheckPointer;
public: public:
HMCResourceManager() : have_RNG(false), have_CheckPointer(false) {} HMCResourceManager() : have_RNG(false), have_CheckPointer(false) {}
// Here need a constructor for using the Reader class template <class ReaderClass >
void initialize(ReaderClass &Read){
// assumes we are starting from the main node
// Geometry
GridModuleParameters GridPar(Read);
GridFourDimModule GridMod( GridPar) ;
AddGrid("gauge", GridMod);
// Checkpointer
auto &CPfactory = HMC_CPModuleFactory<cp_string, QCD::PeriodicGimplR, ReaderClass >::getInstance();
Read.push("Checkpointer");
std::string cp_type;
Read.readDefault("name", cp_type);
std::cout << "Registered types " << std::endl;
std::cout << CPfactory.getBuilderList() << std::endl;
CP = CPfactory.create(cp_type, Read);
CP->print_parameters();
Read.pop();
have_CheckPointer = true;
RNGModuleParameters RNGpar(Read);
SetRNGSeeds(RNGpar);
// HMC here
}
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
// Grids // Grids
@ -159,7 +170,7 @@ class HMCResourceManager {
BaseHmcCheckpointer<ImplementationPolicy>* GetCheckPointer() { BaseHmcCheckpointer<ImplementationPolicy>* GetCheckPointer() {
if (have_CheckPointer) if (have_CheckPointer)
return CP.get_CheckPointer(); return CP->getPtr();
else { else {
std::cout << GridLogError << "Error: no checkpointer defined" std::cout << GridLogError << "Error: no checkpointer defined"
<< std::endl; << std::endl;
@ -170,13 +181,6 @@ class HMCResourceManager {
RegisterLoadCheckPointerFunction(Binary); RegisterLoadCheckPointerFunction(Binary);
RegisterLoadCheckPointerFunction(Nersc); RegisterLoadCheckPointerFunction(Nersc);
RegisterLoadCheckPointerFunction(ILDG); RegisterLoadCheckPointerFunction(ILDG);
/*
RegisterLoadCheckPointerReaderFunction(Binary);
RegisterLoadCheckPointerReaderFunction(Nersc);
RegisterLoadCheckPointerReaderFunction(ILDG);
*/
}; };
} }
} }

4
lib/qcd/hmc/checkpointers/BaseCheckpointer.h
View File

@ -48,8 +48,8 @@ class CheckpointerParameters : Serializable {
format(f){}; format(f){};
template <class ReaderClass, typename std::enable_if< isReader<ReaderClass>::value, int>::type = 0 > template <class ReaderClass >
CheckpointerParameters(ReaderClass &Reader) { CheckpointerParameters(Reader<ReaderClass> &Reader) {
read(Reader, "Checkpointer", *this); read(Reader, "Checkpointer", *this);
} }

150
lib/qcd/hmc/checkpointers/CheckPointerModules.h Normal file
View File

@ -0,0 +1,150 @@
/*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid
Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.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 CP_MODULES_H
#define CP_MODULES_H
// FIXME Reorganize QCD namespace
namespace Grid {
////////////////////////////////////////////////////////////////////////
// Checkpoint module, owns the Checkpointer
////////////////////////////////////////////////////////////////////////
template <class ImplementationPolicy>
class CheckPointerModule: public Parametrized<QCD::CheckpointerParameters>, public HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> > {
public:
std::unique_ptr<QCD::BaseHmcCheckpointer<ImplementationPolicy> > CheckPointPtr;
typedef QCD::CheckpointerParameters APar;
typedef HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> > Base;
typedef typename Base::Product Product;
CheckPointerModule(APar Par): Parametrized<APar>(Par) {}
template <class ReaderClass>
CheckPointerModule(Reader<ReaderClass>& Reader) : Parametrized<APar>(Reader){};
virtual void print_parameters(){
std::cout << this->Par_ << std::endl;
}
Product* getPtr() {
if (!CheckPointPtr) initialize();
return CheckPointPtr.get();
}
private:
virtual void initialize() = 0;
};
template <char const *str, class ImplementationPolicy, class ReaderClass >
class HMC_CPModuleFactory
: public Factory < HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> > , Reader<ReaderClass> > {
public:
typedef Reader<ReaderClass> TheReader;
// use SINGLETON FUNCTOR MACRO HERE
HMC_CPModuleFactory(const HMC_CPModuleFactory& e) = delete;
void operator=(const HMC_CPModuleFactory& e) = delete;
static HMC_CPModuleFactory& getInstance(void) {
static HMC_CPModuleFactory e;
return e;
}
private:
HMC_CPModuleFactory(void) = default;
std::string obj_type() const {
return std::string(str);
}
};
/////////////////////////////////////////////////////////////////////
// Concrete classes
/////////////////////////////////////////////////////////////////////
namespace QCD{
template<class ImplementationPolicy>
class BinaryCPModule: public CheckPointerModule< ImplementationPolicy> {
typedef CheckPointerModule< ImplementationPolicy> CPBase;
using CPBase::CPBase; // for constructors
// acquire resource
virtual void initialize(){
this->CheckPointPtr.reset(new BinaryHmcCheckpointer<ImplementationPolicy>(this->Par_));
}
};
template<class ImplementationPolicy>
class NerscCPModule: public CheckPointerModule< ImplementationPolicy> {
typedef CheckPointerModule< ImplementationPolicy> CPBase;
using CPBase::CPBase; // for constructors
// acquire resource
virtual void initialize(){
this->CheckPointPtr.reset(new NerscHmcCheckpointer<ImplementationPolicy>(this->Par_));
}
};
template<class ImplementationPolicy>
class ILDGCPModule: public CheckPointerModule< ImplementationPolicy> {
typedef CheckPointerModule< ImplementationPolicy> CPBase;
using CPBase::CPBase; // for constructors
// acquire resource
virtual void initialize(){
this->CheckPointPtr.reset(new ILDGHmcCheckpointer<ImplementationPolicy>(this->Par_));
}
};
}// QCD temporarily here
extern char cp_string[];
static Registrar<QCD::BinaryCPModule<QCD::PeriodicGimplR>, HMC_CPModuleFactory<cp_string, QCD::PeriodicGimplR, XmlReader> > __CPBinarymodXMLInit("Binary");
static Registrar<QCD::NerscCPModule<QCD::PeriodicGimplR> , HMC_CPModuleFactory<cp_string, QCD::PeriodicGimplR, XmlReader> > __CPNerscmodXMLInit("Nersc");
static Registrar<QCD::ILDGCPModule<QCD::PeriodicGimplR> , HMC_CPModuleFactory<cp_string, QCD::PeriodicGimplR, XmlReader> > __CPILDGmodXMLInit("ILDG");
}// Grid
#endif //CP_MODULES_H

40
lib/qcd/hmc/checkpointers/CheckPointers.h Normal file
View File

@ -0,0 +1,40 @@
/*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid
Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.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 CHECKPOINTERS_H
#define CHECKPOINTERS_H
#include <Grid/qcd/hmc/checkpointers/BaseCheckpointer.h>
#include <Grid/qcd/hmc/checkpointers/NerscCheckpointer.h>
#include <Grid/qcd/hmc/checkpointers/BinaryCheckpointer.h>
#include <Grid/qcd/hmc/checkpointers/ILDGCheckpointer.h>
#include <Grid/qcd/hmc/checkpointers/CheckPointerModules.h>
#endif // CHECKPOINTERS_H

11
lib/qcd/modules/Factory.h
View File

@ -50,6 +50,7 @@ public:
const ProductCreator& name) const; const ProductCreator& name) const;
private: private:
std::map<std::string, Func> builder_; std::map<std::string, Func> builder_;
virtual std::string obj_type() const = 0;
}; };
/****************************************************************************** /******************************************************************************
@ -79,20 +80,24 @@ std::vector<std::string> Factory<T, ProductCreator>::getBuilderList(void) const
// factory ///////////////////////////////////////////////////////////////////// // factory /////////////////////////////////////////////////////////////////////
template <typename T, typename ProductCreator> template <typename T, typename ProductCreator>
std::unique_ptr<T> Factory<T, ProductCreator>::create(const std::string type, std::unique_ptr<T> Factory<T, ProductCreator>::create(const std::string type,
const ProductCreator& name) const const ProductCreator& input) const
{ {
Func func; Func func;
std::cout << GridLogDebug << "Creating object of type "<< type << std::endl;
try try
{ {
func = builder_.at(type); func = builder_.at(type);
} }
catch (std::out_of_range &) catch (std::out_of_range &)
{ {
//HADRON_ERROR("object of type '" + type + "' unknown"); //HADRON_ERROR("object of type '" + type + "' unknown");
std::cout << GridLogError << "Error" << std::endl;
std::cout << GridLogError << obj_type() << " object of name [" << type << "] unknown" << std::endl;
exit(1);
} }
return func(name); return func(input);
} }
} }

35
lib/qcd/modules/Modules.cc Normal file
View File

@ -0,0 +1,35 @@
/*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid
Source file: ./lib/qcd/modules/Modules.cc
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 */
namespace Grid{
char gauge_string[] = "gauge";
char cp_string[] = "CheckPointer";
}

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

@ -50,6 +50,16 @@ public:
Parametrized(Reader<ReaderClass> & Reader){ Parametrized(Reader<ReaderClass> & Reader){
read(Reader, section_name(), Par_); read(Reader, section_name(), Par_);
} }
void set_parameters(Parameters Par){
Par_ = Par;
}
void print_parameters(){
std::cout << Par_ << std::endl;
}
protected: protected:
Parameters Par_; Parameters Par_;
@ -70,6 +80,7 @@ class HMCModuleBase{
public: public:
typedef Prod Product; typedef Prod Product;
virtual Prod* getPtr() = 0; virtual Prod* getPtr() = 0;
virtual void print_parameters(){}; //default to nothing
}; };
@ -87,6 +98,8 @@ class ActionModule
typedef HMCModuleBase< QCD::Action<typename ActionType::GaugeField> > Base; typedef HMCModuleBase< QCD::Action<typename ActionType::GaugeField> > Base;
typedef typename Base::Product Product; typedef typename Base::Product Product;
std::unique_ptr<ActionType> ActionPtr; std::unique_ptr<ActionType> ActionPtr;
ActionModule(APar Par) : Parametrized<APar>(Par) {} ActionModule(APar Par) : Parametrized<APar>(Par) {}
@ -94,6 +107,10 @@ class ActionModule
template <class ReaderClass> template <class ReaderClass>
ActionModule(Reader<ReaderClass>& Reader) : Parametrized<APar>(Reader){}; ActionModule(Reader<ReaderClass>& Reader) : Parametrized<APar>(Reader){};
virtual void print_parameters(){
std::cout << this->Par_ << std::endl;
}
Product* getPtr() { Product* getPtr() {
if (!ActionPtr) initialize(); if (!ActionPtr) initialize();
@ -102,8 +119,16 @@ class ActionModule
private: private:
virtual void initialize() = 0; virtual void initialize() = 0;
}; };
namespace QCD{ namespace QCD{
class WilsonGaugeActionParameters : Serializable { class WilsonGaugeActionParameters : Serializable {
@ -118,11 +143,11 @@ class WilsonGaugeActionParameters : Serializable {
template<class Impl> template<class Impl>
class WilsonGModule: public ActionModule<WilsonGaugeAction<Impl>, WilsonGaugeActionParameters> { class WilsonGModule: public ActionModule<WilsonGaugeAction<Impl>, WilsonGaugeActionParameters> {
typedef ActionModule<WilsonGaugeAction<Impl>, WilsonGaugeActionParameters> ActionBase; typedef ActionModule<WilsonGaugeAction<Impl>, WilsonGaugeActionParameters> ActionBase;
using ActionBase::ActionBase; using ActionBase::ActionBase; // for constructors
// acquire resource // acquire resource
virtual void initialize(){ virtual void initialize(){
ActionBase::ActionPtr.reset(new WilsonGaugeAction<Impl>(ActionBase::Par_.beta)); this->ActionPtr.reset(new WilsonGaugeAction<Impl>(this->Par_.beta));
} }
}; };
@ -137,31 +162,38 @@ typedef WilsonGModule<PeriodicGimplR> WilsonGMod;
////////////////////////////////////////
// Factories specialisations
////////////////////////////////////////
// use the same classed defined by Antonin, does not make sense to rewrite // use the same classed defined by Antonin, does not make sense to rewrite
// Factory is perfectly fine // Factory is perfectly fine
// Registar must be changed because I do not want to use the ModuleFactory // Registar must be changed because I do not want to use the ModuleFactory
/*
define
*/
// ref to LatticeGaugeField must be changed
typedef HMCModuleBase< QCD::Action< QCD::LatticeGaugeField > > HMC_LGTActionModBase;
typedef HMCModuleBase< QCD::Action< QCD::LatticeGaugeField > > HMCModBase; template <char const *str, class ReaderClass >
class HMC_LGTActionModuleFactory
template <class ReaderClass > : public Factory < HMC_LGTActionModBase , Reader<ReaderClass> > {
class HMCActionModuleFactory
: public Factory < HMCModBase , Reader<ReaderClass> > {
public: public:
typedef Reader<ReaderClass> TheReader; typedef Reader<ReaderClass> TheReader;
// use SINGLETON FUNCTOR MACRO HERE // use SINGLETON FUNCTOR MACRO HERE
HMCActionModuleFactory(const HMCActionModuleFactory& e) = delete; HMC_LGTActionModuleFactory(const HMC_LGTActionModuleFactory& e) = delete;
void operator=(const HMCActionModuleFactory& e) = delete; void operator=(const HMC_LGTActionModuleFactory& e) = delete;
static HMCActionModuleFactory& getInstance(void) { static HMC_LGTActionModuleFactory& getInstance(void) {
static HMCActionModuleFactory e; static HMC_LGTActionModuleFactory e;
return e; return e;
} }
private: private:
HMCActionModuleFactory(void) = default; HMC_LGTActionModuleFactory(void) = default;
std::string obj_type() const {
return std::string(str);
}
}; };
/* /*
@ -178,6 +210,8 @@ when needed a pointer is released
template <class T, class TheFactory> template <class T, class TheFactory>
class Registrar { class Registrar {
public: public:
@ -188,9 +222,10 @@ class Registrar {
} }
}; };
Registrar<QCD::WilsonGMod, HMCActionModuleFactory<XmlReader> > __WGmodInit("WilsonGaugeAction");
extern char gauge_string[];
static Registrar<QCD::WilsonGMod, HMC_LGTActionModuleFactory<gauge_string, XmlReader> > __WGmodXMLInit("Wilson");
} }

88
tests/hmc/Test_hmc_Factories.cc Normal file
View File

@ -0,0 +1,88 @@
/*************************************************************************************
Grid physics library, www.github.com/paboyle/Grid
Source file: ./tests/Test_hmc_WilsonFermionGauge.cc
Copyright (C) 2015
Author: Peter Boyle <pabobyle@ph.ed.ac.uk>
Author: neo <cossu@post.kek.jp>
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 */
#include <Grid/Grid.h>
int main(int argc, char **argv) {
using namespace Grid;
using namespace Grid::QCD;
Grid_init(&argc, &argv);
int threads = GridThread::GetThreads();
// here make a routine to print all the relevant information on the run
std::cout << GridLogMessage << "Grid is setup to use " << threads << " threads" << std::endl;
// Typedefs to simplify notation
typedef GenericHMCRunner<MinimumNorm2> HMCWrapper; // Uses the default minimum norm
typedef Grid::XmlReader InputFileReader;
// Reader
InputFileReader Reader("input.wilson_gauge.params.xml");
HMCWrapper TheHMC;
TheHMC.Resources.initialize(Reader);
// Construct observables
// here there is too much indirection
PlaquetteLogger<HMCWrapper::ImplPolicy> PlaqLog("Plaquette");
TheHMC.ObservablesList.push_back(&PlaqLog);
//////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// Collect actions, here use more encapsulation
// need wrappers of the fermionic classes
// that have a complex construction
// standard
RealD beta = 5.6 ;
WilsonGaugeActionR Waction(beta);
ActionLevel<HMCWrapper::Field> Level1(1);
Level1.push_back(&Waction);
//Level1.push_back(WGMod.getPtr());
TheHMC.TheAction.push_back(Level1);
/////////////////////////////////////////////////////////////
// Nest MDparameters in the HMCparameters->HMCPayload
// make it serializable
TheHMC.MDparameters.MDsteps = 20;
TheHMC.MDparameters.trajL = 1.0;
// eventually smearing here
// ...
////////////////////////////////////////////////////////////////
TheHMC.ReadCommandLine(argc, argv); // these must be parameters from file
TheHMC.Run(); // no smearing
Grid_finalize();
} // main

35
tests/hmc/Test_hmc_WilsonGauge_Binary.cc
View File

@ -41,22 +41,13 @@ int main(int argc, char **argv) {
// Typedefs to simplify notation // Typedefs to simplify notation
typedef GenericHMCRunner<MinimumNorm2> HMCWrapper; // Uses the default minimum norm typedef GenericHMCRunner<MinimumNorm2> HMCWrapper; // Uses the default minimum norm
typedef Grid::XmlReader InputFileReader;
// Reader, now not necessary
InputFileReader Reader("input.wilson_gauge.params.xml");
HMCWrapper TheHMC; HMCWrapper TheHMC;
// Grid from the command line // Grid from the command line
TheHMC.Resources.AddFourDimGrid("gauge"); TheHMC.Resources.AddFourDimGrid("gauge");
// Possibile to create the module by hand
// hardcoding parameters or using a Reader
// Grid from the Reader
/*
GridModuleParameters GridPar(Reader);
GridFourDimModule GridMod( GridPar) ;
TheHMC.Resources.AddGrid("gauge", GridMod);
*/
// Checkpointer definition // Checkpointer definition
CheckpointerParameters CPparams; CheckpointerParameters CPparams;
@ -65,14 +56,8 @@ int main(int argc, char **argv) {
CPparams.saveInterval = 5; CPparams.saveInterval = 5;
CPparams.format = "IEEE64BIG"; CPparams.format = "IEEE64BIG";
// can also use the reader constructor
// CheckpointerParameters CPparams(Reader);
TheHMC.Resources.LoadBinaryCheckpointer(CPparams); TheHMC.Resources.LoadBinaryCheckpointer(CPparams);
// Fill resources
// Seeds for the random number generators
// Can also initialize using the Reader
RNGModuleParameters RNGpar; RNGModuleParameters RNGpar;
RNGpar.SerialSeed = {1,2,3,4,5}; RNGpar.SerialSeed = {1,2,3,4,5};
RNGpar.ParallelSeed = {6,7,8,9,10}; RNGpar.ParallelSeed = {6,7,8,9,10};
@ -88,18 +73,6 @@ int main(int argc, char **argv) {
// Collect actions, here use more encapsulation // Collect actions, here use more encapsulation
// need wrappers of the fermionic classes // need wrappers of the fermionic classes
// that have a complex construction // that have a complex construction
// Gauge action
// as module
/*
WilsonGMod::Parameters WPar;
WPar.beta = 6.0;
WilsonGMod WGMod(WPar);
auto testAction = WGMod.getPtr();// test to pass to the action set
HMCModuleBase<Action<LatticeGaugeField>>* HMB = &WGMod;
*/
// standard // standard
RealD beta = 5.6 ; RealD beta = 5.6 ;
WilsonGaugeActionR Waction(beta); WilsonGaugeActionR Waction(beta);
@ -115,10 +88,6 @@ int main(int argc, char **argv) {
TheHMC.MDparameters.MDsteps = 20; TheHMC.MDparameters.MDsteps = 20;
TheHMC.MDparameters.trajL = 1.0; TheHMC.MDparameters.trajL = 1.0;
// eventually smearing here
// ...
////////////////////////////////////////////////////////////////
TheHMC.ReadCommandLine(argc, argv); // these must be parameters from file TheHMC.ReadCommandLine(argc, argv); // these must be parameters from file
TheHMC.Run(); // no smearing TheHMC.Run(); // no smearing