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

added DistilPar-module and cleaned up some code

Browse Source
This commit is contained in:
ferben 2019-11-11 17:29:55 +00:00
parent 7a446d5b7f
commit df586a142d
11 changed files with 302 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Hadrons/Modules.hpp
View File

@ -70,6 +70,7 @@
#include <Hadrons/Modules/MDistil/Noises.hpp> #include <Hadrons/Modules/MDistil/Noises.hpp>
#include <Hadrons/Modules/MDistil/LapEvec.hpp> #include <Hadrons/Modules/MDistil/LapEvec.hpp>
#include <Hadrons/Modules/MDistil/Perambulator.hpp> #include <Hadrons/Modules/MDistil/Perambulator.hpp>
#include <Hadrons/Modules/MDistil/DistilPar.hpp>
#include <Hadrons/Modules/MDistil/DistilCommon.hpp> #include <Hadrons/Modules/MDistil/DistilCommon.hpp>
#include <Hadrons/Modules/MAction/ZMobiusDWF.hpp> #include <Hadrons/Modules/MAction/ZMobiusDWF.hpp>
#include <Hadrons/Modules/MAction/ScaledDWF.hpp> #include <Hadrons/Modules/MAction/ScaledDWF.hpp>

36
Hadrons/Modules/MDistil/DistilCommon.hpp
View File

@ -63,42 +63,14 @@ BEGIN_MODULE_NAMESPACE(MDistil)
struct DistilParameters: Serializable { struct DistilParameters: Serializable {
GRID_SERIALIZABLE_CLASS_MEMBERS(DistilParameters, GRID_SERIALIZABLE_CLASS_MEMBERS(DistilParameters,
int, nvec,
int, nnoise, int, nnoise,
int, tsrc, int, tsrc,
std::string, TI, int, TI,
std::string, LI, int, LI,
std::string, SI ) int, SI )
DistilParameters() = default;
template <class ReaderClass> DistilParameters(Reader<ReaderClass>& Reader){read(Reader,"Distil",*this);}
// Numeric parameter is allowed to be empty (in which case it = Default),
// but assert during setup() if specified but not numeric
static int ParameterDefault( const std::string & s, int Default, bool bCalledFromSetup )
{
int i = Default;
if( s.length() > 0 ) {
std::istringstream ss( s );
ss >> i;
if( bCalledFromSetup )
assert( !ss.fail() && "Parameter should either be empty or integer" );
}
return i;
}
}; };
#define DISTIL_PARAMETERS_DEFINE( inSetup ) \
const int Nt{env().getDim(Tdir)}; \
const int nvec{par().nvec}; \
const int nnoise{par().Distil.nnoise}; \
const int tsrc{par().Distil.tsrc}; \
const int TI{Hadrons::MDistil::DistilParameters::ParameterDefault(par().Distil.TI, Nt, inSetup)}; \
const int LI{Hadrons::MDistil::DistilParameters::ParameterDefault(par().Distil.LI, nvec, inSetup)}; \
const int SI{Hadrons::MDistil::DistilParameters::ParameterDefault(par().Distil.SI, Ns, inSetup)}; \
const bool full_tdil{ TI == Nt }; \
const bool exact_distillation{ full_tdil && LI == nvec }; \
const int Nt_inv{ full_tdil ? 1 : TI }
/****************************************************************************** /******************************************************************************
Make a lower dimensional grid in preparation for local slice operations Make a lower dimensional grid in preparation for local slice operations
******************************************************************************/ ******************************************************************************/

7
Hadrons/Modules/MDistil/DistilPar.cc Normal file
View File

@ -0,0 +1,7 @@
#include <Hadrons/Modules/MDistil/DistilPar.hpp>
using namespace Grid;
using namespace Hadrons;
using namespace MDistil;
template class Grid::Hadrons::MDistil::TDistilPar<FIMPL>;

96
Hadrons/Modules/MDistil/DistilPar.hpp Normal file
View File

@ -0,0 +1,96 @@
#ifndef Hadrons_MDistil_DistilPar_hpp_
#define Hadrons_MDistil_DistilPar_hpp_
#include <Hadrons/Global.hpp>
#include <Hadrons/Module.hpp>
#include <Hadrons/ModuleFactory.hpp>
#include <Hadrons/Modules/MDistil/DistilCommon.hpp>
BEGIN_HADRONS_NAMESPACE
/******************************************************************************
* DistilPar *
******************************************************************************/
BEGIN_MODULE_NAMESPACE(MDistil)
class DistilParPar: Serializable
{
public:
GRID_SERIALIZABLE_CLASS_MEMBERS(DistilParPar,
int, nnoise,
int, tsrc,
int, TI,
int, LI,
int, SI );
};
template <typename FImpl>
class TDistilPar: public Module<DistilParPar>
{
public:
// constructor
TDistilPar(const std::string name);
// destructor
virtual ~TDistilPar(void) {};
// dependency relation
virtual std::vector<std::string> getInput(void);
virtual std::vector<std::string> getOutput(void);
// setup
virtual void setup(void);
// execution
virtual void execute(void);
};
MODULE_REGISTER_TMP(DistilPar, TDistilPar<FIMPL>, MDistil);
/******************************************************************************
* TDistilPar implementation *
******************************************************************************/
// constructor /////////////////////////////////////////////////////////////////
template <typename FImpl>
TDistilPar<FImpl>::TDistilPar(const std::string name)
: Module<DistilParPar>(name)
{}
// dependencies/products ///////////////////////////////////////////////////////
template <typename FImpl>
std::vector<std::string> TDistilPar<FImpl>::getInput(void)
{
std::vector<std::string> in;
return in;
}
template <typename FImpl>
std::vector<std::string> TDistilPar<FImpl>::getOutput(void)
{
std::vector<std::string> out = {getName()};
return out;
}
// setup ///////////////////////////////////////////////////////////////////////
template <typename FImpl>
void TDistilPar<FImpl>::setup(void)
{
}
// execution ///////////////////////////////////////////////////////////////////
template <typename FImpl>
void TDistilPar<FImpl>::execute(void)
{
Hadrons::MDistil::DistilParameters &out = envGet(Hadrons::MDistil::DistilParameters, getName());
out.nnoise=par().nnoise;
out.tsrc=par().tsrc;
out.TI=par().TI;
out.LI=par().LI;
out.SI=par().SI;
}
END_MODULE_NAMESPACE
END_HADRONS_NAMESPACE
#endif // Hadrons_MDistil_DistilPar_hpp_

