portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-04-03 18:55:56 +01:00
Code Releases Activity

Gparity valence test now working.

Browse Source 
Interface in FermionOperator will change a lot in future
This commit is contained in:
Peter Boyle 2015-08-14 00:01:04 +01:00
parent 45b01858a8
commit 7d3512ab21
14 changed files with 572 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lib/Stencil.h
View File

@ -41,6 +41,12 @@
namespace Grid { namespace Grid {
struct StencilEntry {
int _offset;
int _is_local;
int _permute;
int _around_the_world;
};
class CartesianStencil { // Stencil runs along coordinate axes only; NO diagonal fill in. class CartesianStencil { // Stencil runs along coordinate axes only; NO diagonal fill in.
public: public:
@ -58,9 +64,9 @@ namespace Grid {
std::vector<int> _permute_type; std::vector<int> _permute_type;
// npoints x Osites() of these // npoints x Osites() of these
std::vector<std::vector<int> > _offsets; std::vector<std::vector<StencilEntry> > _entries;
std::vector<std::vector<int> > _is_local;
std::vector<std::vector<int> > _permute; inline StencilEntry * GetEntry(int &ptype,int point,int osite) { ptype = _permute_type[point]; return & _entries[point][osite]; }
int _unified_buffer_size; int _unified_buffer_size;
int _request_count; int _request_count;
@ -77,8 +83,8 @@ namespace Grid {
// Can this be avoided with simpler coding of comms? // Can this be avoided with simpler coding of comms?
void Local (int point, int dimension,int shift,int cbmask); void Local (int point, int dimension,int shift,int cbmask);
void Comms (int point, int dimension,int shift,int cbmask); void Comms (int point, int dimension,int shift,int cbmask);
void CopyPlane(int point, int dimension,int lplane,int rplane,int cbmask,int permute); void CopyPlane(int point, int dimension,int lplane,int rplane,int cbmask,int permute,int wrap);
void ScatterPlane (int point,int dimension,int plane,int cbmask,int offset); void ScatterPlane (int point,int dimension,int plane,int cbmask,int offset,int wrap);
// Could allow a functional munging of the halo to another type during the comms. // Could allow a functional munging of the halo to another type during the comms.
// this could implement the 16bit/32bit/64bit compression. // this could implement the 16bit/32bit/64bit compression.

20
lib/algorithms/CoarsenedMatrix.h
View File

@ -193,20 +193,18 @@ PARALLEL_FOR_LOOP
for(int ss=0;ss<Grid()->oSites();ss++){ for(int ss=0;ss<Grid()->oSites();ss++){
siteVector res = zero; siteVector res = zero;
siteVector nbr; siteVector nbr;
int offset,local,perm,ptype; int ptype;
StencilEntry *SE;
for(int point=0;point<geom.npoint;point++){ for(int point=0;point<geom.npoint;point++){
offset = Stencil._offsets [point][ss];
local = Stencil._is_local[point][ss]; SE=Stencil.GetEntry(ptype,point,ss);
perm = Stencil._permute [point][ss];
ptype = Stencil._permute_type[point];
if(local&&perm) { if(SE->_is_local&&SE->_permute) {
permute(nbr,in._odata[offset],ptype); permute(nbr,in._odata[SE->_offset],ptype);
} else if(local) { } else if(SE->_is_local) {
nbr = in._odata[offset]; nbr = in._odata[SE->_offset];
} else { } else {
nbr = comm_buf[offset]; nbr = comm_buf[SE->_offset];
} }
res = res + A[point]._odata[ss]*nbr; res = res + A[point]._odata[ss]*nbr;
} }

2
lib/lattice/Lattice_peekpoke.h
View File

@ -14,6 +14,7 @@ namespace Grid {
auto PeekIndex(const Lattice<vobj> &lhs,int i) -> Lattice<decltype(peekIndex<Index>(lhs._odata[0],i))> auto PeekIndex(const Lattice<vobj> &lhs,int i) -> Lattice<decltype(peekIndex<Index>(lhs._odata[0],i))>
{ {
Lattice<decltype(peekIndex<Index>(lhs._odata[0],i))> ret(lhs._grid); Lattice<decltype(peekIndex<Index>(lhs._odata[0],i))> ret(lhs._grid);
ret.checkerboard=lhs.checkerboard;
PARALLEL_FOR_LOOP PARALLEL_FOR_LOOP
for(int ss=0;ss<lhs._grid->oSites();ss++){ for(int ss=0;ss<lhs._grid->oSites();ss++){
ret._odata[ss] = peekIndex<Index>(lhs._odata[ss],i); ret._odata[ss] = peekIndex<Index>(lhs._odata[ss],i);
@ -24,6 +25,7 @@ PARALLEL_FOR_LOOP
auto PeekIndex(const Lattice<vobj> &lhs,int i,int j) -> Lattice<decltype(peekIndex<Index>(lhs._odata[0],i,j))> auto PeekIndex(const Lattice<vobj> &lhs,int i,int j) -> Lattice<decltype(peekIndex<Index>(lhs._odata[0],i,j))>
{ {
Lattice<decltype(peekIndex<Index>(lhs._odata[0],i,j))> ret(lhs._grid); Lattice<decltype(peekIndex<Index>(lhs._odata[0],i,j))> ret(lhs._grid);
ret.checkerboard=lhs.checkerboard;
PARALLEL_FOR_LOOP PARALLEL_FOR_LOOP
for(int ss=0;ss<lhs._grid->oSites();ss++){ for(int ss=0;ss<lhs._grid->oSites();ss++){
ret._odata[ss] = peekIndex<Index>(lhs._odata[ss],i,j); ret._odata[ss] = peekIndex<Index>(lhs._odata[ss],i,j);

2
lib/qcd/QCD.h
View File

@ -36,7 +36,7 @@ namespace QCD {
template<typename T> struct isSpinor { template<typename T> struct isSpinor {
static const bool value = (SpinorIndex==T::TensorLevel); static const bool value = (SpinorIndex==T::TensorLevel);
}; };
template <typename T> using IfSpinor = Invoke<std::enable_if<isSpinor<T>::value,int> > ; template <typename T> using IfSpinor = Invoke<std::enable_if< isSpinor<T>::value,int> > ;
template <typename T> using IfNotSpinor = Invoke<std::enable_if<!isSpinor<T>::value,int> > ; template <typename T> using IfNotSpinor = Invoke<std::enable_if<!isSpinor<T>::value,int> > ;
// ChrisK very keen to add extra space for Gparity doubling. // ChrisK very keen to add extra space for Gparity doubling.

11
lib/qcd/action/Actions.h
View File

@ -46,6 +46,8 @@
//////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////
#define FermOpTemplateInstantiate(A) \ #define FermOpTemplateInstantiate(A) \
template class A<GparityWilsonImplF>; \
template class A<GparityWilsonImplD>; \
template class A<WilsonImplF>; \ template class A<WilsonImplF>; \
template class A<WilsonImplD>; template class A<WilsonImplD>;
@ -131,6 +133,15 @@ typedef OverlapWilsonPartialFractionTanhFermion<WilsonImplD> OverlapWilsonPartia
typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplR> OverlapWilsonPartialFractionZolotarevFermionR; typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplR> OverlapWilsonPartialFractionZolotarevFermionR;
typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplF> OverlapWilsonPartialFractionZolotarevFermionF; typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplF> OverlapWilsonPartialFractionZolotarevFermionF;
typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplD> OverlapWilsonPartialFractionZolotarevFermionD; typedef OverlapWilsonPartialFractionZolotarevFermion<WilsonImplD> OverlapWilsonPartialFractionZolotarevFermionD;
// Gparity cases; partial list until tested
typedef WilsonFermion<GparityWilsonImplR> GparityWilsonFermionR;
typedef WilsonFermion<GparityWilsonImplF> GparityWilsonFermionF;
typedef WilsonFermion<GparityWilsonImplD> GparityWilsonFermionD;
typedef DomainWallFermion<GparityWilsonImplR> GparityDomainWallFermionR;
typedef DomainWallFermion<GparityWilsonImplF> GparityDomainWallFermionF;
typedef DomainWallFermion<GparityWilsonImplD> GparityDomainWallFermionD;
}} }}
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// G5 herm -- this has to live in QCD since dirac matrix is not in the broader sector of code // G5 herm -- this has to live in QCD since dirac matrix is not in the broader sector of code

66
lib/qcd/action/fermion/FermionOperator.h
View File

@ -37,12 +37,10 @@ namespace Grid {
typedef WilsonCompressor<SiteHalfSpinor,SiteSpinor> Compressor; typedef WilsonCompressor<SiteHalfSpinor,SiteSpinor> Compressor;
// provide the multiply by link that is differentiated between Gparity (with flavour index) and // provide the multiply by link that is differentiated between Gparity (with flavour index) and non-Gparity
// non-Gparity static inline void multLink(SiteHalfSpinor &phi,const SiteDoubledGaugeField &U,const SiteHalfSpinor &chi,int mu,StencilEntry *SE){
static inline void multLink(SiteHalfSpinor &phi,const SiteDoubledGaugeField &U,const SiteHalfSpinor &chi,int mu){
mult(&phi(),&U(mu),&chi()); mult(&phi(),&U(mu),&chi());
} }
static inline void DoubleStore(GridBase *GaugeGrid,DoubledGaugeField &Uds,const GaugeField &Umu) static inline void DoubleStore(GridBase *GaugeGrid,DoubledGaugeField &Uds,const GaugeField &Umu)
{ {
conformable(Uds._grid,GaugeGrid); conformable(Uds._grid,GaugeGrid);
@ -55,6 +53,11 @@ namespace Grid {
PokeIndex<LorentzIndex>(Uds,U,mu+4); PokeIndex<LorentzIndex>(Uds,U,mu+4);
} }
} }
static inline void InsertForce(GaugeField &mat,const FermionField &Btilde,const FermionField &A,int mu){
GaugeLinkField link(mat._grid);
link = TraceIndex<SpinIndex>(outerProduct(Btilde,A));
PokeIndex<LorentzIndex>(mat,link,mu);
}
}; };
@ -62,8 +65,6 @@ namespace Grid {
typedef WilsonImpl<vComplexF,Nc> WilsonImplF; // Float typedef WilsonImpl<vComplexF,Nc> WilsonImplF; // Float
typedef WilsonImpl<vComplexD,Nc> WilsonImplD; // Double typedef WilsonImpl<vComplexD,Nc> WilsonImplD; // Double
template<class S,int Nrepresentation=Nc> template<class S,int Nrepresentation=Nc>
class GparityWilsonImpl { class GparityWilsonImpl {
public: public:
@ -74,7 +75,7 @@ namespace Grid {
template<typename vtype> using iImplHalfSpinor = iVector<iVector<iVector<vtype, Nrepresentation>, Nhs>, Ngp >; template<typename vtype> using iImplHalfSpinor = iVector<iVector<iVector<vtype, Nrepresentation>, Nhs>, Ngp >;
template<typename vtype> using iImplGaugeField = iVector<iScalar<iMatrix<vtype, Nrepresentation> >, Nd >; template<typename vtype> using iImplGaugeField = iVector<iScalar<iMatrix<vtype, Nrepresentation> >, Nd >;
template<typename vtype> using iImplGaugeLink = iScalar<iScalar<iScalar<iMatrix<vtype, Nrepresentation> > > >; template<typename vtype> using iImplGaugeLink = iScalar<iScalar<iMatrix<vtype, Nrepresentation> > >;
template<typename vtype> using iImplDoubledGaugeField = iVector<iVector<iScalar<iMatrix<vtype, Nrepresentation> >, Nds >, Ngp >; template<typename vtype> using iImplDoubledGaugeField = iVector<iVector<iScalar<iMatrix<vtype, Nrepresentation> >, Nds >, Ngp >;
typedef iImplSpinor <Simd> SiteSpinor; typedef iImplSpinor <Simd> SiteSpinor;
@ -88,16 +89,26 @@ namespace Grid {
typedef Lattice<SiteGaugeField> GaugeField; typedef Lattice<SiteGaugeField> GaugeField;
typedef Lattice<SiteDoubledGaugeField> DoubledGaugeField; typedef Lattice<SiteDoubledGaugeField> DoubledGaugeField;
typedef GparityWilsonCompressor<SiteHalfSpinor,SiteSpinor> Compressor; // typedef GparityWilsonCompressor<SiteHalfSpinor,SiteSpinor> Compressor;
typedef WilsonCompressor<SiteHalfSpinor,SiteSpinor> Compressor;
// provide the multiply by link that is differentiated between Gparity (with flavour index) and // provide the multiply by link that is differentiated between Gparity (with flavour index) and
// non-Gparity // non-Gparity
static inline void multLink(SiteHalfSpinor &phi,const SiteDoubledGaugeField &U,const SiteHalfSpinor &chi,int mu){ static inline void multLink(SiteHalfSpinor &phi,const SiteDoubledGaugeField &U,const SiteHalfSpinor &chi,int mu,StencilEntry *SE){
for(int f=0;f<Ngp;f++){ // FIXME; need to be more careful. If this is a simd direction we are still stuffed
mult(&phi(f),&U(f)(mu),&chi(f)); if ( SE->_around_the_world && ((mu==Xp)||(mu==Xm)) ) {
} mult(&phi(0),&U(0)(mu),&chi(1));
mult(&phi(1),&U(1)(mu),&chi(0));
} else {
mult(&phi(0),&U(0)(mu),&chi(0));
mult(&phi(1),&U(1)(mu),&chi(1));
} }
}
static inline void InsertForce(GaugeField &mat,const FermionField &Btilde,const FermionField &A,int mu){
// Fixme
return;
}
static inline void DoubleStore(GridBase *GaugeGrid,DoubledGaugeField &Uds,const GaugeField &Umu) static inline void DoubleStore(GridBase *GaugeGrid,DoubledGaugeField &Uds,const GaugeField &Umu)
{ {
conformable(Uds._grid,GaugeGrid); conformable(Uds._grid,GaugeGrid);
@ -116,44 +127,51 @@ namespace Grid {
LatticeCoordinate(coor,mu); LatticeCoordinate(coor,mu);
U = PeekIndex<LorentzIndex>(Umu,mu); U = PeekIndex<LorentzIndex>(Umu,mu);
Uconj = conj(U); Uconj = conjugate(U);
int neglink = GaugeGrid->GlobalDimensions()[mu]-1; int neglink = GaugeGrid->GlobalDimensions()[mu]-1;
if ( gpdirs[mu] ) { if ( gpdirs[mu] ) {
Uconj = where(coor==neglink,-Uconj,Uconj); Uconj = where(coor==neglink,-Uconj,Uconj);
} }
PARALLEL_FOR_LOOP PARALLEL_FOR_LOOP
for(auto ss=U.begin();ss<U.end();ss++){ for(auto ss=U.begin();ss<U.end();ss++){
Uds[ss](0)(mu) = U[ss](); Uds[ss](0)(mu) = U[ss]();
Uds[ss](1)(mu) = Uconj[ss](); Uds[ss](1)(mu) = Uconj[ss]();
} }
U = adj(Cshift(U ,mu,-1)); // correct except for spanning the boundary
U = adj(Cshift(U,mu,-1)); // correct except for spanning the boundary
Uconj = adj(Cshift(Uconj,mu,-1)); Uconj = adj(Cshift(Uconj,mu,-1));
Utmp = where(coor==0,U,Uconj); Utmp = U;
PARALLEL_FOR_LOOP if ( gpdirs[mu] ) {
for(auto ss=U.begin();ss<U.end();ss++){ Utmp = where(coor==0,Uconj,Utmp);
Uds[ss](1)(mu) = Utmp[ss]();
} }
Utmp = where(coor==0,Uconj,U);
PARALLEL_FOR_LOOP PARALLEL_FOR_LOOP
for(auto ss=U.begin();ss<U.end();ss++){ for(auto ss=U.begin();ss<U.end();ss++){
Uds[ss](0)(mu) = Utmp[ss](); Uds[ss](0)(mu+4) = Utmp[ss]();
} }
Utmp = Uconj;
if ( gpdirs[mu] ) {
Utmp = where(coor==0,U,Utmp);
}
PARALLEL_FOR_LOOP
for(auto ss=U.begin();ss<U.end();ss++){
Uds[ss](1)(mu+4) = Utmp[ss]();
}
} }
} }
}; };
typedef WilsonImpl<vComplex,Nc> WilsonImplR; // Real.. whichever prec typedef GparityWilsonImpl<vComplex,Nc> GparityWilsonImplR; // Real.. whichever prec
typedef WilsonImpl<vComplexF,Nc> WilsonImplF; // Float typedef GparityWilsonImpl<vComplexF,Nc> GparityWilsonImplF; // Float
typedef WilsonImpl<vComplexD,Nc> WilsonImplD; // Double typedef GparityWilsonImpl<vComplexD,Nc> GparityWilsonImplD; // Double

75
lib/qcd/action/fermion/WilsonCompressor.h
View File

@ -63,6 +63,7 @@ namespace QCD {
} }
}; };
/*
template<class SiteHalfSpinor,class SiteSpinor> template<class SiteHalfSpinor,class SiteSpinor>
class GparityWilsonCompressor : public WilsonCompressor<SiteHalfSpinor,SiteSpinor>{ class GparityWilsonCompressor : public WilsonCompressor<SiteHalfSpinor,SiteSpinor>{
@ -77,55 +78,65 @@ namespace QCD {
const int Nsimd = grid->Nsimd(); const int Nsimd = grid->Nsimd();
int ocb=grid->CheckerBoardFromOindex(osite); int checkered=grid->CheckerBoarded(dim);
int ocb=grid->CheckerBoardFromOindex(osite);
SiteHalfSpinor tmp = spinproject(in); // spin projected SiteHalfSpinor tmp = this->spinproject(in); // spin projected
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
// Check whether we must flavour flip // Check whether we must flavour flip
// do this if source is plane 0 on processor 0 in dimension dim // do this if source is plane 0 on processor 0 in dimension dim
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
if ( (this->mu==Xp)||(this->mu==Yp)||(this->mu==Zp)||(this->mu==Tp) ) { int do_flip = 0;
int flipicoor= 0;
if(Gbcs[this->mu]){
if ( Gbcs[this->mu] && (grid->_processor_coor[dim] == 0) && (plane==0) && (ocb==0) ) { std::cout << "Applying Gparity BC's in direction "<<this->mu<<std::endl;
std::vector<scalar_object> flat(Nsimd); if ( (this->mu==Xp)||(this->mu==Yp)||(this->mu==Zp)||(this->mu==Tp) ) {
if ( (grid->_processor_coor[dim] == 0)
extract(tmp,flat); && (plane==0)
&& ( (!checkered)||(ocb==0) ) ) {
for(int i=0;i<Nsimd;i++) { do_flip=1;
std::vector<int> coor; flipicoor=0;
grid->iCoorFromIindex(coor,i);
if ( coor[dim]==0 ) {
scalar_object stmp;
stmp(0) = flat[i](1);
stmp(1) = flat[i](0);
flat[i] = stmp;
}
} }
}
if ( (this->mu==Xm)||(this->mu==Ym)||(this->mu==Zm)||(this->mu==Tm) ) {
if ( (grid->_processor_coor[dim] == (grid->_processors[dim]-1) )
&& (plane==grid->_rdimensions[dim]-1)
&& ( (!checkered)||(ocb==1) ) ) {
do_flip=1;
flipicoor=grid->_simd_layout[dim]-1;
}
}
}
if ( do_flip ) {
merge(tmp,flat); std::cout << "Applying Gparity BC's in direction "<<this->mu<< " osite " << osite << " plane "<<plane <<std::endl;
} // coor & bc guard std::vector<scalar_object> flat(Nsimd);
} // shift guard std::vector<int> coor;
extract(tmp,flat);
for(int i=0;i<Nsimd;i++) {
grid->iCoorFromIindex(coor,i);
if ( coor[dim]==flipicoor ) {
scalar_object stmp;
stmp(0) = flat[i](1);
stmp(1) = flat[i](0);
flat[i] = stmp;
}
}
merge(tmp,flat);
}
return tmp; return tmp;
} }
SiteHalfSpinor flavourflip(const SiteHalfSpinor &in) {
SiteHalfSpinor ret;
for(int f=0;f<Ngp;f++){
ret(0) = in(1);
ret(1) = in(0);
}
return ret;
}
}; };
*/
}} // namespace close }} // namespace close
#endif #endif

6
lib/qcd/action/fermion/WilsonFermion.cc
View File

@ -117,7 +117,6 @@ namespace QCD {
Compressor compressor(dag); Compressor compressor(dag);
GaugeLinkField tmp(B._grid);
FermionField Btilde(B._grid); FermionField Btilde(B._grid);
st.HaloExchange<SiteSpinor,SiteHalfSpinor,Compressor>(B,comm_buf,compressor); st.HaloExchange<SiteSpinor,SiteHalfSpinor,Compressor>(B,comm_buf,compressor);
@ -141,9 +140,8 @@ PARALLEL_FOR_LOOP
////////////////////////////////////////////////// //////////////////////////////////////////////////
// spin trace outer product // spin trace outer product
////////////////////////////////////////////////// //////////////////////////////////////////////////
tmp = TraceIndex<SpinIndex>(outerProduct(Btilde,A)); Impl::InsertForce(mat,Btilde,A,mu);
PokeIndex<LorentzIndex>(mat,tmp,mu);
} }
} }

11
lib/qcd/action/fermion/WilsonFermion5D.cc
View File

@ -137,7 +137,6 @@ void WilsonFermion5D<Impl>::DerivInternal(CartesianStencil & st,
//////////////////////// ////////////////////////
// Call the single hop // Call the single hop
//////////////////////// ////////////////////////
tmp = zero;
PARALLEL_FOR_LOOP PARALLEL_FOR_LOOP
for(int sss=0;sss<U._grid->oSites();sss++){ for(int sss=0;sss<U._grid->oSites();sss++){
@ -154,14 +153,18 @@ PARALLEL_FOR_LOOP
// spin trace outer product // spin trace outer product
//////////////////////////// ////////////////////////////
tmp[sU] = tmp[sU]+ traceIndex<SpinIndex>(
outerProduct(Btilde[sF],Atilde[sF])); // ordering here
} }
} }
Impl::InsertForce(mat,Btilde,A,mu);
/*
tmp = zero;
for(int sss=0;sss<U._grid->oSites();sss++){
tmp[sU] = tmp[sU]+ traceIndex<SpinIndex>(outerProduct(Btilde[sF],Atilde[sF])); // ordering here
}
PokeIndex<LorentzIndex>(mat,tmp,mu); PokeIndex<LorentzIndex>(mat,tmp,mu);
*/
} }
} }

