portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2024-09-20 09:15:38 +01:00
Code Releases Activity

Hadrons: modules remember their factory registration name

Browse Source
This commit is contained in:
Antonin Portelli 2016-12-14 17:59:45 +00:00
parent 013e710c7d
commit 3af663e17b
17 changed files with 87 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
extras/Hadrons/Module.cc
View File

@ -51,6 +51,13 @@ Environment & ModuleBase::env(void) const
return env_;
}
// get factory registration name if available
std::string ModuleBase::getRegisteredName(void)
{
HADRON_ERROR("module '" + getName() + "' has a type not registered"
+ " in the factory");
}
// execution ///////////////////////////////////////////////////////////////////
void ModuleBase::operator()(void)
{

28
extras/Hadrons/Module.hpp
View File

@ -34,7 +34,17 @@ directory.
BEGIN_HADRONS_NAMESPACE
// module registration macros
#define MODULE_REGISTER(mod)\
#define MODULE_REGISTER(mod, base)\
class mod: public base\
{\
public:\
typedef base Base;\
using Base::Base;\
virtual std::string getRegisteredName(void)\
{\
return std::string(#mod);\
}\
};\
class mod##ModuleRegistrar\
{\
public:\
@ -49,7 +59,17 @@ public:\
};\
static mod##ModuleRegistrar mod##ModuleRegistrarInstance;
#define MODULE_REGISTER_NS(mod, ns)\
#define MODULE_REGISTER_NS(mod, base, ns)\
class mod: public base\
{\
public:\
typedef base Base;\
using Base::Base;\
virtual std::string getRegisteredName(void)\
{\
return std::string(#ns "::" #mod);\
}\
};\
class ns##mod##ModuleRegistrar\
{\
public:\
@ -64,6 +84,8 @@ public:\
};\
static ns##mod##ModuleRegistrar ns##mod##ModuleRegistrarInstance;
#define ARG(...) __VA_ARGS__
/******************************************************************************
* Module class *
******************************************************************************/
@ -78,6 +100,8 @@ public:
// access
std::string getName(void) const;
Environment &env(void) const;
// get factory registration name if available
virtual std::string getRegisteredName(void);
// dependencies/products
virtual std::vector<std::string> getInput(void) = 0;
virtual std::vector<std::string> getOutput(void) = 0;

12
extras/Hadrons/Modules/MAction/DWF.hpp
View File

@ -68,6 +68,8 @@ public:
virtual void execute(void);
};
MODULE_REGISTER_NS(DWF, TDWF<FIMPL>, MAction);
/******************************************************************************
* DWF template implementation *
******************************************************************************/
@ -109,9 +111,9 @@ template <typename FImpl>
void TDWF<FImpl>::execute(void)
{
LOG(Message) << "Setting up domain wall fermion matrix with m= "
<< par().mass << ", M5= " << par().M5 << " and Ls= "
<< par().Ls << " using gauge field '" << par().gauge << "'"
<< std::endl;
<< par().mass << ", M5= " << par().M5 << " and Ls= "
<< par().Ls << " using gauge field '" << par().gauge << "'"
<< std::endl;
env().createGrid(par().Ls);
auto &U = *env().template getObject<LatticeGaugeField>(par().gauge);
auto &g4 = *env().getGrid();
@ -123,12 +125,8 @@ void TDWF<FImpl>::execute(void)
env().setObject(getName(), fMatPt);
}
typedef TDWF<FIMPL> DWF;
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(DWF, MAction);
END_HADRONS_NAMESPACE
#endif // Hadrons_DWF_hpp_

8
extras/Hadrons/Modules/MAction/Wilson.hpp
View File

@ -66,6 +66,8 @@ public:
virtual void execute(void);
};
MODULE_REGISTER_NS(Wilson, TWilson<FIMPL>, MAction);
/******************************************************************************
* TWilson template implementation *
******************************************************************************/
@ -98,7 +100,7 @@ void TWilson<FImpl>::setup(void)
{
unsigned int size;
size = 3*env().template lattice4dSize<typename FImpl::DoubledGaugeField>();
size = 2*env().template lattice4dSize<typename FImpl::DoubledGaugeField>();
env().registerObject(getName(), size);
}
@ -115,12 +117,8 @@ void TWilson<FImpl>::execute()
env().setObject(getName(), fMatPt);
}
typedef TWilson<FIMPL> Wilson;
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Wilson, MAction);
END_HADRONS_NAMESPACE
#endif // Hadrons_Wilson_hpp_

