DifFourVector Class Reference

#include <DifFourVector.h>

Public Member Functions
	DifFourVector ()
	DifFourVector (const DifNumber &mass, const DifVector &p)
	DifFourVector (const double &mass, const DifVector &p)
	DifFourVector (const DifFourVector &v)
	~DifFourVector ()
HepSymMatrix	errorMatrix (const HepSymMatrix &e) const
HepMatrix	jacobian () const
DifFourVector &	operator+= (const DifFourVector &v)
DifFourVector &	operator-= (const DifFourVector &v)
DifFourVector &	operator= (const DifFourVector &v)
DifFourVector	operator- () const
int	nPar () const
DifVector	direction () const
DifNumber	pMag () const
DifNumber	massSq () const
DifNumber	mass () const
void	print () const
DifFourVector &	zeroDerivatives ()
void	boostTo (const DifFourVector &)
void	boostFrom (const DifFourVector &)
void	boostToMe (std::vector< DifFourVector * > &listToBoost) const
void	boostFromMe (std::vector< DifFourVector * > &listToBoost) const

Public Attributes
DifNumber	E
DifVector	P

Friends
DifFourVector	operator+ (const DifFourVector &a, const DifFourVector &b)
DifFourVector	operator- (const DifFourVector &a, const DifFourVector &b)
DifNumber	operator* (const DifFourVector &a, const DifFourVector &b)

Detailed Description

Definition at line 34 of file DifFourVector.h.

Constructor & Destructor Documentation

DifFourVector() [1/4]

DifFourVector::DifFourVector

(

)

Definition at line 27 of file DifFourVector.cxx.

  :E(0.0),P(0.0,0.0,0.0)
{} 

DifFourVector() [2/4]

DifFourVector::DifFourVector	(	const DifNumber &	mass,
		const DifVector &	p )

Definition at line 31 of file DifFourVector.cxx.

  :E(sqrt(m*m+p*p)),P(p)
{}

DifFourVector() [3/4]

DifFourVector::DifFourVector	(	const double &	mass,
		const DifVector &	p )

Definition at line 35 of file DifFourVector.cxx.

  :E(sqrt(m*m+p*p)),P(p)
{}

DifFourVector() [4/4]

DifFourVector::DifFourVector

(

const DifFourVector &

v

)

Definition at line 40 of file DifFourVector.cxx.

  :E(v.E),P(v.P)
{}

~DifFourVector()

DifFourVector::~DifFourVector ( )

inline

Definition at line 48 of file DifFourVector.h.

{}      // destroy

Member Function Documentation

boostFrom()

void DifFourVector::boostFrom

(

const DifFourVector &

pFrom

)

Definition at line 166 of file DifFourVector.cxx.

{
 const DifVector xHat(1,0,0);
  const DifVector yHat(0,1,0);
  const DifVector zHat(0,1,0);
  DifVector z=pFrom.direction();
  DifVector y=zHat-z*(zHat*z);
  if(y.length()<0.01) y=xHat-z*(xHat*z);
  y.normalize();
  DifVector x(cross(y,z));
  
  DifNumber px=P*x;
  DifNumber py=P*y;
  DifNumber pz=P*z;
 
  DifNumber gamma=pFrom.E/pFrom.mass();
  DifNumber beta=pFrom.pMag()/pFrom.E;
 
  DifNumber pzP=gamma*(pz+beta*E);
  DifNumber eP=gamma*(E+beta*pz);
 
  E=eP;
  P=px*x+py*y+pzP*z;
}

boostFromMe()

void DifFourVector::boostFromMe

(

std::vector< DifFourVector * > &

listToBoost

)

const

Definition at line 134 of file DifFourVector.cxx.

                                                              {
  const DifVector xHat(1,0,0);
  const DifVector yHat(0,1,0);
  const DifVector zHat(0,0,1);
  DifVector z=P;
  z.normalize();
  DifVector y(zHat-z*(zHat*z));
  if(y.lengthSq()<0.0001) y=xHat-z*(xHat*z);
  y.normalize();
  DifVector x(cross(y,z));
  
  DifNumber gamma=E/mass();
  DifNumber beta=pMag()/E;
  
  for(int i=0;i<(int)list.size();i++) {
    DifFourVector& p4i=*list[i];
    DifNumber px=p4i.P*x;
    DifNumber py=p4i.P*y;
    DifNumber pz=p4i.P*z;
    DifNumber e=p4i.E;
 
    DifNumber pzP=gamma*(pz+beta*e);
    DifNumber eP=gamma*(e+beta*pz);
    
    p4i.E=eP;
    p4i.P=px*x+py*y+pzP*z;
 
  }
    
}

boostTo()

void DifFourVector::boostTo

(

const DifFourVector &

pTo

)

Definition at line 72 of file DifFourVector.cxx.

{
  const DifVector xHat(1,0,0);
  const DifVector yHat(0,1,0);
  const DifVector zHat(0,1,0);
  DifVector z=pTo.direction();
  DifVector y=zHat-z*(zHat*z);
  if(y.length()<0.01) y=xHat-z*(xHat*z);
  y.normalize();
  DifVector x(cross(y,z));
  
  DifNumber px=P*x;
  DifNumber py=P*y;
  DifNumber pz=P*z;
 
  DifNumber gamma=pTo.E/pTo.mass();
  DifNumber beta=pTo.pMag()/pTo.E;
 
  DifNumber pzP=gamma*(pz-beta*E);
  DifNumber eP=gamma*(E-beta*pz);
 
  E=eP;
  P=px*x+py*y+pzP*z;
 
  return;
 
}

