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

EvtVector4R Class Reference

#include <EvtVector4R.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)
double cont (const EvtVector4R &v4) const
EvtVector4R cross (const EvtVector4R &v2)
double d3mag () const
double dot (const EvtVector4R &v2) const
double dotr3 (const EvtVector4R &p1, const EvtVector4R &p2) const
 EvtVector4R (double e, double px, double py, double pz)
 EvtVector4R ()
double get (int i) const
double mag2r3 (const EvtVector4R &p1) const
double magr3 (const EvtVector4R &p1) const
double mass () const
double mass2 () const
EvtVector4R & operator *= (double c)
EvtVector4R & operator+= (const EvtVector4R &v2)
EvtVector4R & operator-= (const EvtVector4R &v2)
EvtVector4R & operator/= (double c)
EvtVector4R & operator= (const EvtVector4R &v2)
double scalartripler3 (const EvtVector4R &p1, const EvtVector4R &p2, const EvtVector4R &p3) const
void set (double e, double px, double py, double pz)
void set (int i, double d)

Private Member Functions

double Square (double x) const

Private Attributes

double v [4]

Friends

EvtVector4R boostTo (const EvtVector4R &rs, const EvtVector3R &boost)
EvtVector4R boostTo (const EvtVector4R &rs, const EvtVector4R &p4)
double operator * (const EvtVector4R &v1, const EvtVector4R &v2)
EvtVector4R operator * (const EvtVector4R &v2, double d)
EvtVector4R operator * (double d, const EvtVector4R &v2)
EvtVector4R operator+ (const EvtVector4R &v1, const EvtVector4R &v2)
EvtVector4R operator- (const EvtVector4R &v1, const EvtVector4R &v2)
EvtVector4R operator/ (const EvtVector4R &v2, double d)
std::ostream & operator<< (std::ostream &s, const EvtVector4R &v)
EvtVector4R rotateEuler (const EvtVector4R &rs, double alpha, double beta, double gamma)

Constructor & Destructor Documentation

EvtVector4R::EvtVector4R (   )  [inline]
  

00047 {}

EvtVector4R::EvtVector4R (  double  e,
double  px,
double  py,
double  pz
) 
  

00034                                                                {
00035   
00036   v[0]=e; v[1]=p1; v[2]=p2; v[3]=p3;
00037 }

Member Function Documentation

void EvtVector4R::applyBoostTo (  const EvtVector3R &  boost  ) 
  

00120                                                       {
00121 
00122   double bx,by,bz,gamma,b2;
00123 
00124   bx=boost.get(0);
00125   by=boost.get(1);
00126   bz=boost.get(2);
00127 
00128   double bxx=bx*bx;
00129   double byy=by*by;
00130   double bzz=bz*bz;
00131 
00132   b2=bxx+byy+bzz;
00133 
00134 
00135   if (b2==0.0){
00136     return;
00137   }
00138 
00139   assert(b2<1.0);
00140 
00141   gamma=1.0/sqrt(1-b2);
00142 
00143 
00144   double gb2=(gamma-1.0)/b2;
00145 
00146   double gb2xy=gb2*bx*by;
00147   double gb2xz=gb2*bx*bz;
00148   double gb2yz=gb2*by*bz;
00149 
00150   double gbx=gamma*bx;
00151   double gby=gamma*by;
00152   double gbz=gamma*bz;
00153 
00154   double e2=v[0];
00155   double px2=v[1];
00156   double py2=v[2];
00157   double pz2=v[3];
00158 
00159   v[0]=gamma*e2+gbx*px2+gby*py2+gbz*pz2;
00160 
00161   v[1]=gbx*e2+gb2*bxx*px2+px2+gb2xy*py2+gb2xz*pz2;
00162 
00163   v[2]=gby*e2+gb2*byy*py2+py2+gb2xy*px2+gb2yz*pz2;
00164 
00165   v[3]=gbz*e2+gb2*bzz*pz2+pz2+gb2yz*py2+gb2xz*px2;
00166 
00167   return;
00168 
00169 }

void EvtVector4R::applyBoostTo (  const EvtVector4R &  p4  ) 
  

00108                                                    {
00109 
00110   double e=p4.get(0);
00111 
00112   EvtVector3R boost(p4.get(1)/e,p4.get(2)/e,p4.get(3)/e);
00113 
00114   applyBoostTo(boost);
00115 
00116   return;
00117 
00118 }

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

