mirror of
https://github.com/paboyle/Grid.git
synced 2025-06-12 20:27:06 +01:00
Merge branch 'feature/hadrons' into feature/qed-fvol
This commit is contained in:
@ -149,11 +149,11 @@ void WilsonFermion<Impl>::MeooeDag(const FermionField &in, FermionField &out) {
|
||||
|
||||
typedef Lattice<iSinglet<vector_type> > LatComplex;
|
||||
|
||||
Gamma::GammaMatrix Gmu [] = {
|
||||
Gamma::GammaX,
|
||||
Gamma::GammaY,
|
||||
Gamma::GammaZ,
|
||||
Gamma::GammaT
|
||||
Gamma::Algebra Gmu [] = {
|
||||
Gamma::Algebra::GammaX,
|
||||
Gamma::Algebra::GammaY,
|
||||
Gamma::Algebra::GammaZ,
|
||||
Gamma::Algebra::GammaT
|
||||
};
|
||||
|
||||
std::vector<int> latt_size = _grid->_fdimensions;
|
||||
|
||||
@ -503,11 +503,11 @@ void WilsonFermion5D<Impl>::MomentumSpacePropagatorHt(FermionField &out,const Fe
|
||||
typedef iSinglet<ScalComplex> Tcomplex;
|
||||
typedef Lattice<iSinglet<vector_type> > LatComplex;
|
||||
|
||||
Gamma::GammaMatrix Gmu [] = {
|
||||
Gamma::GammaX,
|
||||
Gamma::GammaY,
|
||||
Gamma::GammaZ,
|
||||
Gamma::GammaT
|
||||
Gamma::Algebra Gmu [] = {
|
||||
Gamma::Algebra::GammaX,
|
||||
Gamma::Algebra::GammaY,
|
||||
Gamma::Algebra::GammaZ,
|
||||
Gamma::Algebra::GammaT
|
||||
};
|
||||
|
||||
std::vector<int> latt_size = _grid->_fdimensions;
|
||||
@ -574,11 +574,11 @@ void WilsonFermion5D<Impl>::MomentumSpacePropagatorHt(FermionField &out,const Fe
|
||||
template<class Impl>
|
||||
void WilsonFermion5D<Impl>::MomentumSpacePropagatorHw(FermionField &out,const FermionField &in,RealD mass)
|
||||
{
|
||||
Gamma::GammaMatrix Gmu [] = {
|
||||
Gamma::GammaX,
|
||||
Gamma::GammaY,
|
||||
Gamma::GammaZ,
|
||||
Gamma::GammaT
|
||||
Gamma::Algebra Gmu [] = {
|
||||
Gamma::Algebra::GammaX,
|
||||
Gamma::Algebra::GammaY,
|
||||
Gamma::Algebra::GammaZ,
|
||||
Gamma::Algebra::GammaT
|
||||
};
|
||||
|
||||
GridBase *_grid = _FourDimGrid;
|
||||
|
||||
@ -80,7 +80,7 @@ class Gamma5HermitianLinearOperator : public LinearOperatorBase<Field> {
|
||||
Matrix &_Mat;
|
||||
Gamma g5;
|
||||
public:
|
||||
Gamma5HermitianLinearOperator(Matrix &Mat): _Mat(Mat), g5(Gamma::Gamma5) {};
|
||||
Gamma5HermitianLinearOperator(Matrix &Mat): _Mat(Mat), g5(Gamma::Algebra::Gamma5) {};
|
||||
void Op (const Field &in, Field &out){
|
||||
HermOp(in,out);
|
||||
}
|
||||
|
||||
@ -1,95 +0,0 @@
|
||||
/*************************************************************************************
|
||||
|
||||
Grid physics library, www.github.com/paboyle/Grid
|
||||
|
||||
Source file: ./lib/qcd/spin/Dirac.cc
|
||||
|
||||
Copyright (C) 2015
|
||||
|
||||
Author: Peter Boyle <paboyle@ph.ed.ac.uk>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
|
||||
See the full license in the file "LICENSE" in the top level distribution directory
|
||||
*************************************************************************************/
|
||||
/* END LEGAL */
|
||||
#include <Grid/Grid.h>
|
||||
|
||||
namespace Grid {
|
||||
|
||||
namespace QCD {
|
||||
|
||||
Gamma::GammaMatrix Gamma::GammaMatrices [] = {
|
||||
Gamma::Identity,
|
||||
Gamma::GammaX,
|
||||
Gamma::GammaY,
|
||||
Gamma::GammaZ,
|
||||
Gamma::GammaT,
|
||||
Gamma::Gamma5,
|
||||
Gamma::MinusIdentity,
|
||||
Gamma::MinusGammaX,
|
||||
Gamma::MinusGammaY,
|
||||
Gamma::MinusGammaZ,
|
||||
Gamma::MinusGammaT,
|
||||
Gamma::MinusGamma5
|
||||
};
|
||||
const char *Gamma::GammaMatrixNames[] = {
|
||||
"Identity ",
|
||||
"GammaX ",
|
||||
"GammaY ",
|
||||
"GammaZ ",
|
||||
"GammaT ",
|
||||
"Gamma5 ",
|
||||
"-Identity",
|
||||
"-GammaX ",
|
||||
"-GammaY ",
|
||||
"-GammaZ ",
|
||||
"-GammaT ",
|
||||
"-Gamma5 ",
|
||||
" "
|
||||
};
|
||||
|
||||
SpinMatrix makeGammaProd(const unsigned int i)
|
||||
{
|
||||
SpinMatrix g;
|
||||
|
||||
g = 1.;
|
||||
if (i & 0x1)
|
||||
{
|
||||
g = g*Gamma(Gamma::GammaMatrix::GammaX);
|
||||
}
|
||||
if (i & 0x2)
|
||||
{
|
||||
g = g*Gamma(Gamma::GammaMatrix::GammaY);
|
||||
}
|
||||
if (i & 0x4)
|
||||
{
|
||||
g = g*Gamma(Gamma::GammaMatrix::GammaZ);
|
||||
}
|
||||
if (i & 0x8)
|
||||
{
|
||||
g = g*Gamma(Gamma::GammaMatrix::GammaT);
|
||||
}
|
||||
|
||||
return g;
|
||||
}
|
||||
|
||||
// void sprojMul( vHalfSpinColourVector &out,vColourMatrix &u, vSpinColourVector &in){
|
||||
// vHalfSpinColourVector hspin;
|
||||
// spProjXp(hspin,in);
|
||||
// mult(&out,&u,&hspin);
|
||||
// }
|
||||
}
|
||||
}
|
||||
@ -1,628 +1,232 @@
|
||||
/*************************************************************************************
|
||||
/*************************************************************************************
|
||||
|
||||
Grid physics library, www.github.com/paboyle/Grid
|
||||
Grid physics library, www.github.com/paboyle/Grid
|
||||
|
||||
Source file: ./lib/qcd/spin/Dirac.h
|
||||
Source file: lib/qcd/spin/Dirac.h
|
||||
|
||||
Copyright (C) 2015
|
||||
Copyright (C) 2015
|
||||
Copyright (C) 2016
|
||||
|
||||
Author: Antonin Portelli <antonin.portelli@me.com>
|
||||
Author: Peter Boyle <paboyle@ph.ed.ac.uk>
|
||||
Author: Peter Boyle <peterboyle@Peters-MacBook-Pro-2.local>
|
||||
Author: paboyle <paboyle@ph.ed.ac.uk>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
You should have received a copy of the GNU General Public License along
|
||||
with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
|
||||
See the full license in the file "LICENSE" in the top level distribution directory
|
||||
*************************************************************************************/
|
||||
/* END LEGAL */
|
||||
See the full license in the file "LICENSE" in the top level distribution directory
|
||||
*************************************************************************************/
|
||||
/* END LEGAL */
|
||||
#ifndef GRID_QCD_DIRAC_H
|
||||
#define GRID_QCD_DIRAC_H
|
||||
namespace Grid{
|
||||
|
||||
// Gamma matrices using the code generated by the Mathematica notebook
|
||||
// gamma-gen/gamma-gen.nb in Gamma.cc & Gamma.h
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
#include <Grid/qcd/spin/Gamma.h>
|
||||
|
||||
namespace Grid {
|
||||
|
||||
// Dirac algebra adjoint operator (not in QCD:: to overload other adj)
|
||||
inline QCD::Gamma adj(const QCD::Gamma &g)
|
||||
{
|
||||
return QCD::Gamma (QCD::Gamma::adj[g.g]);
|
||||
}
|
||||
|
||||
namespace QCD {
|
||||
|
||||
// Dirac algebra mutliplication operator
|
||||
inline Gamma operator*(const Gamma &g1, const Gamma &g2)
|
||||
{
|
||||
return Gamma (Gamma::mul[g1.g][g2.g]);
|
||||
}
|
||||
|
||||
class Gamma {
|
||||
// general left multiply
|
||||
template<class vtype>
|
||||
inline auto operator*(const Gamma &G, const iScalar<vtype> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iScalar<vtype>,SpinorIndex>::notvalue,iScalar<vtype>>::type
|
||||
{
|
||||
iScalar<vtype> ret;
|
||||
ret._internal=G*arg._internal;
|
||||
return ret;
|
||||
}
|
||||
|
||||
public:
|
||||
template<class vtype,int N>
|
||||
inline auto operator*(const Gamma &G, const iVector<vtype, N> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iVector<vtype,N>,SpinorIndex>::notvalue,iVector<vtype,N>>::type
|
||||
{
|
||||
iVector<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
ret._internal[i]=G*arg._internal[i];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
const int Ns=4;
|
||||
|
||||
enum GammaMatrix {
|
||||
Identity,
|
||||
GammaX,
|
||||
GammaY,
|
||||
GammaZ,
|
||||
GammaT,
|
||||
Gamma5,
|
||||
MinusIdentity,
|
||||
MinusGammaX,
|
||||
MinusGammaY,
|
||||
MinusGammaZ,
|
||||
MinusGammaT,
|
||||
MinusGamma5
|
||||
// GammaXGamma5, // Rest are composite (willing to take hit for two calls sequentially)
|
||||
// GammaYGamma5, // as they are less commonly used.
|
||||
// GammaZGamma5,
|
||||
// GammaTGamma5,
|
||||
// SigmaXY,
|
||||
// SigmaXZ,
|
||||
// SigmaYZ,
|
||||
// SigmaXT,
|
||||
// SigmaYT,
|
||||
// SigmaZT,
|
||||
// MinusGammaXGamma5, easiest to form by composition
|
||||
// MinusGammaYGamma5, as performance is not critical for these
|
||||
// MinusGammaZGamma5,
|
||||
// MinusGammaTGamma5,
|
||||
// MinusSigmaXY,
|
||||
// MinusSigmaXZ,
|
||||
// MinusSigmaYZ,
|
||||
// MinusSigmaXT,
|
||||
// MinusSigmaYT,
|
||||
// MinusSigmaZT
|
||||
};
|
||||
|
||||
static GammaMatrix GammaMatrices[];
|
||||
static const char *GammaMatrixNames[];
|
||||
template<class vtype, int N>
|
||||
inline auto operator*(const Gamma &G, const iMatrix<vtype, N> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,N>,SpinorIndex>::notvalue,iMatrix<vtype,N>>::type
|
||||
{
|
||||
iMatrix<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
ret._internal[i][j]=G*arg._internal[i][j];
|
||||
}}
|
||||
return ret;
|
||||
}
|
||||
|
||||
Gamma (GammaMatrix g) { _g=g; }
|
||||
// general right multiply
|
||||
template<class vtype>
|
||||
inline auto operator*(const iScalar<vtype> &arg, const Gamma &G)
|
||||
->typename std::enable_if<matchGridTensorIndex<iScalar<vtype>,SpinorIndex>::notvalue,iScalar<vtype>>::type
|
||||
{
|
||||
iScalar<vtype> ret;
|
||||
ret._internal=arg._internal*G;
|
||||
return ret;
|
||||
}
|
||||
|
||||
GammaMatrix _g;
|
||||
template<class vtype, int N>
|
||||
inline auto operator * (const iMatrix<vtype, N> &arg, const Gamma &G)
|
||||
->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,N>,SpinorIndex>::notvalue,iMatrix<vtype,N>>::type
|
||||
{
|
||||
iMatrix<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
ret._internal[i][j]=arg._internal[i][j]*G;
|
||||
}}
|
||||
return ret;
|
||||
}
|
||||
|
||||
};
|
||||
// Gamma-left matrices gL_mu = g_mu*(1 - g5)
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
class GammaL
|
||||
{
|
||||
public:
|
||||
typedef Gamma::Algebra Algebra;
|
||||
Gamma gamma;
|
||||
public:
|
||||
GammaL(const Algebra initg): gamma(initg) {}
|
||||
GammaL(const Gamma initg): gamma(initg) {}
|
||||
};
|
||||
|
||||
// vector multiply
|
||||
template<class vtype>
|
||||
inline auto operator*(const GammaL &gl, const iVector<vtype, Ns> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iVector<vtype, Ns>, SpinorIndex>::value, iVector<vtype, Ns>>::type
|
||||
{
|
||||
iVector<vtype, Ns> buf;
|
||||
|
||||
// Make gamma products (Chroma convention)
|
||||
SpinMatrix makeGammaProd(const unsigned int i);
|
||||
|
||||
/* Gx
|
||||
* 0 0 0 i
|
||||
* 0 0 i 0
|
||||
* 0 -i 0 0
|
||||
* -i 0 0 0
|
||||
*/
|
||||
// right multiplication makes sense for matrix args, not for vector since there is
|
||||
// no concept of row versus columnar indices
|
||||
template<class vtype> inline void rmultMinusGammaX(iMatrix<vtype,Ns> &ret,const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = timesI(rhs(i,3));
|
||||
ret(i,1) = timesI(rhs(i,2));
|
||||
ret(i,2) = timesMinusI(rhs(i,1));
|
||||
ret(i,3) = timesMinusI(rhs(i,0));
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void rmultGammaX(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = timesMinusI(rhs(i,3));
|
||||
ret(i,1) = timesMinusI(rhs(i,2));
|
||||
ret(i,2) = timesI(rhs(i,1));
|
||||
ret(i,3) = timesI(rhs(i,0));
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multGammaX(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = timesI(rhs(3,i));
|
||||
ret(1,i) = timesI(rhs(2,i));
|
||||
ret(2,i) = timesMinusI(rhs(1,i));
|
||||
ret(3,i) = timesMinusI(rhs(0,i));
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaX(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = timesMinusI(rhs(3,i));
|
||||
ret(1,i) = timesMinusI(rhs(2,i));
|
||||
ret(2,i) = timesI(rhs(1,i));
|
||||
ret(3,i) = timesI(rhs(0,i));
|
||||
}
|
||||
};
|
||||
buf(0) = 0.;
|
||||
buf(1) = 0.;
|
||||
buf(2) = 2.*arg(2);
|
||||
buf(3) = 2.*arg(3);
|
||||
|
||||
return gl.gamma*buf;
|
||||
};
|
||||
|
||||
template<class vtype> inline void multGammaX(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret._internal[0] = timesI(rhs._internal[3]);
|
||||
ret._internal[1] = timesI(rhs._internal[2]);
|
||||
ret._internal[2] = timesMinusI(rhs._internal[1]);
|
||||
ret._internal[3] = timesMinusI(rhs._internal[0]);
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaX(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) = timesMinusI(rhs(3));
|
||||
ret(1) = timesMinusI(rhs(2));
|
||||
ret(2) = timesI(rhs(1));
|
||||
ret(3) = timesI(rhs(0));
|
||||
};
|
||||
// matrix left multiply
|
||||
template<class vtype>
|
||||
inline auto operator*(const GammaL &gl, const iMatrix<vtype, Ns> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype, Ns>, SpinorIndex>::value, iMatrix<vtype, Ns>>::type
|
||||
{
|
||||
iMatrix<vtype, Ns> buf;
|
||||
|
||||
for(unsigned int i = 0; i < Ns; ++i)
|
||||
{
|
||||
buf(0, i) = 0.;
|
||||
buf(1, i) = 0.;
|
||||
buf(2, i) = 2.*arg(2, i);
|
||||
buf(3, i) = 2.*arg(3, i);
|
||||
}
|
||||
|
||||
return gl.gamma*buf;
|
||||
};
|
||||
|
||||
// matrix right multiply
|
||||
template<class vtype>
|
||||
inline auto operator*(const iMatrix<vtype, Ns> &arg, const GammaL &gl)
|
||||
->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype, Ns>, SpinorIndex>::value, iMatrix<vtype, Ns>>::type
|
||||
{
|
||||
iMatrix<vtype, Ns> buf;
|
||||
|
||||
buf = arg*gl.gamma;
|
||||
for(unsigned int i = 0; i < Ns; ++i)
|
||||
{
|
||||
buf(i, 0) = 0.;
|
||||
buf(i, 1) = 0.;
|
||||
buf(i, 2) = 2.*buf(i, 2);
|
||||
buf(i, 3) = 2.*buf(i, 3);
|
||||
}
|
||||
|
||||
return buf;
|
||||
};
|
||||
|
||||
/*Gy
|
||||
* 0 0 0 -1 [0] -+ [3]
|
||||
* 0 0 1 0 [1] +- [2]
|
||||
* 0 1 0 0
|
||||
* -1 0 0 0
|
||||
*/
|
||||
template<class vtype> inline void rmultGammaY(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = -rhs(i,3);
|
||||
ret(i,1) = rhs(i,2);
|
||||
ret(i,2) = rhs(i,1);
|
||||
ret(i,3) = -rhs(i,0);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void rmultMinusGammaY(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = rhs(i,3);
|
||||
ret(i,1) = -rhs(i,2);
|
||||
ret(i,2) = -rhs(i,1);
|
||||
ret(i,3) = rhs(i,0);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multGammaY(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = -rhs(3,i);
|
||||
ret(1,i) = rhs(2,i);
|
||||
ret(2,i) = rhs(1,i);
|
||||
ret(3,i) = -rhs(0,i);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaY(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = rhs(3,i);
|
||||
ret(1,i) = -rhs(2,i);
|
||||
ret(2,i) = -rhs(1,i);
|
||||
ret(3,i) = rhs(0,i);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multGammaY(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) = -rhs(3);
|
||||
ret(1) = rhs(2);
|
||||
ret(2) = rhs(1);
|
||||
ret(3) = -rhs(0);
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaY(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) = rhs(3);
|
||||
ret(1) = -rhs(2);
|
||||
ret(2) = -rhs(1);
|
||||
ret(3) = rhs(0);
|
||||
};
|
||||
/*Gz
|
||||
* 0 0 i 0 [0]+-i[2]
|
||||
* 0 0 0 -i [1]-+i[3]
|
||||
* -i 0 0 0
|
||||
* 0 i 0 0
|
||||
*/
|
||||
template<class vtype> inline void rmultGammaZ(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = timesMinusI(rhs(i,2));
|
||||
ret(i,1) = timesI(rhs(i,3));
|
||||
ret(i,2) = timesI(rhs(i,0));
|
||||
ret(i,3) = timesMinusI(rhs(i,1));
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void rmultMinusGammaZ(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = timesI(rhs(i,2));
|
||||
ret(i,1) = timesMinusI(rhs(i,3));
|
||||
ret(i,2) = timesMinusI(rhs(i,0));
|
||||
ret(i,3) = timesI(rhs(i,1));
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multGammaZ(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = timesI(rhs(2,i));
|
||||
ret(1,i) =timesMinusI(rhs(3,i));
|
||||
ret(2,i) =timesMinusI(rhs(0,i));
|
||||
ret(3,i) = timesI(rhs(1,i));
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaZ(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = timesMinusI(rhs(2,i));
|
||||
ret(1,i) = timesI(rhs(3,i));
|
||||
ret(2,i) = timesI(rhs(0,i));
|
||||
ret(3,i) = timesMinusI(rhs(1,i));
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multGammaZ(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) = timesI(rhs(2));
|
||||
ret(1) =timesMinusI(rhs(3));
|
||||
ret(2) =timesMinusI(rhs(0));
|
||||
ret(3) = timesI(rhs(1));
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaZ(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) = timesMinusI(rhs(2));
|
||||
ret(1) = timesI(rhs(3));
|
||||
ret(2) = timesI(rhs(0));
|
||||
ret(3) = timesMinusI(rhs(1));
|
||||
};
|
||||
/*Gt
|
||||
* 0 0 1 0 [0]+-[2]
|
||||
* 0 0 0 1 [1]+-[3]
|
||||
* 1 0 0 0
|
||||
* 0 1 0 0
|
||||
*/
|
||||
template<class vtype> inline void rmultGammaT(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = rhs(i,2);
|
||||
ret(i,1) = rhs(i,3);
|
||||
ret(i,2) = rhs(i,0);
|
||||
ret(i,3) = rhs(i,1);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void rmultMinusGammaT(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) =- rhs(i,2);
|
||||
ret(i,1) =- rhs(i,3);
|
||||
ret(i,2) =- rhs(i,0);
|
||||
ret(i,3) =- rhs(i,1);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multGammaT(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = rhs(2,i);
|
||||
ret(1,i) = rhs(3,i);
|
||||
ret(2,i) = rhs(0,i);
|
||||
ret(3,i) = rhs(1,i);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaT(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) =-rhs(2,i);
|
||||
ret(1,i) =-rhs(3,i);
|
||||
ret(2,i) =-rhs(0,i);
|
||||
ret(3,i) =-rhs(1,i);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multGammaT(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) = rhs(2);
|
||||
ret(1) = rhs(3);
|
||||
ret(2) = rhs(0);
|
||||
ret(3) = rhs(1);
|
||||
};
|
||||
template<class vtype> inline void multMinusGammaT(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) =-rhs(2);
|
||||
ret(1) =-rhs(3);
|
||||
ret(2) =-rhs(0);
|
||||
ret(3) =-rhs(1);
|
||||
};
|
||||
/*G5
|
||||
* 1 0 0 0 [0]+-[2]
|
||||
* 0 1 0 0 [1]+-[3]
|
||||
* 0 0 -1 0
|
||||
* 0 0 0 -1
|
||||
*/
|
||||
template<class vtype> inline void rmultGamma5(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) = rhs(i,0);
|
||||
ret(i,1) = rhs(i,1);
|
||||
ret(i,2) =-rhs(i,2);
|
||||
ret(i,3) =-rhs(i,3);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void rmultMinusGamma5(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(i,0) =-rhs(i,0);
|
||||
ret(i,1) =-rhs(i,1);
|
||||
ret(i,2) = rhs(i,2);
|
||||
ret(i,3) = rhs(i,3);
|
||||
}
|
||||
};
|
||||
//general left multiply
|
||||
template<class vtype>
|
||||
inline auto operator*(const GammaL &gl, const iScalar<vtype> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iScalar<vtype>,SpinorIndex>::notvalue,iScalar<vtype>>::type
|
||||
{
|
||||
iScalar<vtype> ret;
|
||||
ret._internal=gl*arg._internal;
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<class vtype> inline void multGamma5(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) = rhs(0,i);
|
||||
ret(1,i) = rhs(1,i);
|
||||
ret(2,i) =-rhs(2,i);
|
||||
ret(3,i) =-rhs(3,i);
|
||||
}
|
||||
};
|
||||
template<class vtype> inline void multMinusGamma5(iMatrix<vtype,Ns> &ret, const iMatrix<vtype,Ns> &rhs){
|
||||
for(int i=0;i<Ns;i++){
|
||||
ret(0,i) =-rhs(0,i);
|
||||
ret(1,i) =-rhs(1,i);
|
||||
ret(2,i) = rhs(2,i);
|
||||
ret(3,i) = rhs(3,i);
|
||||
}
|
||||
};
|
||||
template<class vtype,int N>
|
||||
inline auto operator*(const GammaL &gl, const iVector<vtype, N> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iVector<vtype,N>,SpinorIndex>::notvalue,iVector<vtype,N>>::type
|
||||
{
|
||||
iVector<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
ret._internal[i]=gl*arg._internal[i];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<class vtype> inline void multGamma5(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) = rhs(0);
|
||||
ret(1) = rhs(1);
|
||||
ret(2) =-rhs(2);
|
||||
ret(3) =-rhs(3);
|
||||
};
|
||||
template<class vtype> inline void multMinusGamma5(iVector<vtype,Ns> &ret, const iVector<vtype,Ns> &rhs){
|
||||
ret(0) =-rhs(0);
|
||||
ret(1) =-rhs(1);
|
||||
ret(2) = rhs(2);
|
||||
ret(3) = rhs(3);
|
||||
};
|
||||
template<class vtype, int N>
|
||||
inline auto operator*(const GammaL &gl, const iMatrix<vtype, N> &arg)
|
||||
->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,N>,SpinorIndex>::notvalue,iMatrix<vtype,N>>::type
|
||||
{
|
||||
iMatrix<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
ret._internal[i][j]=gl*arg._internal[i][j];
|
||||
}}
|
||||
return ret;
|
||||
}
|
||||
|
||||
//general right multiply
|
||||
template<class vtype>
|
||||
inline auto operator*(const iScalar<vtype> &arg, const GammaL &gl)
|
||||
->typename std::enable_if<matchGridTensorIndex<iScalar<vtype>,SpinorIndex>::notvalue,iScalar<vtype>>::type
|
||||
{
|
||||
iScalar<vtype> ret;
|
||||
ret._internal=arg._internal*gl;
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<class vtype, int N>
|
||||
inline auto operator * (const iMatrix<vtype, N> &arg, const GammaL &gl)
|
||||
->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,N>,SpinorIndex>::notvalue,iMatrix<vtype,N>>::type
|
||||
{
|
||||
iMatrix<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
ret._internal[i][j]=arg._internal[i][j]*gl;
|
||||
}}
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifdef GRID_WARN_SUBOPTIMAL
|
||||
#warning "Optimisation alert switch over to multGammaX early "
|
||||
#endif
|
||||
}}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Operator * : first case this is not a spin index, so recurse
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// FIXME
|
||||
//
|
||||
// Optimisation; switch over to a "multGammaX(ret._internal,arg._internal)" style early and
|
||||
// note that doing so from the lattice operator will avoid copy back and case switch overhead, as
|
||||
// was done for the tensor math operator to remove operator * notation early
|
||||
//
|
||||
|
||||
//left multiply
|
||||
template<class vtype> inline auto operator * ( const Gamma &G,const iScalar<vtype> &arg) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iScalar<vtype>,SpinorIndex>::notvalue,iScalar<vtype> >::type
|
||||
|
||||
{
|
||||
iScalar<vtype> ret;
|
||||
ret._internal=G*arg._internal;
|
||||
return ret;
|
||||
}
|
||||
template<class vtype,int N> inline auto operator * ( const Gamma &G,const iVector<vtype,N> &arg) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iVector<vtype,N>,SpinorIndex>::notvalue,iVector<vtype,N> >::type
|
||||
{
|
||||
iVector<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
ret._internal[i]=G*arg._internal[i];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
template<class vtype,int N> inline auto operator * ( const Gamma &G,const iMatrix<vtype,N> &arg) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,N>,SpinorIndex>::notvalue,iMatrix<vtype,N> >::type
|
||||
{
|
||||
iMatrix<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
ret._internal[i][j]=G*arg._internal[i][j];
|
||||
}}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
//right multiply
|
||||
template<class vtype> inline auto operator * (const iScalar<vtype> &arg, const Gamma &G) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iScalar<vtype>,SpinorIndex>::notvalue,iScalar<vtype> >::type
|
||||
|
||||
{
|
||||
iScalar<vtype> ret;
|
||||
ret._internal=arg._internal*G;
|
||||
return ret;
|
||||
}
|
||||
template<class vtype,int N> inline auto operator * (const iVector<vtype,N> &arg, const Gamma &G) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iVector<vtype,N>,SpinorIndex>::notvalue,iVector<vtype,N> >::type
|
||||
{
|
||||
iVector<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
ret._internal=arg._internal[i]*G;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
template<class vtype,int N> inline auto operator * (const iMatrix<vtype,N> &arg, const Gamma &G) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,N>,SpinorIndex>::notvalue,iMatrix<vtype,N> >::type
|
||||
{
|
||||
iMatrix<vtype,N> ret;
|
||||
for(int i=0;i<N;i++){
|
||||
for(int j=0;j<N;j++){
|
||||
ret._internal[i][j]=arg._internal[i][j]*G;
|
||||
}}
|
||||
return ret;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////
|
||||
// When we hit the spin index this matches and we stop
|
||||
////////////////////////////////////////////////////////
|
||||
template<class vtype> inline auto operator * ( const Gamma &G,const iMatrix<vtype,Ns> &arg) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,Ns>,SpinorIndex>::value,iMatrix<vtype,Ns> >::type
|
||||
{
|
||||
iMatrix<vtype,Ns> ret;
|
||||
switch (G._g) {
|
||||
case Gamma::Identity:
|
||||
ret = arg;
|
||||
break;
|
||||
case Gamma::MinusIdentity:
|
||||
ret = -arg;
|
||||
break;
|
||||
case Gamma::GammaX:
|
||||
multGammaX(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaX:
|
||||
multMinusGammaX(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaY:
|
||||
multGammaY(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaY:
|
||||
multMinusGammaY(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaZ:
|
||||
multGammaZ(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaZ:
|
||||
multMinusGammaZ(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaT:
|
||||
multGammaT(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaT:
|
||||
multMinusGammaT(ret,arg);
|
||||
break;
|
||||
case Gamma::Gamma5:
|
||||
multGamma5(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGamma5:
|
||||
multMinusGamma5(ret,arg);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
// Could have used type trait for Matrix/vector and then an enable if to share code
|
||||
template<class vtype> inline auto operator * ( const Gamma &G,const iVector<vtype,Ns> &arg) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iVector<vtype,Ns>,SpinorIndex>::value,iVector<vtype,Ns> >::type
|
||||
{
|
||||
iVector<vtype,Ns> ret;
|
||||
switch (G._g) {
|
||||
case Gamma::Identity:
|
||||
ret = arg;
|
||||
break;
|
||||
case Gamma::MinusIdentity:
|
||||
ret = -arg;
|
||||
break;
|
||||
case Gamma::GammaX:
|
||||
multGammaX(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaX:
|
||||
multMinusGammaX(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaY:
|
||||
multGammaY(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaY:
|
||||
multMinusGammaY(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaZ:
|
||||
multGammaZ(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaZ:
|
||||
multMinusGammaZ(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaT:
|
||||
multGammaT(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaT:
|
||||
multMinusGammaT(ret,arg);
|
||||
break;
|
||||
case Gamma::Gamma5:
|
||||
multGamma5(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGamma5:
|
||||
multMinusGamma5(ret,arg);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
template<class vtype> inline auto operator * (const iMatrix<vtype,Ns> &arg, const Gamma &G) ->
|
||||
typename std::enable_if<matchGridTensorIndex<iMatrix<vtype,Ns>,SpinorIndex>::value,iMatrix<vtype,Ns> >::type
|
||||
{
|
||||
iMatrix<vtype,Ns> ret;
|
||||
switch (G._g) {
|
||||
case Gamma::Identity:
|
||||
ret = arg;
|
||||
break;
|
||||
case Gamma::MinusIdentity:
|
||||
ret = -arg;
|
||||
break;
|
||||
case Gamma::GammaX:
|
||||
rmultGammaX(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaX:
|
||||
rmultMinusGammaX(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaY:
|
||||
rmultGammaY(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaY:
|
||||
rmultMinusGammaY(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaZ:
|
||||
rmultGammaZ(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaZ:
|
||||
rmultMinusGammaZ(ret,arg);
|
||||
break;
|
||||
case Gamma::GammaT:
|
||||
rmultGammaT(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGammaT:
|
||||
rmultMinusGammaT(ret,arg);
|
||||
break;
|
||||
case Gamma::Gamma5:
|
||||
rmultGamma5(ret,arg);
|
||||
break;
|
||||
case Gamma::MinusGamma5:
|
||||
rmultMinusGamma5(ret,arg);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
/* Output from test
|
||||
./Grid_gamma
|
||||
Identity((1,0),(0,0),(0,0),(0,0))
|
||||
((0,0),(1,0),(0,0),(0,0))
|
||||
((0,0),(0,0),(1,0),(0,0))
|
||||
((0,0),(0,0),(0,0),(1,0)) OK
|
||||
|
||||
GammaX ((0,0),(0,0),(0,0),(0,1))
|
||||
((0,0),(0,0),(0,1),(0,0))
|
||||
((0,0),(0,-1),(0,0),(0,0))
|
||||
((0,-1),(0,0),(0,0),(0,0)) OK
|
||||
* Gx
|
||||
* 0 0 0 i
|
||||
* 0 0 i 0
|
||||
* 0 -i 0 0
|
||||
* -i 0 0 0
|
||||
|
||||
GammaY ((-0,-0),(-0,-0),(-0,-0),(-1,-0))
|
||||
((0,0),(0,0),(1,0),(0,0))
|
||||
((0,0),(1,0),(0,0),(0,0)) OK
|
||||
((-1,-0),(-0,-0),(-0,-0),(-0,-0))
|
||||
*Gy
|
||||
* 0 0 0 -1 [0] -+ [3]
|
||||
* 0 0 1 0 [1] +- [2]
|
||||
* 0 1 0 0
|
||||
* -1 0 0 0
|
||||
|
||||
GammaZ ((0,0),(0,0),(0,1),(0,0))
|
||||
((0,0),(0,0),(0,0),(0,-1))
|
||||
((0,-1),(0,0),(0,0),(0,0))
|
||||
((0,0),(0,1),(0,0),(0,0)) OK
|
||||
* 0 0 i 0 [0]+-i[2]
|
||||
* 0 0 0 -i [1]-+i[3]
|
||||
* -i 0 0 0
|
||||
* 0 i 0 0
|
||||
|
||||
GammaT ((0,0),(0,0),(1,0),(0,0))
|
||||
((0,0),(0,0),(0,0),(1,0)) OK
|
||||
((1,0),(0,0),(0,0),(0,0))
|
||||
((0,0),(1,0),(0,0),(0,0))
|
||||
* 0 0 1 0 [0]+-[2]
|
||||
* 0 0 0 1 [1]+-[3]
|
||||
* 1 0 0 0
|
||||
* 0 1 0 0
|
||||
|
||||
Gamma5 ((1,0),(0,0),(0,0),(0,0))
|
||||
((0,0),(1,0),(0,0),(0,0))
|
||||
((-0,-0),(-0,-0),(-1,-0),(-0,-0))
|
||||
((-0,-0),(-0,-0),(-0,-0),(-1,-0))
|
||||
* 1 0 0 0 [0]+-[2]
|
||||
* 0 1 0 0 [1]+-[3] OK
|
||||
* 0 0 -1 0
|
||||
* 0 0 0 -1
|
||||
*/
|
||||
|
||||
} //namespace QCD
|
||||
} // Grid
|
||||
#endif
|
||||
|
||||
1140
lib/qcd/spin/Gamma.cc
Normal file
1140
lib/qcd/spin/Gamma.cc
Normal file
File diff suppressed because it is too large
Load Diff
1348
lib/qcd/spin/Gamma.h
Normal file
1348
lib/qcd/spin/Gamma.h
Normal file
File diff suppressed because it is too large
Load Diff
1488
lib/qcd/spin/gamma-gen/gamma-gen.nb
Normal file
1488
lib/qcd/spin/gamma-gen/gamma-gen.nb
Normal file
File diff suppressed because it is too large
Load Diff
@ -47,7 +47,7 @@ void axpibg5x(Lattice<vobj> &z,const Lattice<vobj> &x,Coeff a,Coeff b)
|
||||
|
||||
GridBase *grid=x._grid;
|
||||
|
||||
Gamma G5(Gamma::Gamma5);
|
||||
Gamma G5(Gamma::Algebra::Gamma5);
|
||||
PARALLEL_FOR_LOOP
|
||||
for(int ss=0;ss<grid->oSites();ss++){
|
||||
vobj tmp;
|
||||
@ -80,7 +80,7 @@ void ag5xpby_ssp(Lattice<vobj> &z,Coeff a,const Lattice<vobj> &x,Coeff b,const L
|
||||
conformable(x,z);
|
||||
GridBase *grid=x._grid;
|
||||
int Ls = grid->_rdimensions[0];
|
||||
Gamma G5(Gamma::Gamma5);
|
||||
Gamma G5(Gamma::Algebra::Gamma5);
|
||||
PARALLEL_FOR_LOOP
|
||||
for(int ss=0;ss<grid->oSites();ss+=Ls){ // adds Ls
|
||||
vobj tmp;
|
||||
@ -98,7 +98,7 @@ void axpbg5y_ssp(Lattice<vobj> &z,Coeff a,const Lattice<vobj> &x,Coeff b,const L
|
||||
conformable(x,z);
|
||||
GridBase *grid=x._grid;
|
||||
int Ls = grid->_rdimensions[0];
|
||||
Gamma G5(Gamma::Gamma5);
|
||||
Gamma G5(Gamma::Algebra::Gamma5);
|
||||
PARALLEL_FOR_LOOP
|
||||
for(int ss=0;ss<grid->oSites();ss+=Ls){ // adds Ls
|
||||
vobj tmp;
|
||||
@ -116,7 +116,7 @@ void ag5xpbg5y_ssp(Lattice<vobj> &z,Coeff a,const Lattice<vobj> &x,Coeff b,const
|
||||
conformable(x,z);
|
||||
GridBase *grid=x._grid;
|
||||
int Ls = grid->_rdimensions[0];
|
||||
Gamma G5(Gamma::Gamma5);
|
||||
Gamma G5(Gamma::Algebra::Gamma5);
|
||||
PARALLEL_FOR_LOOP
|
||||
for(int ss=0;ss<grid->oSites();ss+=Ls){ // adds Ls
|
||||
vobj tmp1;
|
||||
@ -168,7 +168,7 @@ void G5R5(Lattice<vobj> &z,const Lattice<vobj> &x)
|
||||
z.checkerboard = x.checkerboard;
|
||||
conformable(x,z);
|
||||
int Ls = grid->_rdimensions[0];
|
||||
Gamma G5(Gamma::Gamma5);
|
||||
Gamma G5(Gamma::Algebra::Gamma5);
|
||||
PARALLEL_FOR_LOOP
|
||||
for(int ss=0;ss<grid->oSites();ss+=Ls){ // adds Ls
|
||||
vobj tmp;
|
||||
|
||||
Reference in New Issue
Block a user