138
Hadrons/Modules/MDistil/DistilVectors.hpp
View File

@ -47,11 +47,9 @@ public:
std::string, noise, std::string, noise,
std::string, perambulator, std::string, perambulator,
std::string, lapevec, std::string, lapevec,
std::string, source, std::string, rho,
std::string, sink, std::string, phi,
int, tsrc, MDistil::DistilParameters, DistilPar);
std::string, nvec,
std::string, TI)
}; };
template <typename FImpl> template <typename FImpl>
@ -80,10 +78,10 @@ public:
std::string PerambulatorName; std::string PerambulatorName;
std::string NoiseVectorName; std::string NoiseVectorName;
std::string LapEvecName; std::string LapEvecName;
bool bMakeSource; bool bMakeRho;
bool bMakeSink; bool bMakePhi;
std::string SourceName; std::string RhoName;
std::string SinkName; std::string PhiName;
}; };
MODULE_REGISTER_TMP(DistilVectors, TDistilVectors<FIMPL>, MDistil); MODULE_REGISTER_TMP(DistilVectors, TDistilVectors<FIMPL>, MDistil);
@ -131,24 +129,24 @@ std::vector<std::string> TDistilVectors<FImpl>::getInput(void)
template <typename FImpl> template <typename FImpl>
std::vector<std::string> TDistilVectors<FImpl>::getOutput(void) std::vector<std::string> TDistilVectors<FImpl>::getOutput(void)
{ {
SourceName = par().source; RhoName = par().rho;
SinkName = par().sink; PhiName = par().phi;
bMakeSource = ( SourceName.size() > 0 ); bMakeRho = ( RhoName.size() > 0 );
bMakeSink = ( SinkName.size() > 0 ); bMakePhi = ( PhiName.size() > 0 );
if (!bMakeSource && !bMakeSink) if (!bMakeRho && !bMakePhi)
{ {
SourceName = getName(); RhoName = getName();
SinkName = SourceName; PhiName = RhoName;
SourceName.append("_rho"); RhoName.append("_rho");
SinkName.append("_phi"); PhiName.append("_phi");
bMakeSource = true; bMakeRho = true;
bMakeSink = true; bMakePhi = true;
} }
std::vector<std::string> out; std::vector<std::string> out;
if (bMakeSource) if (bMakeRho)
out.push_back(SourceName); out.push_back(RhoName);
if (bMakeSink) if (bMakePhi)
out.push_back(SinkName); out.push_back(PhiName);
return out; return out;
} }
@ -157,28 +155,25 @@ template <typename FImpl>
void TDistilVectors<FImpl>::setup(void) void TDistilVectors<FImpl>::setup(void)
{ {
Cleanup(); Cleanup();
auto &noise = envGet(NoiseTensor, NoiseVectorName); auto &noise = envGet(NoiseTensor, NoiseVectorName);
auto &perambulator = envGet(PerambTensor, PerambulatorName); auto &perambulator = envGet(PerambTensor, PerambulatorName);
// We expect the perambulator to have been created with these indices // We expect the perambulator to have been created with these indices
assert( perambulator.ValidateIndexNames() && "Perambulator index names bad" ); assert( perambulator.ValidateIndexNames() && "Perambulator index names bad" );
const int Nt{ env().getDim(Tdir) }; const int Nt{env().getDim(Tdir)};
assert( Nt == static_cast<int>( perambulator.tensor.dimension(0) ) && "PerambTensor time dimensionality bad" ); const int nvec{par().DistilPar.nvec};
const int LI{ static_cast<int>( perambulator.tensor.dimension(2) ) }; const int nnoise{par().DistilPar.nnoise};
const int SI{ static_cast<int>( perambulator.tensor.dimension(5) ) }; const int TI{par().DistilPar.TI};
const int Nt_inv{ static_cast<int>( perambulator.tensor.dimension(4) ) }; const int LI{par().DistilPar.LI};
const int nnoise{ static_cast<int>( perambulator.tensor.dimension(3) ) }; const int SI{par().DistilPar.SI};
assert( nnoise >= static_cast<int>( noise.tensor.dimension(0) ) && "Not enough noise vectors for perambulator" ); const bool full_tdil{ TI == Nt };
// Nvec defaults to what's in the perambulator unless overriden const int Nt_inv{ full_tdil ? 1 : TI };
const int nvec_per{ static_cast<int>( perambulator.tensor.dimension(1) ) };
const int nvec{Hadrons::MDistil::DistilParameters::ParameterDefault(par().nvec, nvec_per, true) };
assert( nvec <= nvec_per && "Not enough distillation sub-space vectors" );
if (bMakeSource) if (bMakeRho)
envCreate(std::vector<FermionField>, SourceName, 1, nnoise*LI*SI*Nt_inv, envGetGrid(FermionField)); envCreate(std::vector<FermionField>, RhoName, 1, nnoise*LI*SI*Nt_inv, envGetGrid(FermionField));
if (bMakeSink) if (bMakePhi)
envCreate(std::vector<FermionField>, SinkName, 1, nnoise*LI*SI*Nt_inv, envGetGrid(FermionField)); envCreate(std::vector<FermionField>, PhiName, 1, nnoise*LI*SI*Nt_inv, envGetGrid(FermionField));
grid4d = env().getGrid(); grid4d = env().getGrid();
Coordinate latt_size = GridDefaultLatt(); Coordinate latt_size = GridDefaultLatt();
@ -189,10 +184,10 @@ void TDistilVectors<FImpl>::setup(void)
mpi_layout[Nd-1] = 1; mpi_layout[Nd-1] = 1;
grid3d = MakeLowerDimGrid(grid4d); grid3d = MakeLowerDimGrid(grid4d);
envTmp(LatticeSpinColourVector, "tmp2",1,LatticeSpinColourVector(grid4d)); envTmp(LatticeSpinColourVector, "source4d",1,LatticeSpinColourVector(grid4d));
envTmp(LatticeSpinColourVector, "tmp3d",1,LatticeSpinColourVector(grid3d)); envTmp(LatticeSpinColourVector, "source3d",1,LatticeSpinColourVector(grid3d));
envTmp(LatticeColourVector, "tmp3d_nospin",1,LatticeColourVector(grid3d)); envTmp(LatticeColourVector, "source3d_nospin",1,LatticeColourVector(grid3d));
envTmp(LatticeSpinColourVector, "sink_tslice",1,LatticeSpinColourVector(grid3d)); envTmp(LatticeSpinColourVector, "sink3d",1,LatticeSpinColourVector(grid3d));
envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d)); envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d));
} }
@ -216,50 +211,49 @@ void TDistilVectors<FImpl>::execute(void)
auto &perambulator = envGet(PerambTensor, PerambulatorName); auto &perambulator = envGet(PerambTensor, PerambulatorName);
auto &epack = envGet(Grid::Hadrons::EigenPack<LatticeColourVector>, LapEvecName); auto &epack = envGet(Grid::Hadrons::EigenPack<LatticeColourVector>, LapEvecName);
envGetTmp(LatticeSpinColourVector, tmp2); envGetTmp(LatticeSpinColourVector, source4d);
envGetTmp(LatticeSpinColourVector, tmp3d); envGetTmp(LatticeSpinColourVector, source3d);
envGetTmp(LatticeColourVector, tmp3d_nospin); envGetTmp(LatticeColourVector, source3d_nospin);
envGetTmp(LatticeSpinColourVector, sink_tslice); envGetTmp(LatticeSpinColourVector, sink3d);
envGetTmp(LatticeColourVector, evec3d); envGetTmp(LatticeColourVector, evec3d);
const int Ntlocal{ grid4d->LocalDimensions()[3] }; const int Ntlocal{ grid4d->LocalDimensions()[3] };
const int Ntfirst{ grid4d->LocalStarts()[3] }; const int Ntfirst{ grid4d->LocalStarts()[3] };
const int Nt{ env().getDim(Tdir) }; const int Nt{env().getDim(Tdir)};
const int TI{ Hadrons::MDistil::DistilParameters::ParameterDefault( par().TI, Nt, false ) }; const int nvec{par().DistilPar.nvec};
const int LI{ static_cast<int>( perambulator.tensor.dimension(2) ) }; const int nnoise{par().DistilPar.nnoise};
const int SI{ static_cast<int>( perambulator.tensor.dimension(5) ) }; const int tsrc{par().DistilPar.tsrc};
const int Nt_inv{ static_cast<int>( perambulator.tensor.dimension(4) ) }; const int TI{par().DistilPar.TI};
const int nnoise{ static_cast<int>( perambulator.tensor.dimension(3) ) }; const int LI{par().DistilPar.LI};
// Nvec defaults to what's in the perambulator unless overriden const int SI{par().DistilPar.SI};
const int nvec{Hadrons::MDistil::DistilParameters::ParameterDefault(par().nvec, static_cast<int>( perambulator.tensor.dimension(1) ), false)}; const bool full_tdil{ TI == Nt };
const int tsrc{ par().tsrc }; const int Nt_inv{ full_tdil ? 1 : TI };
const bool full_tdil{ TI==Nt };
int vecindex; int vecindex;
int t_inv; int t_inv;
if (bMakeSource) if (bMakeRho)
{ {
auto &rho = envGet(std::vector<FermionField>, SourceName); auto &rho = envGet(std::vector<FermionField>, RhoName);
for (int inoise = 0; inoise < nnoise; inoise++) { for (int inoise = 0; inoise < nnoise; inoise++) {
for (int dk = 0; dk < LI; dk++) { for (int dk = 0; dk < LI; dk++) {
for (int dt = 0; dt < Nt_inv; dt++) { for (int dt = 0; dt < Nt_inv; dt++) {
for (int ds = 0; ds < SI; ds++) { for (int ds = 0; ds < SI; ds++) {
vecindex = inoise + nnoise * dk + nnoise * LI * ds + nnoise *LI * SI*dt; vecindex = inoise + nnoise * dk + nnoise * LI * ds + nnoise *LI * SI*dt;
rho[vecindex] = 0; rho[vecindex] = 0;
tmp3d_nospin = 0; source3d_nospin = 0;
for (int it = dt; it < Nt; it += TI){ for (int it = dt; it < Nt; it += TI){
if (full_tdil) t_inv = tsrc; else t_inv = it; if (full_tdil) t_inv = tsrc; else t_inv = it;
if (t_inv >= Ntfirst && t_inv < Ntfirst + Ntlocal) { if (t_inv >= Ntfirst && t_inv < Ntfirst + Ntlocal) {
for (int ik = dk; ik < nvec; ik += LI){ for (int ik = dk; ik < nvec; ik += LI){
for (int is = ds; is < Ns; is += SI){ for (int is = ds; is < Ns; is += SI){
ExtractSliceLocal(evec3d,epack.evec[ik],0,t_inv-Ntfirst,Tdir); ExtractSliceLocal(evec3d,epack.evec[ik],0,t_inv-Ntfirst,Tdir);
tmp3d_nospin = evec3d * noise.tensor(inoise, t_inv, ik, is); source3d_nospin = evec3d * noise.tensor(inoise, t_inv, ik, is);
tmp3d=0; source3d=0;
pokeSpin(tmp3d,tmp3d_nospin,is); pokeSpin(source3d,source3d_nospin,is);
tmp2=0; source4d=0;
InsertSliceLocal(tmp3d,tmp2,0,t_inv-Ntfirst,Tdir); InsertSliceLocal(source3d,source4d,0,t_inv-Ntfirst,Tdir);
rho[vecindex] += tmp2; rho[vecindex] += source4d;
} }
} }
} }
@ -269,8 +263,8 @@ void TDistilVectors<FImpl>::execute(void)
} }
} }
} }
if (bMakeSink) { if (bMakePhi) {
auto &phi = envGet(std::vector<FermionField>, SinkName); auto &phi = envGet(std::vector<FermionField>, PhiName);
for (int inoise = 0; inoise < nnoise; inoise++) { for (int inoise = 0; inoise < nnoise; inoise++) {
for (int dk = 0; dk < LI; dk++) { for (int dk = 0; dk < LI; dk++) {
for (int dt = 0; dt < Nt_inv; dt++) { for (int dt = 0; dt < Nt_inv; dt++) {
@ -278,12 +272,12 @@ void TDistilVectors<FImpl>::execute(void)
vecindex = inoise + nnoise * dk + nnoise * LI * ds + nnoise *LI * SI*dt; vecindex = inoise + nnoise * dk + nnoise * LI * ds + nnoise *LI * SI*dt;
phi[vecindex] = 0; phi[vecindex] = 0;
for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++) { for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++) {
sink_tslice=0; sink3d=0;
for (int ivec = 0; ivec < nvec; ivec++) { for (int ivec = 0; ivec < nvec; ivec++) {
ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir); ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir);
sink_tslice += evec3d * perambulator.tensor(t, ivec, dk, inoise,dt,ds); sink3d += evec3d * perambulator.tensor(t, ivec, dk, inoise,dt,ds);
} }
InsertSliceLocal(sink_tslice,phi[vecindex],0,t-Ntfirst,Tdir); InsertSliceLocal(sink3d,phi[vecindex],0,t-Ntfirst,Tdir);
} }
} }
} }

23
Hadrons/Modules/MDistil/Noises.hpp
View File

@ -43,10 +43,7 @@ class NoisesPar: Serializable
{ {
public: public:
GRID_SERIALIZABLE_CLASS_MEMBERS(NoisesPar, GRID_SERIALIZABLE_CLASS_MEMBERS(NoisesPar,
int, nnoise, MDistil::DistilParameters, DistilPar,
int, nvec,
std::string, TI,
std::string, LI,
std::string, NoiseFileName) std::string, NoiseFileName)
}; };
@ -96,9 +93,9 @@ std::vector<std::string> TNoises<FImpl>::getOutput(void)
template <typename FImpl> template <typename FImpl>
void TNoises<FImpl>::setup(void) void TNoises<FImpl>::setup(void)
{ {
const int Nt{env().getDim(Tdir)}; const int Nt{env().getDim(Tdir)};
const int nnoise{par().nnoise}; const int nvec{par().DistilPar.nvec};
const int nvec{par().nvec}; const int nnoise{par().DistilPar.nnoise};
envCreate(NoiseTensor, getName(), 1, nnoise, Nt, nvec, Ns); envCreate(NoiseTensor, getName(), 1, nnoise, Nt, nvec, Ns);
} }
@ -107,12 +104,12 @@ template <typename FImpl>
void TNoises<FImpl>::execute(void) void TNoises<FImpl>::execute(void)
{ {
const int Nt{env().getDim(Tdir)}; const int Nt{env().getDim(Tdir)};
const int nnoise{par().nnoise}; const int nnoise{par().DistilPar.nnoise};
const int nvec{par().nvec}; const int nvec{par().DistilPar.nvec};
const int TI{ Hadrons::MDistil::DistilParameters::ParameterDefault( par().TI, Nt, false) }; const int TI{par().DistilPar.TI};
const int LI{ Hadrons::MDistil::DistilParameters::ParameterDefault( par().LI, nvec, false) }; const int LI{par().DistilPar.LI};
const bool full_tdil{ TI == Nt }; \ const bool full_tdil{ TI == Nt };
const bool exact_distillation{ full_tdil && LI == nvec }; \ const bool exact_distillation{ full_tdil && LI == nvec };
// We use our own seeds so we can specify different noises per quark // We use our own seeds so we can specify different noises per quark
Real rn; Real rn;

72
Hadrons/Modules/MDistil/PerambFromSolve.hpp
View File

@ -51,10 +51,9 @@ public:
std::string, eigenPack, std::string, eigenPack,
std::string, PerambFileName, std::string, PerambFileName,
std::string, solve, std::string, solve,
int, nvec,
std::string, nvec_reduced, std::string, nvec_reduced,
std::string, LI_reduced, std::string, LI_reduced,
DistilParameters, Distil); MDistil::DistilParameters, DistilPar);
}; };
template <typename FImpl> template <typename FImpl>
@ -116,16 +115,23 @@ template <typename FImpl>
void TPerambFromSolve<FImpl>::setup(void) void TPerambFromSolve<FImpl>::setup(void)
{ {
Cleanup(); Cleanup();
DISTIL_PARAMETERS_DEFINE( true ); const int Nt{env().getDim(Tdir)};
const int nvec_reduced{ Hadrons::MDistil::DistilParameters::ParameterDefault( par().nvec_reduced, nvec, true) }; const int nvec{par().DistilPar.nvec};
const int LI_reduced{ Hadrons::MDistil::DistilParameters::ParameterDefault( par().LI_reduced, LI, true) }; const int nnoise{par().DistilPar.nnoise};
const int LI{par().DistilPar.LI};
const int TI{par().DistilPar.TI};
const int SI{par().DistilPar.SI};
const bool full_tdil{ TI == Nt };
const int Nt_inv{ full_tdil ? 1 : TI };
const int nvec_reduced{ par().nvec_reduced.empty() ? nvec:std::stoi(par().nvec_reduced)};
const int LI_reduced{ par().LI_reduced.empty() ? LI:std::stoi(par().LI_reduced)};
grid4d = env().getGrid(); grid4d = env().getGrid();
grid3d = MakeLowerDimGrid(grid4d); grid3d = MakeLowerDimGrid(grid4d);
envCreate(PerambTensor, getName(), 1, Nt,nvec_reduced,LI_reduced,nnoise,Nt_inv,SI); envCreate(PerambTensor, getName(), 1, Nt,nvec_reduced,LI_reduced,nnoise,Nt_inv,SI);
envCreate(NoiseTensor, getName() + "_noise", 1, nnoise, Nt, nvec, Ns ); envCreate(NoiseTensor, getName() + "_noise", 1, nnoise, Nt, nvec, Ns );
envTmp(LatticeColourVector, "result_3d",1,LatticeColourVector(grid3d)); envTmp(LatticeColourVector, "result3d_nospin",1,LatticeColourVector(grid3d));
envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d)); envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d));
envTmpLat(LatticeColourVector, "result_nospin"); envTmpLat(LatticeColourVector, "result4d_nospin");
} }
template <typename FImpl> template <typename FImpl>
@ -146,28 +152,42 @@ void TPerambFromSolve<FImpl>::execute(void)
GridCartesian * grid4d = env().getGrid(); GridCartesian * grid4d = env().getGrid();
const int Ntlocal{grid4d->LocalDimensions()[3]}; const int Ntlocal{grid4d->LocalDimensions()[3]};
const int Ntfirst{grid4d->LocalStarts()[3]}; const int Ntfirst{grid4d->LocalStarts()[3]};
DISTIL_PARAMETERS_DEFINE( false ); const int Nt{env().getDim(Tdir)};
const int nvec_reduced{ Hadrons::MDistil::DistilParameters::ParameterDefault( par().nvec_reduced, nvec, false) }; const int nvec{par().DistilPar.nvec};
const int LI_reduced{ Hadrons::MDistil::DistilParameters::ParameterDefault( par().LI_reduced, LI, false) }; const int nnoise{par().DistilPar.nnoise};
auto &perambulator = envGet(PerambTensor, getName()); const int TI{par().DistilPar.TI};
auto &solve = envGet(std::vector<FermionField>, par().solve); const int LI{par().DistilPar.LI};
auto &epack = envGet(Grid::Hadrons::EigenPack<LatticeColourVector>, par().eigenPack); const int SI{par().DistilPar.SI};
const bool full_tdil{ TI == Nt };
const int Nt_inv{ full_tdil ? 1 : TI };
const int nvec_reduced{ par().nvec_reduced.empty() ? nvec:std::stoi(par().nvec_reduced)};
const int LI_reduced{ par().LI_reduced.empty() ? LI:std::stoi(par().LI_reduced)};
auto &perambulator = envGet(PerambTensor, getName());
auto &solve = envGet(std::vector<FermionField>, par().solve);
auto &epack = envGet(Grid::Hadrons::EigenPack<LatticeColourVector>, par().eigenPack);
envGetTmp(LatticeColourVector, result_nospin); envGetTmp(LatticeColourVector, result4d_nospin);
envGetTmp(LatticeColourVector, result_3d); envGetTmp(LatticeColourVector, result3d_nospin);
envGetTmp(LatticeColourVector, evec3d); envGetTmp(LatticeColourVector, evec3d);
for (int inoise = 0; inoise < nnoise; inoise++) { for (int inoise = 0; inoise < nnoise; inoise++)
for (int dk = 0; dk < LI_reduced; dk++) { {
for (int dt = 0; dt < Nt_inv; dt++) { for (int dk = 0; dk < LI_reduced; dk++)
for (int ds = 0; ds < SI; ds++) { {
for (int is = 0; is < Ns; is++) { for (int dt = 0; dt < Nt_inv; dt++)
result_nospin = peekSpin(solve[inoise+nnoise*(dk+LI*(dt+Nt_inv*ds))],is); {
for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++) { for (int ds = 0; ds < SI; ds++)
ExtractSliceLocal(result_3d,result_nospin,0,t-Ntfirst,Tdir); {
for (int ivec = 0; ivec < nvec_reduced; ivec++) { for (int is = 0; is < Ns; is++)
{
result4d_nospin = peekSpin(solve[inoise+nnoise*(dk+LI*(dt+Nt_inv*ds))],is);
for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++)
{
ExtractSliceLocal(result3d_nospin,result4d_nospin,0,t-Ntfirst,Tdir);
for (int ivec = 0; ivec < nvec_reduced; ivec++)
{
ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir); ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir);
pokeSpin(perambulator.tensor(t, ivec, dk, inoise,dt,ds),static_cast<Complex>(innerProduct(evec3d, result_3d)),is); pokeSpin(perambulator.tensor(t, ivec, dk, inoise,dt,ds),static_cast<Complex>(innerProduct(evec3d, result3d_nospin)),is);
LOG(Message) << "perambulator(t, ivec, dk, inoise,dt,ds)(is) = (" << t << "," << ivec << "," << dk << "," << inoise << "," << dt << "," << ds << ")(" << is << ") = " << perambulator.tensor(t, ivec, dk, inoise,dt,ds)()(is)() << std::endl; LOG(Message) << "perambulator(t, ivec, dk, inoise,dt,ds)(is) = (" << t << "," << ivec << "," << dk << "," << inoise << "," << dt << "," << ds << ")(" << is << ") = " << perambulator.tensor(t, ivec, dk, inoise,dt,ds)()(is)() << std::endl;
} }
} }
@ -179,8 +199,6 @@ void TPerambFromSolve<FImpl>::execute(void)
if(grid4d->IsBoss()) if(grid4d->IsBoss())
{ {
std::string sPerambName{par().PerambFileName}; std::string sPerambName{par().PerambFileName};
if (sPerambName.empty())
sPerambName = getName();
sPerambName.append( "." ); sPerambName.append( "." );
sPerambName.append( std::to_string(vm().getTrajectory())); sPerambName.append( std::to_string(vm().getTrajectory()));
perambulator.write(sPerambName.c_str()); perambulator.write(sPerambName.c_str());

90
Hadrons/Modules/MDistil/Perambulator.hpp
View File

@ -49,8 +49,7 @@ public:
std::string, PerambFileName, std::string, PerambFileName,
std::string, UnsmearedSinkFileName, std::string, UnsmearedSinkFileName,
std::string, UnsmearedSinkMultiFile, std::string, UnsmearedSinkMultiFile,
int, nvec, MDistil::DistilParameters, DistilPar);
DistilParameters, Distil);
}; };
template <typename FImpl> template <typename FImpl>
@ -106,8 +105,6 @@ std::vector<std::string> TPerambulator<FImpl>::getInput(void)
{ {
sLapEvecName = par().lapevec; sLapEvecName = par().lapevec;
sNoiseName = par().noise; sNoiseName = par().noise;
if( sNoiseName.length() == 0 )
sNoiseName = getName() + "_noise";
return {sLapEvecName, par().solver, sNoiseName }; return {sLapEvecName, par().solver, sNoiseName };
} }
@ -124,23 +121,32 @@ void TPerambulator<FImpl>::setup(void)
Cleanup(); Cleanup();
grid4d = env().getGrid(); grid4d = env().getGrid();
grid3d = MakeLowerDimGrid(grid4d); grid3d = MakeLowerDimGrid(grid4d);
DISTIL_PARAMETERS_DEFINE( true ); const int Nt{env().getDim(Tdir)};
const int nvec{par().DistilPar.nvec};
const int nnoise{par().DistilPar.nnoise};
const int tsrc{par().DistilPar.tsrc};
const int TI{par().DistilPar.TI};
const int LI{par().DistilPar.LI};
const int SI{par().DistilPar.SI};
const bool full_tdil{ TI == Nt };
const int Nt_inv{ full_tdil ? 1 : TI };
const std::string UnsmearedSinkFileName{ par().UnsmearedSinkFileName }; const std::string UnsmearedSinkFileName{ par().UnsmearedSinkFileName };
if (!UnsmearedSinkFileName.empty()) if (!UnsmearedSinkFileName.empty())
bool bMulti = ( Hadrons::MDistil::DistilParameters::ParameterDefault( par().UnsmearedSinkMultiFile, 1, true ) != 0 ); //bool bMulti = ( Hadrons::MDistil::DistilParameters::ParameterDefault( par().UnsmearedSinkMultiFile, 1, true ) != 0 );
bool bMulti = 0;
envCreate(PerambTensor, getName(), 1, Nt,nvec,LI,nnoise,Nt_inv,SI); envCreate(PerambTensor, getName(), 1, Nt,nvec,LI,nnoise,Nt_inv,SI);
envCreate(std::vector<FermionField>, getName() + "_unsmeared_sink", 1, envCreate(std::vector<FermionField>, getName() + "_unsmeared_sink", 1,
nnoise*LI*Ns*Nt_inv, envGetGrid(FermionField)); nnoise*LI*Ns*Nt_inv, envGetGrid(FermionField));
envTmpLat(LatticeSpinColourVector, "dist_source"); envTmpLat(LatticeSpinColourVector, "dist_source");
envTmpLat(LatticeSpinColourVector, "tmp2"); envTmpLat(LatticeSpinColourVector, "source4d");
envTmpLat(LatticeSpinColourVector, "result"); envTmp(LatticeSpinColourVector, "source3d",1,LatticeSpinColourVector(grid3d));
envTmpLat(LatticeColourVector, "result_nospin"); envTmp(LatticeColourVector, "source3d_nospin",1,LatticeColourVector(grid3d));
envTmp(LatticeSpinColourVector, "tmp3d",1,LatticeSpinColourVector(grid3d)); envTmpLat(LatticeSpinColourVector, "result4d");
envTmp(LatticeColourVector, "tmp3d_nospin",1,LatticeColourVector(grid3d)); envTmpLat(LatticeColourVector, "result4d_nospin");
envTmp(LatticeColourVector, "result_3d",1,LatticeColourVector(grid3d)); envTmp(LatticeColourVector, "result3d_nospin",1,LatticeColourVector(grid3d));
envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d)); envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d));
Ls_ = env().getObjectLs(par().solver); Ls_ = env().getObjectLs(par().solver);
envTmpLat(FermionField, "v4dtmp"); envTmpLat(FermionField, "v4dtmp");
@ -164,7 +170,16 @@ void TPerambulator<FImpl>::Cleanup(void)
template <typename FImpl> template <typename FImpl>
void TPerambulator<FImpl>::execute(void) void TPerambulator<FImpl>::execute(void)
{ {
DISTIL_PARAMETERS_DEFINE( false ); const int Nt{env().getDim(Tdir)};
const int nvec{par().DistilPar.nvec};
const int nnoise{par().DistilPar.nnoise};
const int tsrc{par().DistilPar.tsrc};
const int TI{par().DistilPar.TI};
const int LI{par().DistilPar.LI};
const int SI{par().DistilPar.SI};
const bool full_tdil{ TI == Nt };
const int Nt_inv{ full_tdil ? 1 : TI };
auto &solver=envGet(Solver, par().solver); auto &solver=envGet(Solver, par().solver);
auto &mat = solver.getFMat(); auto &mat = solver.getFMat();
envGetTmp(FermionField, v4dtmp); envGetTmp(FermionField, v4dtmp);
@ -175,12 +190,12 @@ void TPerambulator<FImpl>::execute(void)
auto &epack = envGet(LapEvecs, sLapEvecName); auto &epack = envGet(LapEvecs, sLapEvecName);
auto &unsmeared_sink = envGet(std::vector<FermionField>, getName() + "_unsmeared_sink"); auto &unsmeared_sink = envGet(std::vector<FermionField>, getName() + "_unsmeared_sink");
envGetTmp(LatticeSpinColourVector, dist_source); envGetTmp(LatticeSpinColourVector, dist_source);
envGetTmp(LatticeSpinColourVector, tmp2); envGetTmp(LatticeSpinColourVector, source4d);
envGetTmp(LatticeSpinColourVector, result); envGetTmp(LatticeSpinColourVector, source3d);
envGetTmp(LatticeColourVector, result_nospin); envGetTmp(LatticeColourVector, source3d_nospin);
envGetTmp(LatticeSpinColourVector, tmp3d); envGetTmp(LatticeSpinColourVector, result4d);
envGetTmp(LatticeColourVector, tmp3d_nospin); envGetTmp(LatticeColourVector, result4d_nospin);
envGetTmp(LatticeColourVector, result_3d); envGetTmp(LatticeColourVector, result3d_nospin);
envGetTmp(LatticeColourVector, evec3d); envGetTmp(LatticeColourVector, evec3d);
const int Ntlocal{grid4d->LocalDimensions()[3]}; const int Ntlocal{grid4d->LocalDimensions()[3]};
const int Ntfirst{grid4d->LocalStarts()[3]}; const int Ntfirst{grid4d->LocalStarts()[3]};
@ -196,7 +211,7 @@ void TPerambulator<FImpl>::execute(void)
{ {
LOG(Message) << "LapH source vector from noise " << inoise << " and dilution component (d_k,d_t,d_alpha) : (" << dk << ","<< dt << "," << ds << ")" << std::endl; LOG(Message) << "LapH source vector from noise " << inoise << " and dilution component (d_k,d_t,d_alpha) : (" << dk << ","<< dt << "," << ds << ")" << std::endl;
dist_source = 0; dist_source = 0;
tmp3d_nospin = 0; source3d_nospin = 0;
evec3d = 0; evec3d = 0;
for (int it = dt; it < Nt; it += TI) for (int it = dt; it < Nt; it += TI)
{ {
@ -208,39 +223,39 @@ void TPerambulator<FImpl>::execute(void)
for (int is = ds; is < Ns; is += SI) for (int is = ds; is < Ns; is += SI)
{ {
ExtractSliceLocal(evec3d,epack.evec[ik],0,t_inv-Ntfirst,Tdir); ExtractSliceLocal(evec3d,epack.evec[ik],0,t_inv-Ntfirst,Tdir);
tmp3d_nospin = evec3d * noise.tensor(inoise, t_inv, ik, is); source3d_nospin = evec3d * noise.tensor(inoise, t_inv, ik, is);
tmp3d=0; source3d=0;
pokeSpin(tmp3d,tmp3d_nospin,is); pokeSpin(source3d,source3d_nospin,is);
tmp2=0; source4d=0;
InsertSliceLocal(tmp3d,tmp2,0,t_inv-Ntfirst,Tdir); InsertSliceLocal(source3d,source4d,0,t_inv-Ntfirst,Tdir);
dist_source += tmp2; dist_source += source4d;
} }
} }
} }
} }
result=0; result4d=0;
v4dtmp = dist_source; v4dtmp = dist_source;
if (Ls_ == 1) if (Ls_ == 1)
solver(result, v4dtmp); solver(result4d, v4dtmp);
else else
{ {
mat.ImportPhysicalFermionSource(v4dtmp, v5dtmp); mat.ImportPhysicalFermionSource(v4dtmp, v5dtmp);
solver(v5dtmp_sol, v5dtmp); solver(v5dtmp_sol, v5dtmp);
mat.ExportPhysicalFermionSolution(v5dtmp_sol, v4dtmp); mat.ExportPhysicalFermionSolution(v5dtmp_sol, v4dtmp);
result = v4dtmp; result4d = v4dtmp;
} }
if (!UnsmearedSinkFileName.empty()) if (!UnsmearedSinkFileName.empty())
unsmeared_sink[inoise+nnoise*(dk+LI*(dt+Nt_inv*ds))] = result; unsmeared_sink[inoise+nnoise*(dk+LI*(dt+Nt_inv*ds))] = result4d;
for (int is = 0; is < Ns; is++) for (int is = 0; is < Ns; is++)
{ {
result_nospin = peekSpin(result,is); result4d_nospin = peekSpin(result4d,is);
for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++) for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++)
{ {
ExtractSliceLocal(result_3d,result_nospin,0,t-Ntfirst,Tdir); ExtractSliceLocal(result3d_nospin,result4d_nospin,0,t-Ntfirst,Tdir);
for (int ivec = 0; ivec < nvec; ivec++) for (int ivec = 0; ivec < nvec; ivec++)
{ {
ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir); ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir);
pokeSpin(perambulator.tensor(t, ivec, dk, inoise,dt,ds),static_cast<Complex>(innerProduct(evec3d, result_3d)),is); pokeSpin(perambulator.tensor(t, ivec, dk, inoise,dt,ds),static_cast<Complex>(innerProduct(evec3d, result3d_nospin)),is);
} }
} }
} }
@ -284,7 +299,8 @@ void TPerambulator<FImpl>::execute(void)
//Save the unsmeared sinks if filename specified //Save the unsmeared sinks if filename specified
if (!UnsmearedSinkFileName.empty()) if (!UnsmearedSinkFileName.empty())
{ {
bool bMulti = ( Hadrons::MDistil::DistilParameters::ParameterDefault( par().UnsmearedSinkMultiFile, 1, false ) != 0 ); // bool bMulti = ( Hadrons::MDistil::DistilParameters::ParameterDefault( par().UnsmearedSinkMultiFile, 1, false ) != 0 );
bool bMulti =0;
LOG(Message) << "Writing unsmeared sink to " << UnsmearedSinkFileName << std::endl; LOG(Message) << "Writing unsmeared sink to " << UnsmearedSinkFileName << std::endl;
A2AVectorsIo::write(UnsmearedSinkFileName, unsmeared_sink, bMulti, vm().getTrajectory()); A2AVectorsIo::write(UnsmearedSinkFileName, unsmeared_sink, bMulti, vm().getTrajectory());
} }

