Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

EvtRaritaSchwinger Class Reference

#include <EvtRaritaSchwinger.hh>

List of all members.

Public Member Functions

void applyBoostTo (const EvtVector3R boost)
void applyBoostTo (const EvtVector4R p4)
void applyRotateEuler (double alpha, double beta, double gamma)
EvtRaritaSchwinger conj () const
 EvtRaritaSchwinger (const EvtRaritaSchwinger &rs)
 EvtRaritaSchwinger ()
EvtComplex get (int i, int j) const
EvtDiracSpinor getSpinor (int i) const
EvtVector4C getVector (int i) const
EvtRaritaSchwinger & operator+= (const EvtRaritaSchwinger &u2)
EvtRaritaSchwinger & operator-= (const EvtRaritaSchwinger &u2)
EvtRaritaSchwinger & operator= (const EvtRaritaSchwinger &rs)
void set (int i, int j, const EvtComplex &sp)
void setSpinor (int i, const EvtDiracSpinor &sp)
void setVector (int i, const EvtVector4C &v)
virtual ~EvtRaritaSchwinger ()

Private Attributes

EvtComplex _rs [4][4]

Friends

EvtRaritaSchwinger boostTo (const EvtRaritaSchwinger &rs, const EvtVector3R boost)
EvtRaritaSchwinger boostTo (const EvtRaritaSchwinger &rs, const EvtVector4R p4)
EvtRaritaSchwinger conj (const EvtRaritaSchwinger &u2)
EvtRaritaSchwinger dirProd (EvtVector4C v, EvtDiracSpinor u)
EvtRaritaSchwinger dirProd (EvtVector4R v, EvtDiracSpinor u)
EvtComplex operator * (const EvtRaritaSchwinger &u1, const EvtRaritaSchwinger &u2)
EvtRaritaSchwinger operator+ (const EvtRaritaSchwinger &u1, const EvtRaritaSchwinger &u2)
EvtRaritaSchwinger operator- (const EvtRaritaSchwinger &u1, const EvtRaritaSchwinger &u2)
std::ostream & operator<< (std::ostream &s, const EvtRaritaSchwinger &rs)
EvtRaritaSchwinger rotateEuler (const EvtRaritaSchwinger &rs, double alpha, double beta, double gamma)

Constructor & Destructor Documentation

EvtRaritaSchwinger::EvtRaritaSchwinger (   )  [inline]
  

00103                                       {
00104 
00105   int i,j;
00106   for(i=0;i<4;i++){
00107     for(j=0;j<4;j++){
00108       _rs[i][j]=0.0;
00109     }
00110   }
00111 
00112 }

EvtRaritaSchwinger::~EvtRaritaSchwinger (   )  [virtual]
  

00027                                        {
00028 }

EvtRaritaSchwinger::EvtRaritaSchwinger (  const EvtRaritaSchwinger &  rs  )  [inline]
  

00114                                                                   {
00115 
00116   int i,j;
00117   for(i=0;i<4;i++){
00118     for(j=0;j<4;j++){
00119       _rs[i][j]=rs._rs[i][j];
00120     }
00121   }
00122 
00123 }

Member Function Documentation

void EvtRaritaSchwinger::applyBoostTo (  const EvtVector3R  boost  ) 
  

00108                                                             {
00109 
00110   //inefficient but simple to code...
00111   EvtVector4C v0=getVector(0);
00112   EvtVector4C v1=getVector(1);
00113   EvtVector4C v2=getVector(2);
00114   EvtVector4C v3=getVector(3);
00115   v0.applyBoostTo(boost);
00116   v1.applyBoostTo(boost);
00117   v2.applyBoostTo(boost);
00118   v3.applyBoostTo(boost);
00119   setVector(0,v0);
00120   setVector(1,v1);
00121   setVector(2,v2);
00122   setVector(3,v3);
00123   EvtDiracSpinor sp0=getSpinor(0);
00124   EvtDiracSpinor sp1=getSpinor(1);
00125   EvtDiracSpinor sp2=getSpinor(2);
00126   EvtDiracSpinor sp3=getSpinor(3);
00127   sp0.applyBoostTo(boost);
00128   sp1.applyBoostTo(boost);
00129   sp2.applyBoostTo(boost);
00130   sp3.applyBoostTo(boost);
00131   setSpinor(0,sp0);
00132   setSpinor(1,sp1);
00133   setSpinor(2,sp2);
00134   setSpinor(3,sp3);
00135 
00136 
00137 }

