portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-06-13 20:57:06 +01:00
Code Releases Activity

Gammas: code cleaning and gamma_L implementation & test

Browse Source
This commit is contained in:
Antonin Portelli
2017-02-01 15:45:05 -08:00
parent 863855f46f
commit d775fbb2f9
2 changed files with 158 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
lib/qcd/spin/Dirac.h
View File

@ -32,32 +32,28 @@ See the full license in the file "LICENSE" in the top level distribution directo
#ifndef GRID_QCD_DIRAC_H
#define GRID_QCD_DIRAC_H
// code generated by the Mathematica notebook gamma-gen/gamma-gen.nb
#include <array>
// 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 {
inline QCD::Gamma adj (const QCD::Gamma & g)
// 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 {
inline Gamma operator*(const Gamma & g1, const Gamma & g2)
// Dirac algebra mutliplication operator
inline Gamma operator*(const Gamma &g1, const Gamma &g2)
{
return Gamma (Gamma::mul[g1.g][g2.g]);
}
// 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
// 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
@ -90,7 +86,7 @@ inline auto operator*(const Gamma &G, const iMatrix<vtype, N> &arg)
return ret;
}
//right multiply
// 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
@ -112,6 +108,125 @@ inline auto operator * (const iMatrix<vtype, N> &arg, const Gamma &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;
buf(0) = 0.;
buf(1) = 0.;
buf(2) = 2.*arg(2);
buf(3) = 2.*arg(3);
return gl.gamma*buf;
};
// 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;
};
//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,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, 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;
}
}}
#endif