399
lib/qcd/action/fermion/WilsonKernels.cc
View File

@ -9,143 +9,116 @@ void WilsonKernels<Impl>::DiracOptDhopSite(CartesianStencil &st,DoubledGaugeFiel
{ {
SiteHalfSpinor tmp; SiteHalfSpinor tmp;
SiteHalfSpinor chi; SiteHalfSpinor chi;
SiteSpinor result;
SiteHalfSpinor Uchi; SiteHalfSpinor Uchi;
int offset,local,perm, ptype; SiteSpinor result;
StencilEntry *SE;
int ptype;
// Xp // Xp
int ss = sF; SE=st.GetEntry(ptype,Xp,sF);
offset = st._offsets [Xp][ss]; if ( SE->_is_local && SE->_permute ) {
local = st._is_local[Xp][ss]; spProjXp(tmp,in._odata[SE->_offset]);
perm = st._permute[Xp][ss];
ptype = st._permute_type[Xp];
if ( local && perm ) {
spProjXp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjXp(chi,in._odata[offset]); spProjXp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Xp); Impl::multLink(Uchi,U._odata[sU],chi,Xp,SE);
spReconXp(result,Uchi); spReconXp(result,Uchi);
// Yp // Yp
offset = st._offsets [Yp][ss]; SE=st.GetEntry(ptype,Yp,sF);
local = st._is_local[Yp][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Yp][ss]; spProjYp(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Yp];
if ( local && perm ) {
spProjYp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjYp(chi,in._odata[offset]); spProjYp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Yp); Impl::multLink(Uchi,U._odata[sU],chi,Yp,SE);
accumReconYp(result,Uchi); accumReconYp(result,Uchi);
// Zp // Zp
offset = st._offsets [Zp][ss]; SE=st.GetEntry(ptype,Zp,sF);
local = st._is_local[Zp][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Zp][ss]; spProjZp(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Zp];
if ( local && perm ) {
spProjZp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjZp(chi,in._odata[offset]); spProjZp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Zp); Impl::multLink(Uchi,U._odata[sU],chi,Zp,SE);
accumReconZp(result,Uchi); accumReconZp(result,Uchi);
// Tp // Tp
offset = st._offsets [Tp][ss]; SE=st.GetEntry(ptype,Tp,sF);
local = st._is_local[Tp][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Tp][ss]; spProjTp(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Tp];
if ( local && perm ) {
spProjTp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjTp(chi,in._odata[offset]); spProjTp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Tp); Impl::multLink(Uchi,U._odata[sU],chi,Tp,SE);
accumReconTp(result,Uchi); accumReconTp(result,Uchi);
// Xm // Xm
offset = st._offsets [Xm][ss]; SE=st.GetEntry(ptype,Xm,sF);
local = st._is_local[Xm][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Xm][ss]; spProjXm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Xm];
if ( local && perm ) {
spProjXm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjXm(chi,in._odata[offset]); spProjXm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Xm); Impl::multLink(Uchi,U._odata[sU],chi,Xm,SE);
accumReconXm(result,Uchi); accumReconXm(result,Uchi);
// Ym // Ym
offset = st._offsets [Ym][ss]; SE=st.GetEntry(ptype,Ym,sF);
local = st._is_local[Ym][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Ym][ss]; spProjYm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Ym];
if ( local && perm ) {
spProjYm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjYm(chi,in._odata[offset]); spProjYm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Ym); Impl::multLink(Uchi,U._odata[sU],chi,Ym,SE);
accumReconYm(result,Uchi); accumReconYm(result,Uchi);
// Zm // Zm
offset = st._offsets [Zm][ss]; SE=st.GetEntry(ptype,Zm,sF);
local = st._is_local[Zm][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Zm][ss]; spProjZm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Zm];
if ( local && perm ) {
spProjZm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjZm(chi,in._odata[offset]); spProjZm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Zm); Impl::multLink(Uchi,U._odata[sU],chi,Zm,SE);
accumReconZm(result,Uchi); accumReconZm(result,Uchi);
// Tm // Tm
offset = st._offsets [Tm][ss]; SE=st.GetEntry(ptype,Tm,sF);
local = st._is_local[Tm][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Tm][ss]; spProjTm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Tm];
if ( local && perm ) {
spProjTm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjTm(chi,in._odata[offset]); spProjTm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Tm); Impl::multLink(Uchi,U._odata[sU],chi,Tm,SE);
accumReconTm(result,Uchi); accumReconTm(result,Uchi);
vstream(out._odata[ss],result*(-0.5)); vstream(out._odata[sF],result*(-0.5));
}; };
template<class Impl> template<class Impl>
@ -157,141 +130,114 @@ void WilsonKernels<Impl>::DiracOptDhopSiteDag(CartesianStencil &st,DoubledGaugeF
SiteHalfSpinor chi; SiteHalfSpinor chi;
SiteSpinor result; SiteSpinor result;
SiteHalfSpinor Uchi; SiteHalfSpinor Uchi;
int offset,local,perm, ptype; StencilEntry *SE;
int ptype;
// Xp // Xp
int ss=sF; SE=st.GetEntry(ptype,Xm,sF);
offset = st._offsets [Xm][ss]; if ( SE->_is_local && SE->_permute ) {
local = st._is_local[Xm][ss]; spProjXp(tmp,in._odata[SE->_offset]);
perm = st._permute[Xm][ss];
ptype = st._permute_type[Xm];
if ( local && perm ) {
spProjXp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjXp(chi,in._odata[offset]); spProjXp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Xm); Impl::multLink(Uchi,U._odata[sU],chi,Xm,SE);
spReconXp(result,Uchi); spReconXp(result,Uchi);
// Yp // Yp
offset = st._offsets [Ym][ss]; SE=st.GetEntry(ptype,Ym,sF);
local = st._is_local[Ym][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Ym][ss]; spProjYp(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Ym];
if ( local && perm ) {
spProjYp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjYp(chi,in._odata[offset]); spProjYp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Ym); Impl::multLink(Uchi,U._odata[sU],chi,Ym,SE);
accumReconYp(result,Uchi); accumReconYp(result,Uchi);
// Zp // Zp
offset = st._offsets [Zm][ss]; SE=st.GetEntry(ptype,Zm,sF);
local = st._is_local[Zm][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Zm][ss]; spProjZp(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Zm];
if ( local && perm ) {
spProjZp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjZp(chi,in._odata[offset]); spProjZp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Zm); Impl::multLink(Uchi,U._odata[sU],chi,Zm,SE);
accumReconZp(result,Uchi); accumReconZp(result,Uchi);
// Tp // Tp
offset = st._offsets [Tm][ss]; SE=st.GetEntry(ptype,Tm,sF);
local = st._is_local[Tm][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Tm][ss]; spProjTp(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Tm];
if ( local && perm ) {
spProjTp(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjTp(chi,in._odata[offset]); spProjTp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Tm); Impl::multLink(Uchi,U._odata[sU],chi,Tm,SE);
accumReconTp(result,Uchi); accumReconTp(result,Uchi);
// Xm // Xm
offset = st._offsets [Xp][ss]; SE=st.GetEntry(ptype,Xp,sF);
local = st._is_local[Xp][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Xp][ss]; spProjXm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Xp];
if ( local && perm ) {
spProjXm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjXm(chi,in._odata[offset]); spProjXm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Xp); Impl::multLink(Uchi,U._odata[sU],chi,Xp,SE);
accumReconXm(result,Uchi); accumReconXm(result,Uchi);
// Ym // Ym
offset = st._offsets [Yp][ss]; SE=st.GetEntry(ptype,Yp,sF);
local = st._is_local[Yp][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Yp][ss]; spProjYm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Yp];
if ( local && perm ) {
spProjYm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjYm(chi,in._odata[offset]); spProjYm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Yp); Impl::multLink(Uchi,U._odata[sU],chi,Yp,SE);
accumReconYm(result,Uchi); accumReconYm(result,Uchi);
// Zm // Zm
offset = st._offsets [Zp][ss]; SE=st.GetEntry(ptype,Zp,sF);
local = st._is_local[Zp][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Zp][ss]; spProjZm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Zp];
if ( local && perm ) {
spProjZm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjZm(chi,in._odata[offset]); spProjZm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Zp); Impl::multLink(Uchi,U._odata[sU],chi,Zp,SE);
accumReconZm(result,Uchi); accumReconZm(result,Uchi);
// Tm // Tm
offset = st._offsets [Tp][ss]; SE=st.GetEntry(ptype,Tp,sF);
local = st._is_local[Tp][ss]; if ( SE->_is_local && SE->_permute ) {
perm = st._permute[Tp][ss]; spProjTm(tmp,in._odata[SE->_offset]);
ptype = st._permute_type[Tp];
if ( local && perm ) {
spProjTm(tmp,in._odata[offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjTm(chi,in._odata[offset]); spProjTm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,Tp); Impl::multLink(Uchi,U._odata[sU],chi,Tp,SE);
accumReconTm(result,Uchi); accumReconTm(result,Uchi);
vstream(out._odata[ss],result*(-0.5)); vstream(out._odata[sF],result*(-0.5));
} }
template<class Impl> template<class Impl>
@ -303,127 +249,124 @@ void WilsonKernels<Impl>::DiracOptDhopDir(CartesianStencil &st,DoubledGaugeField
SiteHalfSpinor chi; SiteHalfSpinor chi;
SiteSpinor result; SiteSpinor result;
SiteHalfSpinor Uchi; SiteHalfSpinor Uchi;
int offset,local,perm, ptype; StencilEntry *SE;
int ss=sF; int ptype;
offset = st._offsets [dir][ss]; SE=st.GetEntry(ptype,dir,sF);
local = st._is_local[dir][ss];
perm = st._permute[dir][ss];
ptype = st._permute_type[dir];
// Xp // Xp
if(gamma==Xp){ if(gamma==Xp){
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjXp(tmp,in._odata[offset]); spProjXp(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjXp(chi,in._odata[offset]); spProjXp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconXp(result,Uchi); spReconXp(result,Uchi);
} }
// Yp // Yp
if ( gamma==Yp ){ if ( gamma==Yp ){
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjYp(tmp,in._odata[offset]); spProjYp(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjYp(chi,in._odata[offset]); spProjYp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconYp(result,Uchi); spReconYp(result,Uchi);
} }
// Zp // Zp
if ( gamma ==Zp ){ if ( gamma ==Zp ){
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjZp(tmp,in._odata[offset]); spProjZp(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjZp(chi,in._odata[offset]); spProjZp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconZp(result,Uchi); spReconZp(result,Uchi);
} }
// Tp // Tp
if ( gamma ==Tp ){ if ( gamma ==Tp ){
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjTp(tmp,in._odata[offset]); spProjTp(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjTp(chi,in._odata[offset]); spProjTp(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconTp(result,Uchi); spReconTp(result,Uchi);
} }
// Xm // Xm
if ( gamma==Xm ){ if ( gamma==Xm ){
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjXm(tmp,in._odata[offset]); spProjXm(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjXm(chi,in._odata[offset]); spProjXm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconXm(result,Uchi); spReconXm(result,Uchi);
} }
// Ym // Ym
if ( gamma == Ym ){ if ( gamma == Ym ){
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjYm(tmp,in._odata[offset]); spProjYm(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjYm(chi,in._odata[offset]); spProjYm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconYm(result,Uchi); spReconYm(result,Uchi);
} }
// Zm // Zm
if ( gamma == Zm ){ if ( gamma == Zm ){
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjZm(tmp,in._odata[offset]); spProjZm(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjZm(chi,in._odata[offset]); spProjZm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconZm(result,Uchi); spReconZm(result,Uchi);
} }
// Tm // Tm
if ( gamma==Tm ) { if ( gamma==Tm ) {
if ( local && perm ) { if ( SE->_is_local && SE->_permute ) {
spProjTm(tmp,in._odata[offset]); spProjTm(tmp,in._odata[SE->_offset]);
permute(chi,tmp,ptype); permute(chi,tmp,ptype);
} else if ( local ) { } else if ( SE->_is_local ) {
spProjTm(chi,in._odata[offset]); spProjTm(chi,in._odata[SE->_offset]);
} else { } else {
chi=buf[offset]; chi=buf[SE->_offset];
} }
Impl::multLink(Uchi,U._odata[sU],chi,dir); Impl::multLink(Uchi,U._odata[sU],chi,dir,SE);
spReconTm(result,Uchi); spReconTm(result,Uchi);
} }
vstream(out._odata[ss],result*(-0.5)); vstream(out._odata[sF],result*(-0.5));
} }
FermOpTemplateInstantiate(WilsonKernels); FermOpTemplateInstantiate(WilsonKernels);

72
lib/stencil/Stencil_common.cc
View File

@ -8,11 +8,7 @@ namespace Grid {
int checkerboard, int checkerboard,
const std::vector<int> &directions, const std::vector<int> &directions,
const std::vector<int> &distances) const std::vector<int> &distances)
: _offsets(npoints), : _entries(npoints), _permute_type(npoints)
_is_local(npoints),
_comm_buf_size(npoints),
_permute_type(npoints),
_permute(npoints)
{ {
_npoints = npoints; _npoints = npoints;
_grid = grid; _grid = grid;
@ -27,9 +23,7 @@ namespace Grid {
int point = i; int point = i;
_offsets[i].resize( osites); _entries[i].resize( osites);
_is_local[i].resize(osites);
_permute[i].resize( osites);
int dimension = directions[i]; int dimension = directions[i];
int displacement = distances[i]; int displacement = distances[i];
@ -76,7 +70,7 @@ namespace Grid {
} }
void CartesianStencil::Local (int point, int dimension,int shift,int cbmask) void CartesianStencil::Local (int point, int dimension,int shiftpm,int cbmask)
{ {
int fd = _grid->_fdimensions[dimension]; int fd = _grid->_fdimensions[dimension];
int rd = _grid->_rdimensions[dimension]; int rd = _grid->_rdimensions[dimension];
@ -84,7 +78,7 @@ namespace Grid {
int gd = _grid->_gdimensions[dimension]; int gd = _grid->_gdimensions[dimension];
// Map to always positive shift modulo global full dimension. // Map to always positive shift modulo global full dimension.
shift = (shift+fd)%fd; int shift = (shiftpm+fd)%fd;
// the permute type // the permute type
int permute_dim =_grid->PermuteDim(dimension); int permute_dim =_grid->PermuteDim(dimension);
@ -98,6 +92,15 @@ namespace Grid {
int sshift = _grid->CheckerBoardShiftForCB(_checkerboard,dimension,shift,cb); int sshift = _grid->CheckerBoardShiftForCB(_checkerboard,dimension,shift,cb);
int sx = (x+sshift)%rd; int sx = (x+sshift)%rd;
int wraparound=0;
if ( (shiftpm==-1) && (sx>x) ) {
wraparound = 1;
}
if ( (shiftpm== 1) && (sx<x) ) {
wraparound = 1;
}
int permute_slice=0; int permute_slice=0;
if(permute_dim){ if(permute_dim){
@ -107,12 +110,12 @@ namespace Grid {
else permute_slice = 1-wrap; else permute_slice = 1-wrap;
} }
CopyPlane(point,dimension,x,sx,cbmask,permute_slice); CopyPlane(point,dimension,x,sx,cbmask,permute_slice,wraparound);
} }
} }
void CartesianStencil::Comms (int point,int dimension,int shift,int cbmask) void CartesianStencil::Comms (int point,int dimension,int shiftpm,int cbmask)
{ {
GridBase *grid=_grid; GridBase *grid=_grid;
@ -125,7 +128,7 @@ namespace Grid {
// assert(simd_layout==1); // Why? // assert(simd_layout==1); // Why?
assert(comm_dim==1); assert(comm_dim==1);
shift = (shift + fd) %fd; int shift = (shiftpm + fd) %fd;
assert(shift>=0); assert(shift>=0);
assert(shift<fd); assert(shift<fd);
@ -143,10 +146,17 @@ namespace Grid {
// int offnode = (comm_proc!=0); // int offnode = (comm_proc!=0);
int sx = (x+sshift)%rd; int sx = (x+sshift)%rd;
int wraparound=0;
if ( (shiftpm==-1) && (sx>x) && (grid->_processor_coor[dimension]==0) ) {
wraparound = 1;
}
if ( (shiftpm== 1) && (sx<x) && (grid->_processor_coor[dimension]==grid->_processors[dimension]-1) ) {
wraparound = 1;
}
if (!offnode) { if (!offnode) {
int permute_slice=0; int permute_slice=0;
CopyPlane(point,dimension,x,sx,cbmask,permute_slice); CopyPlane(point,dimension,x,sx,cbmask,permute_slice,wraparound);
} else { } else {
@ -161,13 +171,13 @@ namespace Grid {
int unified_buffer_offset = _unified_buffer_size; int unified_buffer_offset = _unified_buffer_size;
_unified_buffer_size += words; _unified_buffer_size += words;
ScatterPlane(point,dimension,x,cbmask,unified_buffer_offset); // permute/extract/merge is done in comms phase ScatterPlane(point,dimension,x,cbmask,unified_buffer_offset,wraparound); // permute/extract/merge is done in comms phase
} }
} }
} }
// Routine builds up integer table for each site in _offsets, _is_local, _permute // Routine builds up integer table for each site in _offsets, _is_local, _permute
void CartesianStencil::CopyPlane(int point, int dimension,int lplane,int rplane,int cbmask,int permute) void CartesianStencil::CopyPlane(int point, int dimension,int lplane,int rplane,int cbmask,int permute,int wrap)
{ {
int rd = _grid->_rdimensions[dimension]; int rd = _grid->_rdimensions[dimension];
@ -180,9 +190,10 @@ namespace Grid {
// Simple block stride gather of SIMD objects // Simple block stride gather of SIMD objects
for(int n=0;n<_grid->_slice_nblock[dimension];n++){ for(int n=0;n<_grid->_slice_nblock[dimension];n++){
for(int b=0;b<_grid->_slice_block[dimension];b++){ for(int b=0;b<_grid->_slice_block[dimension];b++){
_offsets [point][lo+o+b]=ro+o+b; _entries[point][lo+o+b]._offset =ro+o+b;
_is_local[point][lo+o+b]=1; _entries[point][lo+o+b]._is_local=1;
_permute [point][lo+o+b]=permute; _entries[point][lo+o+b]._permute=permute;
_entries[point][lo+o+b]._around_the_world=wrap;
} }
o +=_grid->_slice_stride[dimension]; o +=_grid->_slice_stride[dimension];
} }
@ -199,9 +210,10 @@ namespace Grid {
int ocb=1<<_grid->CheckerBoardFromOindex(o+b); int ocb=1<<_grid->CheckerBoardFromOindex(o+b);
if ( ocb&cbmask ) { if ( ocb&cbmask ) {
_offsets [point][lo+o+b]=ro+o+b; _entries[point][lo+o+b]._offset =ro+o+b;
_is_local[point][lo+o+b]=1; _entries[point][lo+o+b]._is_local=1;
_permute [point][lo+o+b]=permute; _entries[point][lo+o+b]._permute=permute;
_entries[point][lo+o+b]._around_the_world=wrap;
} }
} }
@ -211,7 +223,7 @@ namespace Grid {
} }
} }
// Routine builds up integer table for each site in _offsets, _is_local, _permute // Routine builds up integer table for each site in _offsets, _is_local, _permute
void CartesianStencil::ScatterPlane (int point,int dimension,int plane,int cbmask,int offset) void CartesianStencil::ScatterPlane (int point,int dimension,int plane,int cbmask,int offset, int wrap)
{ {
int rd = _grid->_rdimensions[dimension]; int rd = _grid->_rdimensions[dimension];
@ -224,9 +236,10 @@ namespace Grid {
// Simple block stride gather of SIMD objects // Simple block stride gather of SIMD objects
for(int n=0;n<_grid->_slice_nblock[dimension];n++){ for(int n=0;n<_grid->_slice_nblock[dimension];n++){
for(int b=0;b<_grid->_slice_block[dimension];b++){ for(int b=0;b<_grid->_slice_block[dimension];b++){
_offsets [point][so+o+b]=offset+(bo++); _entries[point][so+o+b]._offset =offset+(bo++);
_is_local[point][so+o+b]=0; _entries[point][so+o+b]._is_local=0;
_permute [point][so+o+b]=0; _entries[point][so+o+b]._permute=0;
_entries[point][so+o+b]._around_the_world=wrap;
} }
o +=_grid->_slice_stride[dimension]; o +=_grid->_slice_stride[dimension];
} }
@ -242,9 +255,10 @@ namespace Grid {
int ocb=1<<_grid->CheckerBoardFromOindex(o+b);// Could easily be a table lookup int ocb=1<<_grid->CheckerBoardFromOindex(o+b);// Could easily be a table lookup
if ( ocb & cbmask ) { if ( ocb & cbmask ) {
_offsets [point][so+o+b]=offset+(bo++); _entries[point][so+o+b]._offset =offset+(bo++);
_is_local[point][so+o+b]=0; _entries[point][so+o+b]._is_local=0;
_permute [point][so+o+b]=0; _entries[point][so+o+b]._permute =0;
_entries[point][so+o+b]._around_the_world=wrap;
} }
} }
o +=_grid->_slice_stride[dimension]; o +=_grid->_slice_stride[dimension];

6
tests/Make.inc
View File

@ -1,5 +1,5 @@
bin_PROGRAMS = Test_GaugeAction Test_cayley_cg Test_cayley_coarsen_support Test_cayley_even_odd Test_cayley_ldop_cr Test_cf_coarsen_support Test_cf_cr_unprec Test_cheby Test_contfrac_cg Test_contfrac_even_odd Test_contfrac_force Test_cshift Test_cshift_red_black Test_dwf_cg_prec Test_dwf_cg_schur Test_dwf_cg_unprec Test_dwf_cr_unprec Test_dwf_even_odd Test_dwf_force Test_dwf_fpgcr Test_dwf_hdcr Test_gamma Test_gparity Test_hmc_EOWilsonFermionGauge Test_hmc_WilsonFermionGauge Test_hmc_WilsonGauge Test_lie_generators Test_main Test_multishift_sqrt Test_nersc_io Test_partfrac_force Test_quenched_update Test_remez Test_rng Test_rng_fixed Test_simd Test_stencil Test_wilson_cg_prec Test_wilson_cg_schur Test_wilson_cg_unprec Test_wilson_cr_unprec Test_wilson_even_odd Test_wilson_force Test_wilson_force_phiMdagMphi Test_wilson_force_phiMphi bin_PROGRAMS = Test_GaugeAction Test_cayley_cg Test_cayley_coarsen_support Test_cayley_even_odd Test_cayley_ldop_cr Test_cf_coarsen_support Test_cf_cr_unprec Test_cheby Test_contfrac_cg Test_contfrac_even_odd Test_contfrac_force Test_cshift Test_cshift_red_black Test_dwf_cg_prec Test_dwf_cg_schur Test_dwf_cg_unprec Test_dwf_cr_unprec Test_dwf_even_odd Test_dwf_force Test_dwf_fpgcr Test_dwf_hdcr Test_gamma Test_gparity Test_gpwilson_even_odd Test_hmc_EOWilsonFermionGauge Test_hmc_WilsonFermionGauge Test_hmc_WilsonGauge Test_lie_generators Test_main Test_multishift_sqrt Test_nersc_io Test_partfrac_force Test_quenched_update Test_remez Test_rng Test_rng_fixed Test_simd Test_stencil Test_wilson_cg_prec Test_wilson_cg_schur Test_wilson_cg_unprec Test_wilson_cr_unprec Test_wilson_even_odd Test_wilson_force Test_wilson_force_phiMdagMphi Test_wilson_force_phiMphi
Test_GaugeAction_SOURCES=Test_GaugeAction.cc Test_GaugeAction_SOURCES=Test_GaugeAction.cc
@ -94,6 +94,10 @@ Test_gparity_SOURCES=Test_gparity.cc
Test_gparity_LDADD=-lGrid Test_gparity_LDADD=-lGrid
Test_gpwilson_even_odd_SOURCES=Test_gpwilson_even_odd.cc
Test_gpwilson_even_odd_LDADD=-lGrid
Test_hmc_EOWilsonFermionGauge_SOURCES=Test_hmc_EOWilsonFermionGauge.cc Test_hmc_EOWilsonFermionGauge_SOURCES=Test_hmc_EOWilsonFermionGauge.cc
Test_hmc_EOWilsonFermionGauge_LDADD=-lGrid Test_hmc_EOWilsonFermionGauge_LDADD=-lGrid

237
tests/Test_gparity.cc
View File

@ -4,26 +4,54 @@ using namespace std;
using namespace Grid; using namespace Grid;
using namespace Grid::QCD; using namespace Grid::QCD;
template<class d> typedef typename GparityDomainWallFermionR::FermionField FermionField;
struct scal {
d internal;
};
Gamma::GammaMatrix Gmu [] = { template<class vobj>
Gamma::GammaX, void Replicate(Lattice<vobj> &coarse,Lattice<vobj> & fine)
Gamma::GammaY, {
Gamma::GammaZ, typedef typename vobj::scalar_object sobj;
Gamma::GammaT
}; GridBase *cg = coarse._grid;
GridBase *fg = fine._grid;
int nd = cg->_ndimension;
subdivides(cg,fg);
assert(cg->_ndimension==fg->_ndimension);
std::vector<int> ratio(cg->_ndimension);
for(int d=0;d<cg->_ndimension;d++){
ratio[d] = fg->_fdimensions[d]/cg->_fdimensions[d];
}
std::vector<int> fcoor(nd);
std::vector<int> ccoor(nd);
for(int g=0;g<fg->gSites();g++){
fg->GlobalIndexToGlobalCoor(g,fcoor);
for(int d=0;d<nd;d++){
ccoor[d] = fcoor[d]%cg->_gdimensions[d];
}
sobj tmp;
peekSite(tmp,coarse,ccoor);
pokeSite(tmp,fine,fcoor);
}
}
int main (int argc, char ** argv) int main (int argc, char ** argv)
{ {
const int nu = 0;
Grid_init(&argc,&argv); Grid_init(&argc,&argv);
const int Ls=4; const int Ls=4;
const int L=4; const int L =4;
std::vector<int> latt_2f(Nd,L); std::vector<int> latt_2f(Nd,L);
std::vector<int> latt_1f(Nd,L); latt_1f[0] = 2L; std::vector<int> latt_1f(Nd,L); latt_1f[nu] = 2*L;
std::vector<int> simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd()); std::vector<int> simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
std::vector<int> mpi_layout = GridDefaultMpi(); //node layout std::vector<int> mpi_layout = GridDefaultMpi(); //node layout
@ -33,30 +61,64 @@ int main (int argc, char ** argv)
GridCartesian * FGrid_1f = SpaceTimeGrid::makeFiveDimGrid(Ls,UGrid_1f); GridCartesian * FGrid_1f = SpaceTimeGrid::makeFiveDimGrid(Ls,UGrid_1f);
GridRedBlackCartesian * FrbGrid_1f = SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls,UGrid_1f); GridRedBlackCartesian * FrbGrid_1f = SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls,UGrid_1f);
GridCartesian * UGrid_2f = SpaceTimeGrid::makeFourDimGrid(latt_2f, simd_layout, mpi_layout);
GridRedBlackCartesian * UrbGrid_2f = SpaceTimeGrid::makeFourDimRedBlackGrid(UGrid_2f);
GridCartesian * FGrid_2f = SpaceTimeGrid::makeFiveDimGrid(Ls,UGrid_2f);
GridRedBlackCartesian * FrbGrid_2f = SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls,UGrid_2f);
std::vector<int> seeds4({1,2,3,4}); std::vector<int> seeds4({1,2,3,4});
std::vector<int> seeds5({5,6,7,8}); std::vector<int> seeds5({5,6,7,8});
GridParallelRNG RNG5_1f(FGrid_1f); RNG5_1f.SeedFixedIntegers(seeds5); GridParallelRNG RNG5_2f(FGrid_2f); RNG5_2f.SeedFixedIntegers(seeds5);
GridParallelRNG RNG4_1f(UGrid_1f); RNG4_1f.SeedFixedIntegers(seeds4); GridParallelRNG RNG4_2f(UGrid_2f); RNG4_2f.SeedFixedIntegers(seeds4);
LatticeGaugeField Umu_2f(UGrid_2f);
SU3::HotConfiguration(RNG4_2f,Umu_2f);
LatticeFermion src (FGrid_2f);
LatticeFermion tmpsrc(FGrid_2f);
FermionField src_2f(FGrid_2f);
LatticeFermion src_1f(FGrid_1f);
// Replicate fermion source
random(RNG5_2f,src);
PokeIndex<0>(src_2f,src,0);
tmpsrc=src*2.0;
PokeIndex<0>(src_2f,tmpsrc,1);
LatticeFermion src_1f(FGrid_1f); random(RNG5_1f,src_1f);
LatticeFermion result_1f(FGrid_1f); result_1f=zero; LatticeFermion result_1f(FGrid_1f); result_1f=zero;
LatticeGaugeField Umu_1f(UGrid_1f); random(RNG4_1f,Umu_1f); LatticeGaugeField Umu_1f(UGrid_1f);
Replicate(Umu_2f,Umu_1f);
//Coordinate grid for reference //Coordinate grid for reference
LatticeInteger xcoor_1f(UGrid_1f); LatticeInteger xcoor_1f(UGrid_1f);
LatticeCoordinate(xcoor_1f,0); LatticeCoordinate(xcoor_1f,nu);
//Copy-conjugate the gauge field //Copy-conjugate the gauge field
//First C-shift the lattice by Lx/2 //First C-shift the lattice by Lx/2
{ {
LatticeGaugeField Umu_shift = conjugate( Cshift(Umu_1f,0,L) ); LatticeGaugeField Umu_shift = conjugate( Cshift(Umu_1f,nu,L) );
Umu_1f = where( xcoor_1f >= Integer(L), Umu_shift, Umu_1f ); Umu_1f = where( xcoor_1f >= Integer(L), Umu_shift, Umu_1f );
// hack test to check the same
Replicate(Umu_2f,Umu_shift);
Umu_shift=Umu_shift-Umu_1f;
cout << GridLogMessage << "Umu diff " << norm2(Umu_shift)<<std::endl;
//Make the gauge field antiperiodic in nu-direction
LatticeColourMatrix Unu(UGrid_1f);
Unu = PeekIndex<LorentzIndex>(Umu_1f,nu);
Unu = where(xcoor_1f == Integer(2*L-1), -Unu, Unu);
PokeIndex<LorentzIndex>(Umu_1f,Unu,nu);
} }
//Make the gauge field antiperiodic in x-direction //Coordinate grid for reference
Umu_1f = where(xcoor_1f == Integer(L-1), -Umu_1f, Umu_1f); LatticeInteger xcoor_1f5(FGrid_1f);
LatticeCoordinate(xcoor_1f5,1+nu);
RealD mass=0.1; Replicate(src,src_1f);
src_1f = where( xcoor_1f5 >= Integer(L), 2.0*src_1f,src_1f );
RealD mass=0.0;
RealD M5=1.8; RealD M5=1.8;
DomainWallFermionR Ddwf(Umu_1f,*FGrid_1f,*FrbGrid_1f,*UGrid_1f,*UrbGrid_1f,mass,M5); DomainWallFermionR Ddwf(Umu_1f,*FGrid_1f,*FrbGrid_1f,*UGrid_1f,*UrbGrid_1f,mass,M5);
@ -69,5 +131,136 @@ int main (int argc, char ** argv)
ConjugateGradient<LatticeFermion> CG(1.0e-8,10000); ConjugateGradient<LatticeFermion> CG(1.0e-8,10000);
CG(HermOpEO,src_o_1f,result_o_1f); CG(HermOpEO,src_o_1f,result_o_1f);
GparityDomainWallFermionR GPDdwf(Umu_2f,*FGrid_2f,*FrbGrid_2f,*UGrid_2f,*UrbGrid_2f,mass,M5);
for(int disp=-1;disp<=1;disp+=2)
for(int mu=0;mu<5;mu++)
{
FermionField Dsrc_2f(FGrid_2f);
LatticeFermion Dsrc_1f(FGrid_1f);
LatticeFermion Dsrc_2freplica(FGrid_1f);
LatticeFermion Dsrc_2freplica0(FGrid_1f);
LatticeFermion Dsrc_2freplica1(FGrid_1f);
if ( mu ==0 ) {
std::cout << GridLogMessage<< " Cross checking entire hopping term"<<std::endl;
GPDdwf.Dhop(src_2f,Dsrc_2f,DaggerNo);
Ddwf.Dhop(src_1f,Dsrc_1f,DaggerNo);
} else {
std::cout << GridLogMessage<< " Cross checking mu="<<mu<< " disp="<< disp<<std::endl;
GPDdwf.DhopDir(src_2f,Dsrc_2f,mu,disp);
Ddwf.DhopDir(src_1f,Dsrc_1f,mu,disp);
}
std::cout << GridLogMessage << "S norms "<< norm2(src_2f) << " " << norm2(src_1f) <<std::endl;
std::cout << GridLogMessage << "D norms "<< norm2(Dsrc_2f)<< " " << norm2(Dsrc_1f) <<std::endl;
LatticeFermion Dsrc_2f0(FGrid_2f); Dsrc_2f0 = PeekIndex<0>(Dsrc_2f,0);
LatticeFermion Dsrc_2f1(FGrid_2f); Dsrc_2f1 = PeekIndex<0>(Dsrc_2f,1);
// Dsrc_2f1 = Dsrc_2f1 - Dsrc_2f0;
// std::cout << GridLogMessage << " Cross check two halves " <<norm2(Dsrc_2f1)<<std::endl;
Replicate(Dsrc_2f0,Dsrc_2freplica0);
Replicate(Dsrc_2f1,Dsrc_2freplica1);
Dsrc_2freplica = where( xcoor_1f5 >= Integer(L), Dsrc_2freplica1,Dsrc_2freplica0 );
Dsrc_2freplica = Dsrc_2freplica - Dsrc_1f ;
std::cout << GridLogMessage << " Cross check against doubled latt " <<norm2(Dsrc_2freplica)<<std::endl;
// std::cout << Dsrc_2f <<std::endl;
}
{
FermionField chi (FGrid_2f); gaussian(RNG5_2f,chi);
FermionField phi (FGrid_2f); gaussian(RNG5_2f,phi);
FermionField chi_e (FrbGrid_2f);
FermionField chi_o (FrbGrid_2f);
FermionField dchi_e (FrbGrid_2f);
FermionField dchi_o (FrbGrid_2f);
FermionField phi_e (FrbGrid_2f);
FermionField phi_o (FrbGrid_2f);
FermionField dphi_e (FrbGrid_2f);
FermionField dphi_o (FrbGrid_2f);
pickCheckerboard(Even,chi_e,chi);
pickCheckerboard(Odd ,chi_o,chi);
pickCheckerboard(Even,phi_e,phi);
pickCheckerboard(Odd ,phi_o,phi);
GPDdwf.Meooe(chi_e,dchi_o);
GPDdwf.Meooe(chi_o,dchi_e);
GPDdwf.MeooeDag(phi_e,dphi_o);
GPDdwf.MeooeDag(phi_o,dphi_e);
ComplexD pDce = innerProduct(phi_e,dchi_e);
ComplexD pDco = innerProduct(phi_o,dchi_o);
ComplexD cDpe = innerProduct(chi_e,dphi_e);
ComplexD cDpo = innerProduct(chi_o,dphi_o);
std::cout<<GridLogMessage <<"e "<<pDce<<" "<<cDpe <<std::endl;
std::cout<<GridLogMessage <<"o "<<pDco<<" "<<cDpo <<std::endl;
std::cout<<GridLogMessage <<"pDce - conj(cDpo) "<< pDce-conj(cDpo) <<std::endl;
std::cout<<GridLogMessage <<"pDco - conj(cDpe) "<< pDco-conj(cDpe) <<std::endl;
}
FermionField result_2f(FGrid_2f); result_2f=zero;
FermionField src_o_2f(FrbGrid_2f);
FermionField result_o_2f(FrbGrid_2f);
pickCheckerboard(Odd,src_o_2f,src_2f);
result_o_2f=zero;
ConjugateGradient<FermionField> CG2f(1.0e-8,10000);
SchurDiagMooeeOperator<GparityDomainWallFermionR,FermionField> HermOpEO2f(GPDdwf);
CG2f(HermOpEO2f,src_o_2f,result_o_2f);
std::cout << "2f cb "<<result_o_2f.checkerboard<<std::endl;
std::cout << "1f cb "<<result_o_1f.checkerboard<<std::endl;
std::cout << " result norms " <<norm2(result_o_2f)<<" " <<norm2(result_o_1f)<<std::endl;
LatticeFermion res0o (FrbGrid_2f);
LatticeFermion res1o (FrbGrid_2f);
LatticeFermion res0 (FGrid_2f);
LatticeFermion res1 (FGrid_2f);
res0=zero;
res1=zero;
res0o = PeekIndex<0>(result_o_2f,0);
res1o = PeekIndex<0>(result_o_2f,1);
std::cout << "res cb "<<res0o.checkerboard<<std::endl;
std::cout << "res cb "<<res1o.checkerboard<<std::endl;
setCheckerboard(res0,res0o);
setCheckerboard(res1,res1o);
LatticeFermion replica (FGrid_1f);
LatticeFermion replica0(FGrid_1f);
LatticeFermion replica1(FGrid_1f);
Replicate(res0,replica0);
Replicate(res1,replica1);
replica = where( xcoor_1f5 >= Integer(L), replica1,replica0 );
replica0 = zero;
setCheckerboard(replica0,result_o_1f);
std::cout << "Norm2 solutions is " <<norm2(replica)<<" "<< norm2(replica0)<<std::endl;
replica = replica - replica0;
std::cout << "Norm2 of difference in solutions is " <<norm2(replica)<<std::endl;
Grid_finalize(); Grid_finalize();
} }

20
tests/Test_stencil.cc
View File

@ -56,17 +56,17 @@ int main (int argc, char ** argv)
// Implement a stencil code that should agree with cshift! // Implement a stencil code that should agree with cshift!
for(int i=0;i<Check._grid->oSites();i++){ for(int i=0;i<Check._grid->oSites();i++){
int offset = myStencil._offsets [0][i]; int permute_type;
int local = myStencil._is_local[0][i]; StencilEntry *SE;
int permute_type = myStencil._permute_type[0]; SE = myStencil.GetEntry(permute_type,0,i);
int perm =myStencil._permute[0][i];
if ( local && perm ) if ( SE->_is_local && SE->_permute )
permute(Check._odata[i],Foo._odata[offset],permute_type); permute(Check._odata[i],Foo._odata[SE->_offset],permute_type);
else if (local) else if (SE->_is_local)
Check._odata[i] = Foo._odata[offset]; Check._odata[i] = Foo._odata[SE->_offset];
else else
Check._odata[i] = comm_buf[offset]; Check._odata[i] = comm_buf[SE->_offset];
} }
Real nrmC = norm2(Check); Real nrmC = norm2(Check);