9
Hadrons/Modules/MIO/LoadDistilNoise.hpp
View File

@ -44,8 +44,7 @@ class LoadDistilNoisePar: Serializable
public: public:
GRID_SERIALIZABLE_CLASS_MEMBERS(LoadDistilNoisePar, GRID_SERIALIZABLE_CLASS_MEMBERS(LoadDistilNoisePar,
std::string, NoiseFileName, std::string, NoiseFileName,
int, nvec, MDistil::DistilParameters, DistilPar);
MDistil::DistilParameters, Distil);
}; };
template <typename FImpl> template <typename FImpl>
@ -97,8 +96,10 @@ std::vector<std::string> TLoadDistilNoise<FImpl>::getOutput(void)
template <typename FImpl> template <typename FImpl>
void TLoadDistilNoise<FImpl>::setup(void) void TLoadDistilNoise<FImpl>::setup(void)
{ {
DISTIL_PARAMETERS_DEFINE( true ); const int Nt{env().getDim(Tdir)};
envCreate(MDistil::NoiseTensor, getName(), 1, nnoise, Nt, nvec, Ns); const int nvec{par().DistilPar.nvec};
const int nnoise{par().DistilPar.nnoise};
envCreate(MDistil::NoiseTensor, getName(), 1, nnoise, Nt, nvec, Ns);
} }
// execution /////////////////////////////////////////////////////////////////// // execution ///////////////////////////////////////////////////////////////////