4
extras/Hadrons/Modules/MContraction/Baryon.hpp
View File

@ -47,7 +47,7 @@ public:
virtual void execute(void);
};
typedef TBaryon<FIMPL, FIMPL, FIMPL> Baryon;
MODULE_REGISTER_NS(Baryon, ARG(TBaryon<FIMPL, FIMPL, FIMPL>), MContraction);
/******************************************************************************
* TBaryon implementation *
@ -97,8 +97,6 @@ void TBaryon<FImpl1, FImpl2, FImpl3>::execute(void)
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Baryon, MContraction);
END_HADRONS_NAMESPACE
#endif // Hadrons_Baryon_hpp_

6
extras/Hadrons/Modules/MContraction/Meson.hpp
View File

@ -72,6 +72,8 @@ public:
virtual void execute(void);
};
MODULE_REGISTER_NS(Meson, ARG(TMeson<FIMPL, FIMPL>), MContraction);
/******************************************************************************
* TMeson implementation *
******************************************************************************/
@ -137,12 +139,8 @@ void TMeson<FImpl1, FImpl2>::execute(void)
write(writer, "meson", result);
}
typedef TMeson<FIMPL, FIMPL> Meson;
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Meson, MContraction);
END_HADRONS_NAMESPACE
#endif // Hadrons_Meson_hpp_

12
extras/Hadrons/Modules/MGauge/Load.cc
View File

@ -32,22 +32,22 @@ using namespace Hadrons;
using namespace MGauge;
/******************************************************************************
* Load implementation *
* TLoad implementation *
******************************************************************************/
// constructor /////////////////////////////////////////////////////////////////
Load::Load(const std::string name)
TLoad::TLoad(const std::string name)
: Module<LoadPar>(name)
{}
// dependencies/products ///////////////////////////////////////////////////////
std::vector<std::string> Load::getInput(void)
std::vector<std::string> TLoad::getInput(void)
{
std::vector<std::string> in;
return in;
}
std::vector<std::string> Load::getOutput(void)
std::vector<std::string> TLoad::getOutput(void)
{
std::vector<std::string> out = {getName()};
@ -55,13 +55,13 @@ std::vector<std::string> Load::getOutput(void)
}
// setup ///////////////////////////////////////////////////////////////////////
void Load::setup(void)
void TLoad::setup(void)
{
env().registerLattice<LatticeGaugeField>(getName());
}
// execution ///////////////////////////////////////////////////////////////////
void Load::execute(void)
void TLoad::execute(void)
{
NerscField header;
std::string fileName = par().file + "."

10
extras/Hadrons/Modules/MGauge/Load.hpp
View File

@ -46,13 +46,13 @@ public:
std::string, file);
};
class Load: public Module<LoadPar>
class TLoad: public Module<LoadPar>
{
public:
// constructor
Load(const std::string name);
TLoad(const std::string name);
// destructor
virtual ~Load(void) = default;
virtual ~TLoad(void) = default;
// dependency relation
virtual std::vector<std::string> getInput(void);
virtual std::vector<std::string> getOutput(void);
@ -62,9 +62,9 @@ public:
virtual void execute(void);
};
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Load, TLoad, MGauge);
MODULE_REGISTER_NS(Load, MGauge);
END_MODULE_NAMESPACE
END_HADRONS_NAMESPACE