00081                                                                     {
00082 
00083   double sp=sin(phi);
00084   double st=sin(theta);
00085   double sk=sin(ksi);
00086   double cp=cos(phi);
00087   double ct=cos(theta);
00088   double ck=cos(ksi);
00089 
00090   double x=( ck*ct*cp-sk*sp)*v[1]+( -sk*ct*cp-ck*sp)*v[2]+st*cp*v[3];
00091   double y=( ck*ct*sp+sk*cp)*v[1]+(-sk*ct*sp+ck*cp)*v[2]+st*sp*v[3];
00092   double z=-ck*st*v[1]+sk*st*v[2]+ct*v[3];
00093 
00094   v[1]=x;
00095   v[2]=y;
00096   v[3]=z;
00097   
00098 }

double EvtVector4R::cont (  const EvtVector4R &  v4  )  const [inline]
  

00162                                                            {
00163   
00164   return v[0]*v4.v[0]-v[1]*v4.v[1]-
00165          v[2]*v4.v[2]-v[3]*v4.v[3];
00166 }

EvtVector4R EvtVector4R::cross (  const EvtVector4R &  v2  ) 
  

00171                                                      {
00172 
00173   //Calcs the cross product.  Added by djl on July 27, 1995.
00174   //Modified for real vectros by ryd Aug 28-96
00175 
00176   EvtVector4R temp;
00177   
00178   temp.v[0] = 0.0; 
00179   temp.v[1] = v[2]*p2.v[3] - v[3]*p2.v[2];
00180   temp.v[2] = v[3]*p2.v[1] - v[1]*p2.v[3];
00181   temp.v[3] = v[1]*p2.v[2] - v[2]*p2.v[1];
00182 
00183   return temp;
00184 }

double EvtVector4R::d3mag (   )  const
  

00189 {
00190   double temp;
00191 
00192   temp = v[1]*v[1]+v[2]*v[2]+v[3]*v[3];
00193 
00194   temp = sqrt( temp );
00195 
00196   return temp;
00197 } // r3mag

double EvtVector4R::dot (  const EvtVector4R &  v2  )  const
  

00199                                                     {
00200 
00201   //Returns the dot product of the 3 momentum.  Added by
00202   //djl on July 27, 1995.  for real!!!
00203 
00204   double temp;
00205 
00206   temp = v[1]*p2.v[1];
00207   temp += v[2]*p2.v[2];
00208   temp += v[3]*p2.v[3];
00209  
00210   return temp;
00211 
00212 } //dot

double EvtVector4R::dotr3 (  const EvtVector4R &  p1,
const EvtVector4R &  p2
)  const
  

00230 {
00231     return 1/mass2() * ((*this) * p1) * ((*this) * p2) - p1 * p2;
00232 }

double EvtVector4R::get (  int  i  )  const [inline]
  

00178                                           {
00179   return v[i];
00180 }

double EvtVector4R::mag2r3 (  const EvtVector4R &  p1  )  const
  

00237 {
00238     return Square((*this) * p1)/mass2() - p1.mass2();
00239 }

double EvtVector4R::magr3 (  const EvtVector4R &  p1  )  const
  

00243 {
00244     return sqrt(mag2r3(p1));
00245 }

double EvtVector4R::mass (   )  const
  

00039                               {
00040 
00041   double m2=v[0]*v[0]-v[1]*v[1]-v[2]*v[2]-v[3]*v[3];
00042 
00043   if (m2>0.0) {
00044     return sqrt(m2);
00045   }
00046   else{
00047     return 0.0;
00048   }
00049 }

double EvtVector4R::mass2 (   )  const [inline]
  

00115                                       {
00116 
00117   return v[0]*v[0]-v[1]*v[1]-v[2]*v[2]-v[3]*v[3];
00118 }

EvtVector4R & EvtVector4R::operator *= (  double  c  )  [inline]
  

00135                                                    {
00136 
00137   v[0]*=c;  
00138   v[1]*=c;  
00139   v[2]*=c;  
00140   v[3]*=c;  
00141 
00142   return *this;
00143 }

EvtVector4R & EvtVector4R::operator+= (  const EvtVector4R &  v2  )  [inline]
  