17
Hadrons/Modules/MIO/LoadPerambulator.hpp
View File

@ -43,9 +43,8 @@ class LoadPerambulatorPar: Serializable
{ {
public: public:
GRID_SERIALIZABLE_CLASS_MEMBERS(LoadPerambulatorPar, GRID_SERIALIZABLE_CLASS_MEMBERS(LoadPerambulatorPar,
std::string, PerambFileName, //stem!!! std::string, PerambFileName,
int, nvec, MDistil::DistilParameters, DistilPar);
MDistil::DistilParameters, Distil);
}; };
template <typename FImpl> template <typename FImpl>
@ -97,8 +96,16 @@ std::vector<std::string> TLoadPerambulator<FImpl>::getOutput(void)
template <typename FImpl> template <typename FImpl>
void TLoadPerambulator<FImpl>::setup(void) void TLoadPerambulator<FImpl>::setup(void)
{ {
DISTIL_PARAMETERS_DEFINE( true ); const int Nt{env().getDim(Tdir)};
//std::array<std::string,6> sIndexNames{"Nt", "nvec", "LI", "nnoise", "Nt_inv", "SI"}; const int nvec{par().DistilPar.nvec};
const int nnoise{par().DistilPar.nnoise};
const int tsrc{par().DistilPar.tsrc};
const int TI{par().DistilPar.TI};
const int LI{par().DistilPar.LI};
const int SI{par().DistilPar.SI};
const bool full_tdil{ TI == Nt };
const bool exact_distillation{ full_tdil && LI == nvec };
const int Nt_inv{ full_tdil ? 1 : TI };
envCreate(MDistil::PerambTensor, getName(), 1, Nt,nvec,LI,nnoise,Nt_inv,SI); envCreate(MDistil::PerambTensor, getName(), 1, Nt,nvec,LI,nnoise,Nt_inv,SI);
} }