void EvtRaritaSchwinger::applyBoostTo (  const EvtVector4R  p4  ) 
  

00095                                                          {
00096 
00097   double e=p4.get(0);
00098 
00099   EvtVector3R boost(p4.get(1)/e,p4.get(2)/e,p4.get(3)/e);
00100 
00101   applyBoostTo(boost);
00102   
00103   return;
00104 
00105 }

void EvtRaritaSchwinger::applyRotateEuler (  double  alpha,
double  beta,
double  gamma
) 
  

00064                                                        {
00065 
00066   //inefficient but simple to code...
00067   EvtVector4C v0=getVector(0);
00068   EvtVector4C v1=getVector(1);
00069   EvtVector4C v2=getVector(2);
00070   EvtVector4C v3=getVector(3);
00071   v0.applyRotateEuler(alpha,beta,gamma);
00072   v1.applyRotateEuler(alpha,beta,gamma);
00073   v2.applyRotateEuler(alpha,beta,gamma);
00074   v3.applyRotateEuler(alpha,beta,gamma);
00075   setVector(0,v0);
00076   setVector(1,v1);
00077   setVector(2,v2);
00078   setVector(3,v3);
00079   EvtDiracSpinor sp0=getSpinor(0);
00080   EvtDiracSpinor sp1=getSpinor(1);
00081   EvtDiracSpinor sp2=getSpinor(2);
00082   EvtDiracSpinor sp3=getSpinor(3);
00083   sp0.applyRotateEuler(alpha,beta,gamma);
00084   sp1.applyRotateEuler(alpha,beta,gamma);
00085   sp2.applyRotateEuler(alpha,beta,gamma);
00086   sp3.applyRotateEuler(alpha,beta,gamma);
00087   setSpinor(0,sp0);
00088   setSpinor(1,sp1);
00089   setSpinor(2,sp2);
00090   setSpinor(3,sp3);
00091 
00092 }

EvtRaritaSchwinger EvtRaritaSchwinger::conj (   )  const
 

EvtComplex EvtRaritaSchwinger::get (  int  i,
int  j
)  const
  

00061 {return _rs[i][j];}

EvtDiracSpinor EvtRaritaSchwinger::getSpinor (  int  i  )  const
  

00163                                                        {
00164 
00165   EvtDiracSpinor tmp;
00166   tmp.set(_rs[0][i],_rs[1][i],_rs[2][i],_rs[3][i]);
00167   return tmp;
00168 
00169 }

EvtVector4C EvtRaritaSchwinger::getVector (  int  i  )  const
  

00156                                                     {
00157 
00158   EvtVector4C tmp(_rs[i][0],_rs[i][1],_rs[i][2],_rs[i][3]);
00159   return tmp;
00160 
00161 }

EvtRaritaSchwinger & EvtRaritaSchwinger::operator+= (  const EvtRaritaSchwinger &  u2  ) 
  

00242                                                                               {
00243 
00244   int i,j;
00245 
00246   for(i=0;i<4;i++){
00247     for(j=0;j<4;j++){
00248       _rs[i][j]+=u2._rs[i][j];
00249     }
00250   }
00251   
00252   return *this; 
00253 }

EvtRaritaSchwinger & EvtRaritaSchwinger::operator-= (  const EvtRaritaSchwinger &  u2  ) 
  

00262                                                                               {
00263 
00264   int i,j;
00265 
00266   for(i=0;i<4;i++){
00267     for(j=0;j<4;j++){
00268       _rs[i][j]+=u2._rs[i][j];
00269     }
00270   }
00271   
00272   return *this; 
00273 }

EvtRaritaSchwinger & EvtRaritaSchwinger::operator= (  const EvtRaritaSchwinger &  rs  )  [inline]
  

00125                                                                              {
00126 
00127   int i,j;
00128   for(i=0;i<4;i++){
00129     for(j=0;j<4;j++){
00130       _rs[i][j]=rs._rs[i][j];
00131     }
00132   }
00133 
00134   return *this;
00135 
00136 }

void EvtRaritaSchwinger::set (  int  i,
int  j,
const EvtComplex &  sp
) 
  

00059 {_rs[i][j]=sp;}