boostToMe()

void DifFourVector::boostToMe

(

std::vector< DifFourVector * > &

listToBoost

)

const

Definition at line 101 of file DifFourVector.cxx.

                                                            {
  const DifVector xHat(1,0,0);
  const DifVector yHat(0,1,0);
  const DifVector zHat(0,0,1);
  DifVector z=P;
  z.normalize();
  DifVector y(zHat-z*(zHat*z));
  if(y.lengthSq()<0.0001) y=xHat-z*(xHat*z);
  y.normalize();
  DifVector x(cross(y,z));
  
  DifNumber gamma=E/mass();
  DifNumber beta=pMag()/E;
  
  for(int i=0;i<(int)list.size();i++) {
    DifFourVector& p4i=*list[i];
    DifNumber px=p4i.P*x;
    DifNumber py=p4i.P*y;
    DifNumber pz=p4i.P*z;
    DifNumber e=p4i.E;
 
    DifNumber pzP=gamma*(pz-beta*e);
    DifNumber eP=gamma*(e-beta*pz);
    
    p4i.E=eP;
    p4i.P=px*x+py*y+pzP*z;
 
  }
    
}

direction()

DifVector DifFourVector::direction ( ) const

inline

Referenced by boostFrom(), and boostTo().

errorMatrix()

HepSymMatrix DifFourVector::errorMatrix

(

const HepSymMatrix &

e

)

const

Definition at line 44 of file DifFourVector.cxx.

                                                                  {
  HepSymMatrix temp(4);
  temp(1,1)=correlation(E,E,e);  
  temp(1,2)=correlation(E,P.x,e);
  temp(1,3)=correlation(E,P.y,e);
  temp(1,4)=correlation(E,P.z,e);
  temp(2,2)=correlation(P.x,P.x,e);
  temp(2,3)=correlation(P.x,P.y,e);
  temp(2,4)=correlation(P.x,P.z,e);
  temp(3,3)=correlation(P.y,P.y,e);
  temp(3,4)=correlation(P.y,P.z,e);
  temp(4,4)=correlation(P.z,P.z,e);
  return temp;
}

jacobian()

HepMatrix DifFourVector::jacobian

(

)

const

Definition at line 59 of file DifFourVector.cxx.

                                      {
  int npar=E.nPar();
  HepMatrix temp(4,npar);
  for(int i=1; i<=npar; i++){
    temp(1,i)=E.derivative(i);
    temp(2,i)=P.x.derivative(i);
    temp(3,i)=P.y.derivative(i);
    temp(4,i)=P.z.derivative(i);
  } // (int i=1; i<=npar; i++)
  return temp;
}

mass()

DifNumber DifFourVector::mass ( ) const

inline

Definition at line 77 of file DifFourVector.h.

                               {
    DifNumber temp=massSq();
    if(temp>=0) return sqrt(temp);
    return -sqrt(-massSq());
  }

Referenced by boostFrom(), boostFromMe(), boostTo(), and boostToMe().

massSq()

DifNumber DifFourVector::massSq ( ) const

inline

Definition at line 76 of file DifFourVector.h.

{return E*E-P*P;}

Referenced by mass().

nPar()

int DifFourVector::nPar ( ) const

inline

operator+=()

DifFourVector & DifFourVector::operator+= ( const DifFourVector & v )

inline

operator-()

DifFourVector DifFourVector::operator- ( ) const

inline

operator-=()

DifFourVector & DifFourVector::operator-= ( const DifFourVector & v )

inline

operator=()

DifFourVector & DifFourVector::operator= ( const DifFourVector & v )

inline

pMag()

DifNumber DifFourVector::pMag ( ) const

inline

Definition at line 75 of file DifFourVector.h.

{return P.length();}

Referenced by boostFrom(), boostFromMe(), boostTo(), and boostToMe().

print()

void DifFourVector::print

(

)

const

Definition at line 192 of file DifFourVector.cxx.

                                {
//SKIP  cout << "E:" << endl << E;
//SKIP  cout << "P:" << endl << P;
  cout << "SKIP of DifFourVector::print()" <<endl;//TEMP
}

zeroDerivatives()

DifFourVector & DifFourVector::zeroDerivatives ( )

inline

Friends And Related Symbol Documentation

operator*

DifNumber operator* ( const DifFourVector & a, const DifFourVector & b )

friend

operator+

DifFourVector operator+ ( const DifFourVector & a, const DifFourVector & b )

friend

operator-

DifFourVector operator- ( const DifFourVector & a, const DifFourVector & b )

friend

Member Data Documentation

E

DifNumber DifFourVector::E

Definition at line 114 of file DifFourVector.h.

Referenced by boostFrom(), boostFromMe(), boostTo(), boostToMe(), errorMatrix(), jacobian(), and massSq().

P

DifVector DifFourVector::P

Definition at line 115 of file DifFourVector.h.

Referenced by boostFrom(), boostFromMe(), boostTo(), boostToMe(), errorMatrix(), jacobian(), massSq(), and pMag().

---

The documentation for this class was generated from the following files:

• DifFourVector.h
• DifFourVector.cxx