fermiqcd_gamma_matrices.h Source File

00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 #define GAMMA_MATRICES
00020 
00021 // ////////////////////////////////////////////////////////////////////
00022 // Gamma matrices and relatives!
00023 // ////////////////////////////////////////////////////////////////////
00024 
00025 mdp_complex Gamma_val[4][4], Sigma_val[4][4][4];
00026 int     Gamma_idx[4][4], Sigma_idx[4][4][4];
00027 mdp_complex Gamma5_val[4], GammaxGamma5_val[4][4];
00028 int     Gamma5_idx[4], GammaxGamma5_idx[4][4];
00029 mdp_complex Gamma_valr[4][4], Sigma_valr[4][4][4];
00030 int     Gamma_idxr[4][4], Sigma_idxr[4][4][4];
00031 mdp_complex Gamma5_valr[4], GammaxGamma5_valr[4][4];
00032 int     Gamma5_idxr[4], GammaxGamma5_idxr[4][4];
00033 int     G16_idx[16][4];
00034 mdp_complex G16_val[16][4];
00035 
00036 mdp_matrix Gamma[4], Gamma1, Gamma5, Pleft, Pright, Lambda[9];
00037 mdp_matrix Sigma[4][4], sigma[4];
00038 
00051 void define_base_matrices(string convention="FERMILAB") {
00052   begin_function("define_base_matrices");
00053   int i,j,a,b,mu,nu; // was int i,j,k;
00054   for(i=0; i<4; i++) Gamma[i].dimension(4,4);
00055   Gamma5.dimension(4,4);
00056 
00057   if(convention=="UKQCD") {
00058     Gamma[0](0,0)=+1;
00059     Gamma[0](1,1)=+1;
00060     Gamma[0](2,2)=-1;
00061     Gamma[0](3,3)=-1;
00062     
00063     Gamma[1](0,3)=+I;
00064     Gamma[1](1,2)=+I;
00065     Gamma[1](2,1)=-I;
00066     Gamma[1](3,0)=-I;
00067     
00068     Gamma[2](0,3)=+1;
00069     Gamma[2](1,2)=-1;
00070     Gamma[2](2,1)=-1;
00071     Gamma[2](3,0)=+1;
00072     
00073     Gamma[3](0,2)=+I;
00074     Gamma[3](1,3)=-I;
00075     Gamma[3](2,0)=-I;
00076     Gamma[3](3,1)=+I;
00077     Gamma5=Gamma[1]*Gamma[2]*Gamma[3]*Gamma[0];
00078   }
00079 
00080   if(convention=="FERMILAB") {
00081     Gamma[0](0,0)=+1;
00082     Gamma[0](1,1)=+1;
00083     Gamma[0](2,2)=-1;
00084     Gamma[0](3,3)=-1;
00085 
00086     Gamma[1](0,3)=+1;
00087     Gamma[1](1,2)=+1;
00088     Gamma[1](2,1)=+1;
00089     Gamma[1](3,0)=+1;
00090     
00091     Gamma[2](0,3)=-I;
00092     Gamma[2](1,2)=+I;
00093     Gamma[2](2,1)=-I;
00094     Gamma[2](3,0)=+I;
00095     
00096     Gamma[3](0,2)=+1;
00097     Gamma[3](1,3)=-1;
00098     Gamma[3](2,0)=+1;
00099     Gamma[3](3,1)=-1;
00100 
00101     Gamma5=Gamma[0]*Gamma[1]*Gamma[2]*Gamma[3];
00102   }
00103 
00104   if(convention=="Minkowsky-Dirac") {
00105     Gamma[0](0,0)=+1;
00106     Gamma[0](1,1)=+1;
00107     Gamma[0](2,2)=-1;
00108     Gamma[0](3,3)=-1;
00109     
00110     Gamma[1](0,3)=+1;
00111     Gamma[1](1,2)=+1;
00112     Gamma[1](2,1)=-1;
00113     Gamma[1](3,0)=-1;
00114     
00115     Gamma[2](0,3)=-I;
00116     Gamma[2](1,2)=+I;
00117     Gamma[2](2,1)=+I;
00118     Gamma[2](3,0)=-I;
00119     
00120     Gamma[3](0,2)=+1;
00121     Gamma[3](1,3)=-1;
00122     Gamma[3](2,0)=-1;
00123     Gamma[3](3,1)=+1;
00124     Gamma5=I*Gamma[0]*Gamma[1]*Gamma[2]*Gamma[3];
00125   }
00126 
00127   if(convention=="Minkowsky-Chiral") {
00128     Gamma[0](0,3)=-1;
00129     Gamma[0](1,2)=-1;
00130     Gamma[0](2,1)=-1;
00131     Gamma[0](3,0)=-1;
00132     
00133     Gamma[1](0,3)=+1;
00134     Gamma[1](1,2)=+1;
00135     Gamma[1](2,1)=-1;
00136     Gamma[1](3,0)=-1;
00137     
00138     Gamma[2](0,3)=-I;
00139     Gamma[2](1,2)=+I;
00140     Gamma[2](2,1)=+I;
00141     Gamma[2](3,0)=-I;
00142     
00143     Gamma[3](0,2)=+1;
00144     Gamma[3](1,3)=-1;
00145     Gamma[3](2,0)=-1;
00146     Gamma[3](3,1)=+1;
00147     Gamma5=I*Gamma[0]*Gamma[1]*Gamma[2]*Gamma[3];
00148   }
00149   Gamma1=mdp_identity(4);
00150   Pleft  = mdp_complex(.5,0)*(Gamma[0]*Gamma[0]-Gamma5);
00151   Pright = mdp_complex(.5,0)*(Gamma[0]*Gamma[0]+Gamma5);
00152 
00153   /* sigma matrices SU(2) generators */
00154 
00155   for(i=0; i<4; i++)
00156     sigma[i].dimension(2,2);
00157   sigma[0](0,0)=+1;
00158   sigma[0](1,1)=+1;
00159   sigma[1](0,1)=+1;
00160   sigma[1](1,0)=+1;
00161   sigma[2](0,1)=-I;
00162   sigma[2](1,0)=+I;
00163   sigma[3](0,0)=+1;
00164   sigma[3](1,1)=-1;
00165 
00166   /* Lambda matrices SU(3) generators */
00167 
00168   for(i=0; i<9; i++) Lambda[i].dimension(3,3);
00169 
00170   Lambda[0](0,0)=+1;
00171   Lambda[0](1,1)=+1;
00172   Lambda[0](2,2)=+1;
00173 
00174   Lambda[1](0,1)=+1;
00175   Lambda[1](1,0)=+1;
00176 
00177   Lambda[2](0,1)=-I;
00178   Lambda[2](1,0)=+I;
00179 
00180   Lambda[3](0,0)=+1;
00181   Lambda[3](1,1)=-1;
00182   
00183   Lambda[4](0,2)=+1;
00184   Lambda[4](2,0)=+1;
00185 
00186   Lambda[5](0,2)=-I;
00187   Lambda[5](2,0)=+I;
00188 
00189   Lambda[6](1,2)=+1;
00190   Lambda[6](2,1)=+1;
00191 
00192   Lambda[7](1,2)=-I;
00193   Lambda[7](2,1)=+I;
00194 
00195   Lambda[8](0,0)=pow(3.0,-0.5);
00196   Lambda[8](1,1)=pow(3.0,-0.5);
00197   Lambda[8](2,2)=-2.0*pow(3.0,-0.5);
00198 
00199   /* Sigma[mu][nu] */
00200 
00201   mdp_matrix tmp;
00202   
00203   for(i=0; i<4; i++)
00204     for(j=0; j<4; j++) {
00205       Sigma[i][j].dimension(4,4);
00206       if(i!=j)
00207         Sigma[i][j]=I*Gamma[i]*Gamma[j];
00208       else
00209         Sigma[i][j]=0;
00210     }
00211 
00212   /* Filling arrays for fast Gamma multiplication */
00213 
00214   for(a=0; a<4; a++) 
00215     for(b=0; b<4; b++) {
00216       if(Gamma5(a,b)!=mdp_complex(0,0)) {
00217         Gamma5_val[b]=Gamma5(a,b);
00218         Gamma5_idx[b]=a;
00219         Gamma5_valr[a]=Gamma5(a,b);
00220         Gamma5_idxr[a]=b;       
00221       }
00222     }
00223 
00224   for(mu=0; mu<4; mu++) {
00225     tmp=Gamma[mu]*Gamma5;
00226     for(a=0; a<4; a++) 
00227       for(b=0; b<4; b++) {
00228         if(Gamma[mu](a,b)!=mdp_complex(0,0)) {
00229           Gamma_val[mu][b]=Gamma[mu](a,b);
00230           Gamma_idx[mu][b]=a;
00231           Gamma_valr[mu][a]=Gamma[mu](a,b);
00232           Gamma_idxr[mu][a]=b;
00233         }
00234         if(tmp(a,b)!=mdp_complex(0,0)) {
00235           GammaxGamma5_val[mu][b]=tmp(a,b);
00236           GammaxGamma5_idx[mu][b]=a;
00237           GammaxGamma5_valr[mu][a]=tmp(a,b);
00238           GammaxGamma5_idxr[mu][a]=b;
00239         }
00240       }
00241   }
00242 
00243   /* Filling arrays for fast Sigma multiplication */
00244   
00245   for(mu=0; mu<4; mu++) 
00246     for(nu=0; nu<4; nu++) 
00247       for(a=0; a<4; a++) 
00248         for(b=0; b<4; b++) {
00249           if(Sigma[mu][nu](a,b)!=mdp_complex(0,0)) {
00250             Sigma_val[mu][nu][b]=Sigma[mu][nu](a,b);
00251             Sigma_idx[mu][nu][b]=a;
00252             Sigma_valr[mu][nu][a]=Sigma[mu][nu](a,b);
00253             Sigma_idxr[mu][nu][a]=b;
00254           }
00255         }
00256 
00257   // Filling G16;
00258   
00259   for(a=0; a<4; a++) {
00260     G16_idx[0][a]=a;
00261     G16_val[0][a]=1;
00262     G16_idx[1][a]=Gamma5_idx[a];
00263     G16_val[1][a]=Gamma5_val[a];
00264     for(mu=0; mu<4; mu++) {
00265       G16_idx[2+mu][a]=Gamma_idx[mu][a];
00266       G16_val[2+mu][a]=Gamma_val[mu][a];
00267       G16_idx[6+mu][a]=Gamma_idx[mu][Gamma5_idx[a]];
00268       G16_val[6+mu][a]=Gamma_val[mu][Gamma5_idx[a]]*Gamma5_val[a];
00269     }
00270     for(mu=1; mu<4; mu++) {
00271       G16_idx[9+mu][a]=Gamma_idx[0][Gamma_idx[mu][a]];
00272       G16_val[9+mu][a]=Gamma_val[0][Gamma_idx[mu][a]]*Gamma_val[mu][a];
00273       G16_idx[12+mu][a]=Gamma_idx[0][Gamma_idx[mu][Gamma5_idx[a]]];
00274       G16_val[12+mu][a]=Gamma_val[0][Gamma_idx[mu][Gamma5_idx[a]]]*
00275         Gamma_val[mu][Gamma5_idx[a]]*Gamma5_val[a];
00276     }
00277   }
00278   end_function("define_base_matrices");
00279 }