12
extras/Hadrons/Modules/MGauge/Random.cc
View File

@ -32,20 +32,20 @@ using namespace Hadrons;
using namespace MGauge;
/******************************************************************************
* Random implementation *
* TRandom implementation *
******************************************************************************/
// constructor /////////////////////////////////////////////////////////////////
Random::Random(const std::string name)
TRandom::TRandom(const std::string name)
: Module<NoPar>(name)
{}
// dependencies/products ///////////////////////////////////////////////////////
std::vector<std::string> Random::getInput(void)
std::vector<std::string> TRandom::getInput(void)
{
return std::vector<std::string>();
}
std::vector<std::string> Random::getOutput(void)
std::vector<std::string> TRandom::getOutput(void)
{
std::vector<std::string> out = {getName()};
@ -53,13 +53,13 @@ std::vector<std::string> Random::getOutput(void)
}
// setup ///////////////////////////////////////////////////////////////////////
void Random::setup(void)
void TRandom::setup(void)
{
env().registerLattice<LatticeGaugeField>(getName());
}
// execution ///////////////////////////////////////////////////////////////////
void Random::execute(void)
void TRandom::execute(void)
{
LOG(Message) << "Generating random gauge configuration" << std::endl;
LatticeGaugeField &U = *env().createLattice<LatticeGaugeField>(getName());

10
extras/Hadrons/Modules/MGauge/Random.hpp
View File

@ -39,13 +39,13 @@ BEGIN_HADRONS_NAMESPACE
******************************************************************************/
BEGIN_MODULE_NAMESPACE(MGauge)
class Random: public Module<NoPar>
class TRandom: public Module<NoPar>
{
public:
// constructor
Random(const std::string name);
TRandom(const std::string name);
// destructor
virtual ~Random(void) = default;
virtual ~TRandom(void) = default;
// dependency relation
virtual std::vector<std::string> getInput(void);
virtual std::vector<std::string> getOutput(void);
@ -55,9 +55,9 @@ public:
virtual void execute(void);
};
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Random, TRandom, MGauge);
MODULE_REGISTER_NS(Random, MGauge);
END_MODULE_NAMESPACE
END_HADRONS_NAMESPACE

12
extras/Hadrons/Modules/MGauge/Unit.cc
View File

@ -32,20 +32,20 @@ using namespace Hadrons;
using namespace MGauge;
/******************************************************************************
* Unit implementation *
* TUnit implementation *
******************************************************************************/
// constructor /////////////////////////////////////////////////////////////////
Unit::Unit(const std::string name)
TUnit::TUnit(const std::string name)
: Module<NoPar>(name)
{}
// dependencies/products ///////////////////////////////////////////////////////
std::vector<std::string> Unit::getInput(void)
std::vector<std::string> TUnit::getInput(void)
{
return std::vector<std::string>();
}
std::vector<std::string> Unit::getOutput(void)
std::vector<std::string> TUnit::getOutput(void)
{
std::vector<std::string> out = {getName()};
@ -53,13 +53,13 @@ std::vector<std::string> Unit::getOutput(void)
}
// setup ///////////////////////////////////////////////////////////////////////
void Unit::setup(void)
void TUnit::setup(void)
{
env().registerLattice<LatticeGaugeField>(getName());
}
// execution ///////////////////////////////////////////////////////////////////
void Unit::execute(void)
void TUnit::execute(void)
{
LOG(Message) << "Creating unit gauge configuration" << std::endl;
LatticeGaugeField &U = *env().createLattice<LatticeGaugeField>(getName());

10
extras/Hadrons/Modules/MGauge/Unit.hpp
View File

@ -39,13 +39,13 @@ BEGIN_HADRONS_NAMESPACE
******************************************************************************/
BEGIN_MODULE_NAMESPACE(MGauge)
class Unit: public Module<NoPar>
class TUnit: public Module<NoPar>
{
public:
// constructor
Unit(const std::string name);
TUnit(const std::string name);
// destructor
virtual ~Unit(void) = default;
virtual ~TUnit(void) = default;
// dependencies/products
virtual std::vector<std::string> getInput(void);
virtual std::vector<std::string> getOutput(void);
@ -55,9 +55,9 @@ public:
virtual void execute(void);
};
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Unit, TUnit, MGauge);
MODULE_REGISTER_NS(Unit, MGauge);
END_MODULE_NAMESPACE
END_HADRONS_NAMESPACE

