EvtRaritaSchwinger.cc

Go to the documentation of this file.

//--------------------------------------------------------------------------
//
// Environment:
//      This software is part of the EvtGen package developed jointly
//      for the BaBar and CLEO collaborations.  If you use all or part
//      of it, please give an appropriate acknowledgement.
//
// Copyright Information: See EvtGen/COPYRIGHT
//      Copyright (C) 2000      Caltech, UCSB
//
// Module: EvtGen/EvtRaritaSchwing.hh
//
// Description:Class to handle spin 3/2
//
// Modification history:
//
//    RYD     April 23, 2000         Module created
//
//------------------------------------------------------------------------
#include "EvtGenBase/EvtPatches.hh"
 
 
#include "EvtGenBase/EvtRaritaSchwinger.hh"
using std::endl;
using std::ostream;
 
EvtRaritaSchwinger::~EvtRaritaSchwinger(){
}
 
 
EvtRaritaSchwinger rotateEuler(const EvtRaritaSchwinger& rs,
                   double alpha,double beta,double gamma){
 
  EvtRaritaSchwinger tmp(rs);
  tmp.applyRotateEuler(alpha,beta,gamma);
  return tmp;
 
}
 
EvtRaritaSchwinger boostTo(const EvtRaritaSchwinger& rs,
               const EvtVector4R p4){
 
  EvtRaritaSchwinger tmp(rs);
  tmp.applyBoostTo(p4);
  return tmp;
 
}
 
EvtRaritaSchwinger boostTo(const EvtRaritaSchwinger& rs,
               const EvtVector3R boost){
 
  EvtRaritaSchwinger tmp(rs);
  tmp.applyBoostTo(boost);
  return tmp;
 
}
 
 
void EvtRaritaSchwinger::set(int i,int j,const EvtComplex& sp){_rs[i][j]=sp;}
 
EvtComplex EvtRaritaSchwinger::get(int i,int j) const {return _rs[i][j];} 
 
void EvtRaritaSchwinger::applyRotateEuler(double alpha,double beta,
                      double gamma){
 
  //inefficient but simple to code...
  EvtVector4C v0=getVector(0);
  EvtVector4C v1=getVector(1);
  EvtVector4C v2=getVector(2);
  EvtVector4C v3=getVector(3);
  v0.applyRotateEuler(alpha,beta,gamma);
  v1.applyRotateEuler(alpha,beta,gamma);
  v2.applyRotateEuler(alpha,beta,gamma);
  v3.applyRotateEuler(alpha,beta,gamma);
  setVector(0,v0);
  setVector(1,v1);
  setVector(2,v2);
  setVector(3,v3);
  EvtDiracSpinor sp0=getSpinor(0);
  EvtDiracSpinor sp1=getSpinor(1);
  EvtDiracSpinor sp2=getSpinor(2);
  EvtDiracSpinor sp3=getSpinor(3);
  sp0.applyRotateEuler(alpha,beta,gamma);
  sp1.applyRotateEuler(alpha,beta,gamma);
  sp2.applyRotateEuler(alpha,beta,gamma);
  sp3.applyRotateEuler(alpha,beta,gamma);
  setSpinor(0,sp0);
  setSpinor(1,sp1);
  setSpinor(2,sp2);
  setSpinor(3,sp3);
 
}
  
 
void EvtRaritaSchwinger::applyBoostTo(const EvtVector4R p4){
 
  double e=p4.get(0);
 
  EvtVector3R boost(p4.get(1)/e,p4.get(2)/e,p4.get(3)/e);
 
  applyBoostTo(boost);
  
  return;
 
}
  
 
void EvtRaritaSchwinger::applyBoostTo(const EvtVector3R boost){
 
  //inefficient but simple to code...
  EvtVector4C v0=getVector(0);
  EvtVector4C v1=getVector(1);
  EvtVector4C v2=getVector(2);
  EvtVector4C v3=getVector(3);
  v0.applyBoostTo(boost);
  v1.applyBoostTo(boost);
  v2.applyBoostTo(boost);
  v3.applyBoostTo(boost);
  setVector(0,v0);
  setVector(1,v1);
  setVector(2,v2);
  setVector(3,v3);
  EvtDiracSpinor sp0=getSpinor(0);
  EvtDiracSpinor sp1=getSpinor(1);
  EvtDiracSpinor sp2=getSpinor(2);
  EvtDiracSpinor sp3=getSpinor(3);
  sp0.applyBoostTo(boost);
  sp1.applyBoostTo(boost);
  sp2.applyBoostTo(boost);
  sp3.applyBoostTo(boost);
  setSpinor(0,sp0);
  setSpinor(1,sp1);
  setSpinor(2,sp2);
  setSpinor(3,sp3);
 
 
}
 
 
ostream& operator<<(ostream& s, const EvtRaritaSchwinger& rs){
 
  int i,j;
  s<< endl;
  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      s << rs._rs[i][j];
    }
    s << endl;
  }
  return s;
  
}
 
 
 