void EvtRaritaSchwinger::setSpinor (  int  i,
const EvtDiracSpinor &  sp
) 
  

00180                                                                 {
00181 
00182   _rs[0][i]=sp.get_spinor(0);
00183   _rs[1][i]=sp.get_spinor(1);
00184   _rs[2][i]=sp.get_spinor(2);
00185   _rs[3][i]=sp.get_spinor(3);
00186 
00187 }

void EvtRaritaSchwinger::setVector (  int  i,
const EvtVector4C &  v
) 
  

00171                                                             {
00172   
00173   _rs[i][0]=v.get(0);
00174   _rs[i][1]=v.get(1);
00175   _rs[i][2]=v.get(2);
00176   _rs[i][3]=v.get(3);
00177 
00178 }

Friends And Related Function Documentation

EvtRaritaSchwinger boostTo (  const EvtRaritaSchwinger &  rs,
const EvtVector3R  boost
)  [friend]
  

00050                                                    {
00051 
00052   EvtRaritaSchwinger tmp(rs);
00053   tmp.applyBoostTo(boost);
00054   return tmp;
00055 
00056 }

EvtRaritaSchwinger boostTo (  const EvtRaritaSchwinger &  rs,
const EvtVector4R  p4
)  [friend]
  

00041                                                 {
00042 
00043   EvtRaritaSchwinger tmp(rs);
00044   tmp.applyBoostTo(p4);
00045   return tmp;
00046 
00047 }

EvtRaritaSchwinger conj (  const EvtRaritaSchwinger &  u2  )  [friend]
 

EvtRaritaSchwinger dirProd (  EvtVector4C  v,
EvtDiracSpinor  u
)  [friend]
  

00207                                                           {
00208 
00209   int i,j;
00210 
00211   EvtRaritaSchwinger tmp;
00212 
00213   for(i=0;i<4;i++){
00214     for(j=0;j<4;j++){
00215       tmp._rs[i][j]=u.get_spinor(i)*v.get(j);
00216     }
00217   }
00218 
00219   return tmp;
00220 
00221 }

EvtRaritaSchwinger dirProd (  EvtVector4R  v,
EvtDiracSpinor  u
)  [friend]
  

00190                                                           {
00191 
00192   int i,j;
00193 
00194   EvtRaritaSchwinger tmp;
00195 
00196   for(i=0;i<4;i++){
00197     for(j=0;j<4;j++){
00198       tmp._rs[i][j]=u.get_spinor(i)*v.get(j);
00199     }
00200   }
00201 
00202   return tmp;
00203 
00204 }

EvtComplex operator * (  const EvtRaritaSchwinger &  u1,
const EvtRaritaSchwinger &  u2
)  [friend]
  

00225                                                   {
00226 
00227   int i,j;
00228   EvtComplex tmp=0.0;
00229 
00230   for(i=0;i<4;i++){
00231     for(j=0;j<4;j++){
00232       tmp+=conj(u1._rs[i][j])*u2._rs[i][j];
00233     }
00234   }
00235 
00236   return tmp;
00237 
00238 }

EvtRaritaSchwinger operator+ (  const EvtRaritaSchwinger &  u1,
const EvtRaritaSchwinger &  u2
)  [friend]
  

00256                                                              {
00257   
00258   return EvtRaritaSchwinger(u1)+=u2;
00259 
00260 }

EvtRaritaSchwinger operator- (  const EvtRaritaSchwinger &  u1,
const EvtRaritaSchwinger &  u2
)  [friend]
  

00276                                                              {
00277   
00278   return EvtRaritaSchwinger(u1)-=u2;
00279 
00280 }

std::ostream& operator<< (  std::ostream &  s,
const EvtRaritaSchwinger &  rs
)  [friend]
 

EvtRaritaSchwinger rotateEuler (  const EvtRaritaSchwinger &  rs,
double  alpha,
double  beta,
double  gamma
)  [friend]
  

00032                                                                      {
00033 
00034   EvtRaritaSchwinger tmp(rs);
00035   tmp.applyRotateEuler(alpha,beta,gamma);
00036   return tmp;
00037 
00038 }

Member Data Documentation

EvtComplex EvtRaritaSchwinger::_rs[4][4] [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:08:58 2011 for BOSS6.5.5 by  doxygen 1.3.9.1