mirror of
https://github.com/paboyle/Grid.git
synced 2026-05-04 17:34:13 +01:00
Merge branch 'develop' into feature/bgq-asm
This commit is contained in:
paboyle
@@ -1,96 +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/GridCore.h>
|
||||
#include <Grid/GridQCDcore.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);
|
||||
// }
|
||||
}
|
||||
}
|
||||
+200
-596
@@ -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
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user