6
extras/Hadrons/Modules/MSolver/RBPrecCG.hpp
View File

@ -66,6 +66,8 @@ public:
virtual void execute(void);
};
MODULE_REGISTER_NS(RBPrecCG, TRBPrecCG<FIMPL>, MSolver);
/******************************************************************************
* TRBPrecCG template implementation *
******************************************************************************/
@ -121,12 +123,8 @@ void TRBPrecCG<FImpl>::execute(void)
env().setObject(getName(), new SolverFn(solver));
}
typedef TRBPrecCG<FIMPL> RBPrecCG;
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(RBPrecCG, MSolver);
END_HADRONS_NAMESPACE
#endif // Hadrons_RBPrecCG_hpp_

6
extras/Hadrons/Modules/MSource/Point.hpp
View File

@ -76,6 +76,8 @@ public:
virtual void execute(void);
};
MODULE_REGISTER_NS(Point, TPoint<FIMPL>, MSource);
/******************************************************************************
* TPoint template implementation *
******************************************************************************/
@ -124,12 +126,8 @@ void TPoint<FImpl>::execute(void)
pokeSite(id, src, position);
}
typedef TPoint<FIMPL> Point;
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Point, MSource);
END_HADRONS_NAMESPACE
#endif // Hadrons_Point_hpp_

6
extras/Hadrons/Modules/MSource/SeqGamma.hpp
View File

@ -57,10 +57,10 @@ public:
virtual void execute(void);
};
typedef TSeqGamma<FIMPL> SeqGamma;
MODULE_REGISTER_NS(SeqGamma, TSeqGamma<FIMPL>, MSource);
/******************************************************************************
* TSeqGamma implementation *
* TSeqGamma implementation *
******************************************************************************/
// constructor /////////////////////////////////////////////////////////////////
template <typename FImpl>
@ -130,8 +130,6 @@ void TSeqGamma<FImpl>::execute(void)
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(SeqGamma, MSource);
END_HADRONS_NAMESPACE
#endif // Hadrons_SeqGamma_hpp_

6
extras/Hadrons/Modules/MSource/Z2.hpp
View File

@ -80,6 +80,8 @@ public:
virtual void execute(void);
};
MODULE_REGISTER_NS(Z2, TZ2<FIMPL>, MSource);
/******************************************************************************
* TZ2 template implementation *
******************************************************************************/
@ -140,12 +142,8 @@ void TZ2<FImpl>::execute(void)
src = src*eta;
}
typedef TZ2<FIMPL> Z2;
END_MODULE_NAMESPACE
MODULE_REGISTER_NS(Z2, MSource);
END_HADRONS_NAMESPACE
#endif // Hadrons_Z2_hpp_

6
extras/Hadrons/Modules/Quark.hpp
View File

@ -67,6 +67,8 @@ private:
SolverFn *solver_{nullptr};
};
MODULE_REGISTER(Quark, TQuark<FIMPL>);
/******************************************************************************
* TQuark implementation *
******************************************************************************/
@ -176,10 +178,6 @@ void TQuark<FImpl>::execute(void)
}
}
typedef TQuark<FIMPL> Quark;
MODULE_REGISTER(Quark);
END_HADRONS_NAMESPACE
#endif // Hadrons_Quark_hpp_