TEvtGen/EvtGen/EvtGenBase/EvtVector4C.cpp

   1 //--------------------------------------------------------------------------
   2 //
   3 // Environment:
   4 //      This software is part of the EvtGen package developed jointly
   5 //      for the BaBar and CLEO collaborations.  If you use all or part
   6 //      of it, please give an appropriate acknowledgement.
   7 //
   8 // Copyright Information: See EvtGen/COPYRIGHT
   9 //      Copyright (C) 1998      Caltech, UCSB
  10 //
  11 // Module: EvtVector4C.cc
  12 //
  13 // Description: EvtComplex implemention of 4 - vectors
  14 //
  15 // Modification history:
  16 //
  17 //    DJL/RYD   September 25, 1996           Module created
  18 //
  19 //------------------------------------------------------------------------
  20 //
  21 #include "EvtGenBase/EvtPatches.hh"
  22 #include <iostream>
  23 #include <math.h>
  24 #include <assert.h>
  25 #include "EvtGenBase/EvtComplex.hh"
  26 #include "EvtGenBase/EvtVector4C.hh"
  27 using std::ostream;
  28
  29
  30 EvtVector4C::EvtVector4C(){
  31
  32   v[0]=EvtComplex(0.0); v[1]=EvtComplex(0.0);
  33   v[2]=EvtComplex(0.0); v[3]=EvtComplex(0.0);
  34
  35 }
  36
  37 EvtVector4C::~EvtVector4C(){}
  38
  39 EvtVector4C::EvtVector4C(const EvtComplex& e0,const EvtComplex& e1,
  40                          const EvtComplex& e2,const EvtComplex& e3){
  41
  42   v[0]=e0; v[1]=e1; v[2]=e2; v[3]=e3;
  43 }
  44
  45
  46 EvtVector4C rotateEuler(const EvtVector4C& rs,
  47                         double alpha,double beta,double gamma){
  48
  49   EvtVector4C tmp(rs);
  50   tmp.applyRotateEuler(alpha,beta,gamma);
  51   return tmp;
  52
  53 }
  54
  55 EvtVector4C boostTo(const EvtVector4C& rs,
  56                     const EvtVector4R p4){
  57
  58   EvtVector4C tmp(rs);
  59   tmp.applyBoostTo(p4);
  60   return tmp;
  61
  62 }
  63
  64 EvtVector4C boostTo(const EvtVector4C& rs,
  65                     const EvtVector3R boost){
  66
  67   EvtVector4C tmp(rs);
  68   tmp.applyBoostTo(boost);
  69   return tmp;
  70
  71 }
  72
  73 void EvtVector4C::applyBoostTo(const EvtVector4R& p4){
  74
  75   double e=p4.get(0);
  76
  77   EvtVector3R boost(p4.get(1)/e,p4.get(2)/e,p4.get(3)/e);
  78
  79   applyBoostTo(boost);
  80
  81   return;
  82
  83 }
  84
  85 void EvtVector4C::applyBoostTo(const EvtVector3R& boost){
  86
  87   double bx,by,bz,gamma,b2;
  88
  89   bx=boost.get(0);
  90   by=boost.get(1);
  91   bz=boost.get(2);
  92
  93   double bxx=bx*bx;
  94   double byy=by*by;
  95   double bzz=bz*bz;
  96
  97   b2=bxx+byy+bzz;
  98
  99
 100   if (b2==0.0){
 101     return;
 102   }
 103
 104   assert(b2<1.0);
 105
 106   gamma=1.0/sqrt(1-b2);
 107
 108
 109   double gb2=(gamma-1.0)/b2;
 110
 111   double gb2xy=gb2*bx*by;
 112   double gb2xz=gb2*bx*bz;
 113   double gb2yz=gb2*by*bz;
 114
 115   double gbx=gamma*bx;
 116   double gby=gamma*by;
 117   double gbz=gamma*bz;
 118
 119   EvtComplex e2=v[0];
 120   EvtComplex px2=v[1];
 121   EvtComplex py2=v[2];
 122   EvtComplex pz2=v[3];
 123
 124   v[0]=gamma*e2+gbx*px2+gby*py2+gbz*pz2;
 125
 126   v[1]=gbx*e2+gb2*bxx*px2+px2+gb2xy*py2+gb2xz*pz2;
 127
 128   v[2]=gby*e2+gb2*byy*py2+py2+gb2xy*px2+gb2yz*pz2;
 129
 130   v[3]=gbz*e2+gb2*bzz*pz2+pz2+gb2yz*py2+gb2xz*px2;
 131
 132   return;
 133
 134 }
 135
 136 void EvtVector4C::applyRotateEuler(double phi,double theta,double ksi){
 137
 138   double sp=sin(phi);
 139   double st=sin(theta);
 140   double sk=sin(ksi);
 141   double cp=cos(phi);
 142   double ct=cos(theta);
 143   double ck=cos(ksi);
 144
 145   EvtComplex x=( ck*ct*cp-sk*sp)*v[1]+( -sk*ct*cp-ck*sp)*v[2]+st*cp*v[3];
 146   EvtComplex y=( ck*ct*sp+sk*cp)*v[1]+(-sk*ct*sp+ck*cp)*v[2]+st*sp*v[3];
 147   EvtComplex z=-ck*st*v[1]+sk*st*v[2]+ct*v[3];
 148
 149   v[1]=x;
 150   v[2]=y;
 151   v[3]=z;
 152
 153 }
 154
 155
 156 ostream& operator<<(ostream& s, const EvtVector4C& v){
 157
 158   s<<"("<<v.v[0]<<","<<v.v[1]<<","<<v.v[2]<<","<<v.v[3]<<")";
 159
 160   return s;
 161
 162 }
 163