mirror of
https://github.com/paboyle/Grid.git
synced 2024-11-15 10:15:36 +00:00
1348 lines
36 KiB
C++
1348 lines
36 KiB
C++
#ifndef GRID_QCD_GAMMA_H
|
|
#define GRID_QCD_GAMMA_H
|
|
|
|
// code generated by the Mathematica notebook gamma-gen/gamma-gen.nb
|
|
|
|
#include <array>
|
|
|
|
NAMESPACE_BEGIN(Grid);
|
|
|
|
class Gamma {
|
|
public:
|
|
GRID_SERIALIZABLE_ENUM(Algebra, undef,
|
|
MinusGamma5 , 0,
|
|
Gamma5 , 1,
|
|
MinusGammaT , 2,
|
|
GammaT , 3,
|
|
MinusGammaTGamma5, 4,
|
|
GammaTGamma5 , 5,
|
|
MinusGammaX , 6,
|
|
GammaX , 7,
|
|
MinusGammaXGamma5, 8,
|
|
GammaXGamma5 , 9,
|
|
MinusGammaY , 10,
|
|
GammaY , 11,
|
|
MinusGammaYGamma5, 12,
|
|
GammaYGamma5 , 13,
|
|
MinusGammaZ , 14,
|
|
GammaZ , 15,
|
|
MinusGammaZGamma5, 16,
|
|
GammaZGamma5 , 17,
|
|
MinusIdentity , 18,
|
|
Identity , 19,
|
|
MinusSigmaXT , 20,
|
|
SigmaXT , 21,
|
|
MinusSigmaXY , 22,
|
|
SigmaXY , 23,
|
|
MinusSigmaXZ , 24,
|
|
SigmaXZ , 25,
|
|
MinusSigmaYT , 26,
|
|
SigmaYT , 27,
|
|
MinusSigmaYZ , 28,
|
|
SigmaYZ , 29,
|
|
MinusSigmaZT , 30,
|
|
SigmaZT , 31);
|
|
static constexpr unsigned int nGamma = 32;
|
|
static const std::array<const char *, nGamma> name;
|
|
static const std::array<std::array<Algebra, nGamma>, nGamma> mul;
|
|
static const std::array<Algebra, nGamma> adj;
|
|
static const std::array<const Gamma, 4> gmu;
|
|
Algebra g;
|
|
public:
|
|
accelerator Gamma(Algebra initg): g(initg) {}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_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>
|
|
accelerator_inline void lmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_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>
|
|
accelerator_inline void lmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_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);
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_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>
|
|
accelerator_inline void lmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multMinusGammaTGamma5(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>
|
|
accelerator_inline void lmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multGammaTGamma5(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>
|
|
accelerator_inline void lmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_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));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multGammaX(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesI(rhs(3));
|
|
ret(1) = timesI(rhs(2));
|
|
ret(2) = timesMinusI(rhs(1));
|
|
ret(3) = timesMinusI(rhs(0));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multMinusGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesI(rhs(3));
|
|
ret(1) = timesI(rhs(2));
|
|
ret(2) = timesI(rhs(1));
|
|
ret(3) = timesI(rhs(0));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesI(rhs(3, i));
|
|
ret(1, i) = timesI(rhs(2, i));
|
|
ret(2, i) = timesI(rhs(1, i));
|
|
ret(3, i) = timesI(rhs(0, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesI(rhs(i, 3));
|
|
ret(i, 1) = timesI(rhs(i, 2));
|
|
ret(i, 2) = timesI(rhs(i, 1));
|
|
ret(i, 3) = timesI(rhs(i, 0));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesMinusI(rhs(3));
|
|
ret(1) = timesMinusI(rhs(2));
|
|
ret(2) = timesMinusI(rhs(1));
|
|
ret(3) = timesMinusI(rhs(0));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesMinusI(rhs(3, i));
|
|
ret(1, i) = timesMinusI(rhs(2, i));
|
|
ret(2, i) = timesMinusI(rhs(1, i));
|
|
ret(3, i) = timesMinusI(rhs(0, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesMinusI(rhs(i, 3));
|
|
ret(i, 1) = timesMinusI(rhs(i, 2));
|
|
ret(i, 2) = timesMinusI(rhs(i, 1));
|
|
ret(i, 3) = timesMinusI(rhs(i, 0));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_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);
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_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>
|
|
accelerator_inline void lmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multMinusGammaYGamma5(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>
|
|
accelerator_inline void lmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multGammaYGamma5(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>
|
|
accelerator_inline void lmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_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));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_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>
|
|
accelerator_inline void lmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multMinusGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesI(rhs(2));
|
|
ret(1) = timesMinusI(rhs(3));
|
|
ret(2) = timesI(rhs(0));
|
|
ret(3) = timesMinusI(rhs(1));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesI(rhs(2, i));
|
|
ret(1, i) = timesMinusI(rhs(3, i));
|
|
ret(2, i) = timesI(rhs(0, i));
|
|
ret(3, i) = timesMinusI(rhs(1, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesI(rhs(i, 2));
|
|
ret(i, 1) = timesMinusI(rhs(i, 3));
|
|
ret(i, 2) = timesI(rhs(i, 0));
|
|
ret(i, 3) = timesMinusI(rhs(i, 1));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesMinusI(rhs(2));
|
|
ret(1) = timesI(rhs(3));
|
|
ret(2) = timesMinusI(rhs(0));
|
|
ret(3) = timesI(rhs(1));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesMinusI(rhs(2, i));
|
|
ret(1, i) = timesI(rhs(3, i));
|
|
ret(2, i) = timesMinusI(rhs(0, i));
|
|
ret(3, i) = timesI(rhs(1, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesMinusI(rhs(i, 2));
|
|
ret(i, 1) = timesI(rhs(i, 3));
|
|
ret(i, 2) = timesMinusI(rhs(i, 0));
|
|
ret(i, 3) = timesI(rhs(i, 1));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multMinusIdentity(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>
|
|
accelerator_inline void lmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multIdentity(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>
|
|
accelerator_inline void lmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void rmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned 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>
|
|
accelerator_inline void multMinusSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesMinusI(rhs(1));
|
|
ret(1) = timesMinusI(rhs(0));
|
|
ret(2) = timesI(rhs(3));
|
|
ret(3) = timesI(rhs(2));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesMinusI(rhs(1, i));
|
|
ret(1, i) = timesMinusI(rhs(0, i));
|
|
ret(2, i) = timesI(rhs(3, i));
|
|
ret(3, i) = timesI(rhs(2, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesMinusI(rhs(i, 1));
|
|
ret(i, 1) = timesMinusI(rhs(i, 0));
|
|
ret(i, 2) = timesI(rhs(i, 3));
|
|
ret(i, 3) = timesI(rhs(i, 2));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesI(rhs(1));
|
|
ret(1) = timesI(rhs(0));
|
|
ret(2) = timesMinusI(rhs(3));
|
|
ret(3) = timesMinusI(rhs(2));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesI(rhs(1, i));
|
|
ret(1, i) = timesI(rhs(0, i));
|
|
ret(2, i) = timesMinusI(rhs(3, i));
|
|
ret(3, i) = timesMinusI(rhs(2, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesI(rhs(i, 1));
|
|
ret(i, 1) = timesI(rhs(i, 0));
|
|
ret(i, 2) = timesMinusI(rhs(i, 3));
|
|
ret(i, 3) = timesMinusI(rhs(i, 2));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multMinusSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesI(rhs(0));
|
|
ret(1) = timesMinusI(rhs(1));
|
|
ret(2) = timesI(rhs(2));
|
|
ret(3) = timesMinusI(rhs(3));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesI(rhs(0, i));
|
|
ret(1, i) = timesMinusI(rhs(1, i));
|
|
ret(2, i) = timesI(rhs(2, i));
|
|
ret(3, i) = timesMinusI(rhs(3, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesI(rhs(i, 0));
|
|
ret(i, 1) = timesMinusI(rhs(i, 1));
|
|
ret(i, 2) = timesI(rhs(i, 2));
|
|
ret(i, 3) = timesMinusI(rhs(i, 3));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesMinusI(rhs(0));
|
|
ret(1) = timesI(rhs(1));
|
|
ret(2) = timesMinusI(rhs(2));
|
|
ret(3) = timesI(rhs(3));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesMinusI(rhs(0, i));
|
|
ret(1, i) = timesI(rhs(1, i));
|
|
ret(2, i) = timesMinusI(rhs(2, i));
|
|
ret(3, i) = timesI(rhs(3, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesMinusI(rhs(i, 0));
|
|
ret(i, 1) = timesI(rhs(i, 1));
|
|
ret(i, 2) = timesMinusI(rhs(i, 2));
|
|
ret(i, 3) = timesI(rhs(i, 3));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multMinusSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = rhs(1);
|
|
ret(1) = -rhs(0);
|
|
ret(2) = rhs(3);
|
|
ret(3) = -rhs(2);
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = rhs(1, i);
|
|
ret(1, i) = -rhs(0, i);
|
|
ret(2, i) = rhs(3, i);
|
|
ret(3, i) = -rhs(2, i);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = -rhs(i, 1);
|
|
ret(i, 1) = rhs(i, 0);
|
|
ret(i, 2) = -rhs(i, 3);
|
|
ret(i, 3) = rhs(i, 2);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = -rhs(1);
|
|
ret(1) = rhs(0);
|
|
ret(2) = -rhs(3);
|
|
ret(3) = rhs(2);
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = -rhs(1, i);
|
|
ret(1, i) = rhs(0, i);
|
|
ret(2, i) = -rhs(3, i);
|
|
ret(3, i) = rhs(2, i);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = rhs(i, 1);
|
|
ret(i, 1) = -rhs(i, 0);
|
|
ret(i, 2) = rhs(i, 3);
|
|
ret(i, 3) = -rhs(i, 2);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multMinusSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = rhs(1);
|
|
ret(1) = -rhs(0);
|
|
ret(2) = -rhs(3);
|
|
ret(3) = rhs(2);
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = rhs(1, i);
|
|
ret(1, i) = -rhs(0, i);
|
|
ret(2, i) = -rhs(3, i);
|
|
ret(3, i) = rhs(2, i);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = -rhs(i, 1);
|
|
ret(i, 1) = rhs(i, 0);
|
|
ret(i, 2) = rhs(i, 3);
|
|
ret(i, 3) = -rhs(i, 2);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = -rhs(1);
|
|
ret(1) = rhs(0);
|
|
ret(2) = rhs(3);
|
|
ret(3) = -rhs(2);
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = -rhs(1, i);
|
|
ret(1, i) = rhs(0, i);
|
|
ret(2, i) = rhs(3, i);
|
|
ret(3, i) = -rhs(2, i);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = rhs(i, 1);
|
|
ret(i, 1) = -rhs(i, 0);
|
|
ret(i, 2) = -rhs(i, 3);
|
|
ret(i, 3) = rhs(i, 2);
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multMinusSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesI(rhs(1));
|
|
ret(1) = timesI(rhs(0));
|
|
ret(2) = timesI(rhs(3));
|
|
ret(3) = timesI(rhs(2));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesI(rhs(1, i));
|
|
ret(1, i) = timesI(rhs(0, i));
|
|
ret(2, i) = timesI(rhs(3, i));
|
|
ret(3, i) = timesI(rhs(2, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesI(rhs(i, 1));
|
|
ret(i, 1) = timesI(rhs(i, 0));
|
|
ret(i, 2) = timesI(rhs(i, 3));
|
|
ret(i, 3) = timesI(rhs(i, 2));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesMinusI(rhs(1));
|
|
ret(1) = timesMinusI(rhs(0));
|
|
ret(2) = timesMinusI(rhs(3));
|
|
ret(3) = timesMinusI(rhs(2));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesMinusI(rhs(1, i));
|
|
ret(1, i) = timesMinusI(rhs(0, i));
|
|
ret(2, i) = timesMinusI(rhs(3, i));
|
|
ret(3, i) = timesMinusI(rhs(2, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesMinusI(rhs(i, 1));
|
|
ret(i, 1) = timesMinusI(rhs(i, 0));
|
|
ret(i, 2) = timesMinusI(rhs(i, 3));
|
|
ret(i, 3) = timesMinusI(rhs(i, 2));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multMinusSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesMinusI(rhs(0));
|
|
ret(1) = timesI(rhs(1));
|
|
ret(2) = timesI(rhs(2));
|
|
ret(3) = timesMinusI(rhs(3));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesMinusI(rhs(0, i));
|
|
ret(1, i) = timesI(rhs(1, i));
|
|
ret(2, i) = timesI(rhs(2, i));
|
|
ret(3, i) = timesMinusI(rhs(3, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesMinusI(rhs(i, 0));
|
|
ret(i, 1) = timesI(rhs(i, 1));
|
|
ret(i, 2) = timesI(rhs(i, 2));
|
|
ret(i, 3) = timesMinusI(rhs(i, 3));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void multSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
|
|
{
|
|
ret(0) = timesI(rhs(0));
|
|
ret(1) = timesMinusI(rhs(1));
|
|
ret(2) = timesMinusI(rhs(2));
|
|
ret(3) = timesI(rhs(3));
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void lmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(0, i) = timesI(rhs(0, i));
|
|
ret(1, i) = timesMinusI(rhs(1, i));
|
|
ret(2, i) = timesMinusI(rhs(2, i));
|
|
ret(3, i) = timesI(rhs(3, i));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_inline void rmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
|
|
{
|
|
for(unsigned int i = 0; i < Ns; ++i)
|
|
{
|
|
ret(i, 0) = timesI(rhs(i, 0));
|
|
ret(i, 1) = timesMinusI(rhs(i, 1));
|
|
ret(i, 2) = timesMinusI(rhs(i, 2));
|
|
ret(i, 3) = timesI(rhs(i, 3));
|
|
}
|
|
};
|
|
|
|
template<class vtype>
|
|
accelerator_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::Algebra::MinusGamma5:
|
|
multMinusGamma5(ret, arg); break;
|
|
case Gamma::Algebra::Gamma5:
|
|
multGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaT:
|
|
multMinusGammaT(ret, arg); break;
|
|
case Gamma::Algebra::GammaT:
|
|
multGammaT(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaTGamma5:
|
|
multMinusGammaTGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaTGamma5:
|
|
multGammaTGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaX:
|
|
multMinusGammaX(ret, arg); break;
|
|
case Gamma::Algebra::GammaX:
|
|
multGammaX(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaXGamma5:
|
|
multMinusGammaXGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaXGamma5:
|
|
multGammaXGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaY:
|
|
multMinusGammaY(ret, arg); break;
|
|
case Gamma::Algebra::GammaY:
|
|
multGammaY(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaYGamma5:
|
|
multMinusGammaYGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaYGamma5:
|
|
multGammaYGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaZ:
|
|
multMinusGammaZ(ret, arg); break;
|
|
case Gamma::Algebra::GammaZ:
|
|
multGammaZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaZGamma5:
|
|
multMinusGammaZGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaZGamma5:
|
|
multGammaZGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusIdentity:
|
|
multMinusIdentity(ret, arg); break;
|
|
case Gamma::Algebra::Identity:
|
|
multIdentity(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXT:
|
|
multMinusSigmaXT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXT:
|
|
multSigmaXT(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXY:
|
|
multMinusSigmaXY(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXY:
|
|
multSigmaXY(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXZ:
|
|
multMinusSigmaXZ(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXZ:
|
|
multSigmaXZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaYT:
|
|
multMinusSigmaYT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaYT:
|
|
multSigmaYT(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaYZ:
|
|
multMinusSigmaYZ(ret, arg); break;
|
|
case Gamma::Algebra::SigmaYZ:
|
|
multSigmaYZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaZT:
|
|
multMinusSigmaZT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaZT:
|
|
multSigmaZT(ret, arg); break;
|
|
default: assert(0);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
template<class vtype>
|
|
accelerator_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::Algebra::MinusGamma5:
|
|
lmultMinusGamma5(ret, arg); break;
|
|
case Gamma::Algebra::Gamma5:
|
|
lmultGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaT:
|
|
lmultMinusGammaT(ret, arg); break;
|
|
case Gamma::Algebra::GammaT:
|
|
lmultGammaT(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaTGamma5:
|
|
lmultMinusGammaTGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaTGamma5:
|
|
lmultGammaTGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaX:
|
|
lmultMinusGammaX(ret, arg); break;
|
|
case Gamma::Algebra::GammaX:
|
|
lmultGammaX(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaXGamma5:
|
|
lmultMinusGammaXGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaXGamma5:
|
|
lmultGammaXGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaY:
|
|
lmultMinusGammaY(ret, arg); break;
|
|
case Gamma::Algebra::GammaY:
|
|
lmultGammaY(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaYGamma5:
|
|
lmultMinusGammaYGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaYGamma5:
|
|
lmultGammaYGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaZ:
|
|
lmultMinusGammaZ(ret, arg); break;
|
|
case Gamma::Algebra::GammaZ:
|
|
lmultGammaZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaZGamma5:
|
|
lmultMinusGammaZGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaZGamma5:
|
|
lmultGammaZGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusIdentity:
|
|
lmultMinusIdentity(ret, arg); break;
|
|
case Gamma::Algebra::Identity:
|
|
lmultIdentity(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXT:
|
|
lmultMinusSigmaXT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXT:
|
|
lmultSigmaXT(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXY:
|
|
lmultMinusSigmaXY(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXY:
|
|
lmultSigmaXY(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXZ:
|
|
lmultMinusSigmaXZ(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXZ:
|
|
lmultSigmaXZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaYT:
|
|
lmultMinusSigmaYT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaYT:
|
|
lmultSigmaYT(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaYZ:
|
|
lmultMinusSigmaYZ(ret, arg); break;
|
|
case Gamma::Algebra::SigmaYZ:
|
|
lmultSigmaYZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaZT:
|
|
lmultMinusSigmaZT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaZT:
|
|
lmultSigmaZT(ret, arg); break;
|
|
default: assert(0);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
template<class vtype>
|
|
accelerator_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::Algebra::MinusGamma5:
|
|
rmultMinusGamma5(ret, arg); break;
|
|
case Gamma::Algebra::Gamma5:
|
|
rmultGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaT:
|
|
rmultMinusGammaT(ret, arg); break;
|
|
case Gamma::Algebra::GammaT:
|
|
rmultGammaT(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaTGamma5:
|
|
rmultMinusGammaTGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaTGamma5:
|
|
rmultGammaTGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaX:
|
|
rmultMinusGammaX(ret, arg); break;
|
|
case Gamma::Algebra::GammaX:
|
|
rmultGammaX(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaXGamma5:
|
|
rmultMinusGammaXGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaXGamma5:
|
|
rmultGammaXGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaY:
|
|
rmultMinusGammaY(ret, arg); break;
|
|
case Gamma::Algebra::GammaY:
|
|
rmultGammaY(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaYGamma5:
|
|
rmultMinusGammaYGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaYGamma5:
|
|
rmultGammaYGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaZ:
|
|
rmultMinusGammaZ(ret, arg); break;
|
|
case Gamma::Algebra::GammaZ:
|
|
rmultGammaZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusGammaZGamma5:
|
|
rmultMinusGammaZGamma5(ret, arg); break;
|
|
case Gamma::Algebra::GammaZGamma5:
|
|
rmultGammaZGamma5(ret, arg); break;
|
|
case Gamma::Algebra::MinusIdentity:
|
|
rmultMinusIdentity(ret, arg); break;
|
|
case Gamma::Algebra::Identity:
|
|
rmultIdentity(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXT:
|
|
rmultMinusSigmaXT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXT:
|
|
rmultSigmaXT(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXY:
|
|
rmultMinusSigmaXY(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXY:
|
|
rmultSigmaXY(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaXZ:
|
|
rmultMinusSigmaXZ(ret, arg); break;
|
|
case Gamma::Algebra::SigmaXZ:
|
|
rmultSigmaXZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaYT:
|
|
rmultMinusSigmaYT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaYT:
|
|
rmultSigmaYT(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaYZ:
|
|
rmultMinusSigmaYZ(ret, arg); break;
|
|
case Gamma::Algebra::SigmaYZ:
|
|
rmultSigmaYZ(ret, arg); break;
|
|
case Gamma::Algebra::MinusSigmaZT:
|
|
rmultMinusSigmaZT(ret, arg); break;
|
|
case Gamma::Algebra::SigmaZT:
|
|
rmultSigmaZT(ret, arg); break;
|
|
default: assert(0);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
NAMESPACE_END(Grid);
|
|
|
|
#endif // GRID_QCD_GAMMA_H
|