3
Hadrons/modules.inc
View File

@ -65,7 +65,9 @@ modules_cc =\
Modules/MScalarSUN/TrMag.cc \ Modules/MScalarSUN/TrMag.cc \
Modules/MDistil/PerambFromSolve.cc \ Modules/MDistil/PerambFromSolve.cc \
Modules/MDistil/DistilVectors.cc \ Modules/MDistil/DistilVectors.cc \
Modules/MDistil/DistilPar.cc \
Modules/MDistil/LapEvec.cc \ Modules/MDistil/LapEvec.cc \
Modules/MDistil/DistilParameters.cc \
Modules/MDistil/Perambulator.cc \ Modules/MDistil/Perambulator.cc \
Modules/MDistil/Noises.cc \ Modules/MDistil/Noises.cc \
Modules/MAction/MobiusDWF.cc \ Modules/MAction/MobiusDWF.cc \
@ -151,6 +153,7 @@ modules_hpp =\
Modules/MDistil/Noises.hpp \ Modules/MDistil/Noises.hpp \
Modules/MDistil/LapEvec.hpp \ Modules/MDistil/LapEvec.hpp \
Modules/MDistil/Perambulator.hpp \ Modules/MDistil/Perambulator.hpp \
Modules/MDistil/DistilPar.hpp \
Modules/MDistil/DistilCommon.hpp \ Modules/MDistil/DistilCommon.hpp \
Modules/MAction/ZMobiusDWF.hpp \ Modules/MAction/ZMobiusDWF.hpp \
Modules/MAction/ScaledDWF.hpp \ Modules/MAction/ScaledDWF.hpp \