00095                                                                 {
00096 
00097   v[0]+=v2.v[0];
00098   v[1]+=v2.v[1];
00099   v[2]+=v2.v[2];
00100   v[3]+=v2.v[3];
00101   
00102   return *this; 
00103 }

EvtVector4R & EvtVector4R::operator-= (  const EvtVector4R &  v2  )  [inline]
  

00105                                                                 {
00106 
00107   v[0]-=v2.v[0];
00108   v[1]-=v2.v[1];
00109   v[2]-=v2.v[2];
00110   v[3]-=v2.v[3];
00111   
00112   return *this; 
00113 }

EvtVector4R & EvtVector4R::operator/= (  double  c  )  [inline]
  

00145                                                    {
00146 
00147   double cinv=1.0/c;  
00148   v[0]*=cinv;  
00149   v[1]*=cinv;  
00150   v[2]*=cinv;  
00151   v[3]*=cinv;  
00152 
00153   return *this;
00154 }

EvtVector4R & EvtVector4R::operator= (  const EvtVector4R &  v2  )  [inline]
  

00085                                                                {
00086 
00087   v[0]=v2.v[0];
00088   v[1]=v2.v[1];
00089   v[2]=v2.v[2];
00090   v[3]=v2.v[3];
00091   
00092   return *this; 
00093 }

double EvtVector4R::scalartripler3 (  const EvtVector4R &  p1,
const EvtVector4R &  p2,
const EvtVector4R &  p3
)  const
  

00219 {
00220     EvtVector4C lc=dual(directProd(*this, p1)).cont2(p2);
00221     EvtVector4R  l(real(lc.get(0)), real(lc.get(1)), real(lc.get(2)),
00222             real(lc.get(3)));
00223 
00224     return -1.0/mass() * (l * p3);
00225 }

void EvtVector4R::set (  double  e,
double  px,
double  py,
double  pz
)  [inline]
  

00187                                                                    {
00188 
00189   v[0]=e;
00190   v[1]=p1;
00191   v[2]=p2;
00192   v[3]=p3;
00193 }

void EvtVector4R::set (  int  i,
double  d
)  [inline]
  

00182                                           {
00183   
00184   v[i]=d;
00185 }

double EvtVector4R::Square (  double  x  )  const [inline, private]
  

00080 { return x*x; }

Friends And Related Function Documentation

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

00071                                              {
00072 
00073   EvtVector4R tmp(rs);
00074   tmp.applyBoostTo(boost);
00075   return tmp;
00076 
00077 }

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

00062                                           {
00063 
00064   EvtVector4R tmp(rs);
00065   tmp.applyBoostTo(p4);
00066   return tmp;
00067 
00068 }

double operator * (  const EvtVector4R &  v1,
const EvtVector4R &  v2
)  [friend]
  

00156                                                                     {
00157 
00158   return v1.v[0]*v2.v[0]-v1.v[1]*v2.v[1]-
00159          v1.v[2]*v2.v[2]-v1.v[3]*v2.v[3];
00160 }

EvtVector4R operator * (  const EvtVector4R &  v2,
double  d
)  [friend]
  

00125                                                             {
00126   
00127   return EvtVector4R(v2)*=c;
00128 }

EvtVector4R operator * (  double  d,
const EvtVector4R &  v2
)  [friend]
  

00120                                                             {
00121   
00122   return EvtVector4R(v2)*=c;
00123 }

EvtVector4R operator+ (  const EvtVector4R &  v1,
const EvtVector4R &  v2
)  [friend]
  

00173                                                                          {
00174   
00175   return EvtVector4R(v1)+=v2;
00176 }

EvtVector4R operator- (  const EvtVector4R &  v1,
const EvtVector4R &  v2
)  [friend]
  

00168                                                                          {
00169   
00170   return EvtVector4R(v1)-=v2;
00171 }

EvtVector4R operator/ (  const EvtVector4R &  v2,
double  d
)  [friend]
  

00130                                                             {
00131   
00132   return EvtVector4R(v2)/=c;
00133 }

std::ostream& operator<< (  std::ostream &  s,
const EvtVector4R &  v
)  [friend]
 

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

00053                                                               {
00054 
00055   EvtVector4R tmp(rs);
00056   tmp.applyRotateEuler(alpha,beta,gamma);
00057   return tmp;
00058 
00059 }

Member Data Documentation

double EvtVector4R::v[4] [private]
 

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