EvtVector4C EvtRaritaSchwinger::getVector(int i) const{
 
  EvtVector4C tmp(_rs[i][0],_rs[i][1],_rs[i][2],_rs[i][3]);
  return tmp;
 
}
 
EvtDiracSpinor EvtRaritaSchwinger::getSpinor(int i) const{
 
  EvtDiracSpinor tmp;
  tmp.set(_rs[0][i],_rs[1][i],_rs[2][i],_rs[3][i]);
  return tmp;
 
}
 
void EvtRaritaSchwinger::setVector(int i,const EvtVector4C& v){
  
  _rs[i][0]=v.get(0);
  _rs[i][1]=v.get(1);
  _rs[i][2]=v.get(2);
  _rs[i][3]=v.get(3);
 
}
 
void EvtRaritaSchwinger::setSpinor(int i,const EvtDiracSpinor& sp){
 
  _rs[0][i]=sp.get_spinor(0);
  _rs[1][i]=sp.get_spinor(1);
  _rs[2][i]=sp.get_spinor(2);
  _rs[3][i]=sp.get_spinor(3);
 
}
 
 
EvtRaritaSchwinger dirProd(EvtVector4R v,EvtDiracSpinor u){
 
  int i,j;
 
  EvtRaritaSchwinger tmp;
 
  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      tmp._rs[i][j]=u.get_spinor(i)*v.get(j);
    }
  }
 
  return tmp;
 
}
 
 
EvtRaritaSchwinger dirProd(EvtVector4C v,EvtDiracSpinor u){
 
  int i,j;
 
  EvtRaritaSchwinger tmp;
 
  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      tmp._rs[i][j]=u.get_spinor(i)*v.get(j);
    }
  }
 
  return tmp;
 
}
 
 
EvtComplex operator*(const EvtRaritaSchwinger& u1,
             const EvtRaritaSchwinger& u2){
 
  int i,j;
  EvtComplex tmp=0.0;
 
  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      tmp+=conj(u1._rs[i][j])*u2._rs[i][j];
    }
  }
 
  return tmp;
 
}
 
 
 
EvtRaritaSchwinger& EvtRaritaSchwinger::operator+=(const EvtRaritaSchwinger& u2){
 
  int i,j;
 
  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      _rs[i][j]+=u2._rs[i][j];
    }
  }
  
  return *this; 
}
 
EvtRaritaSchwinger operator+(const EvtRaritaSchwinger& u1,
                const EvtRaritaSchwinger& u2){
  
  return EvtRaritaSchwinger(u1)+=u2;
 
}
 
EvtRaritaSchwinger& EvtRaritaSchwinger::operator-=(const EvtRaritaSchwinger& u2){
 
  int i,j;
 
  for(i=0;i<4;i++){
    for(j=0;j<4;j++){
      _rs[i][j]+=u2._rs[i][j];
    }
  }
  
  return *this; 
}
 
EvtRaritaSchwinger operator-(const EvtRaritaSchwinger& u1,
                const EvtRaritaSchwinger& u2){
  
  return EvtRaritaSchwinger(u1)-=u2;
 
}