ROOT logo
// @(#)root/physics:$Id$
// Author: Pasha Murat , Peter Malzacher  12/02/99

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TLorentzVector
#define ROOT_TLorentzVector


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TLorentzVector                                                       //
//                                                                      //
// Place holder for real lorentz vector class.                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TMath
#include "TMath.h"
#endif
#ifndef ROOT_TVector3
#include "TVector3.h"
#endif
#ifndef ROOT_TRotation
#include "TRotation.h"
#endif


class TLorentzRotation;


class TLorentzVector : public TObject {

private:

   TVector3 fP;  // 3 vector component
   Double_t fE;  // time or energy of (x,y,z,t) or (px,py,pz,e)

public:

   typedef Double_t Scalar;   // to be able to use it with the ROOT::Math::VectorUtil functions

   enum { kX=0, kY=1, kZ=2, kT=3, kNUM_COORDINATES=4, kSIZE=kNUM_COORDINATES };
   // Safe indexing of the coordinates when using with matrices, arrays, etc.

   TLorentzVector();

   TLorentzVector(Double_t x, Double_t y, Double_t z, Double_t t);
   // Constructor giving the components x, y, z, t.

   TLorentzVector(const Double_t * carray);
   TLorentzVector(const Float_t * carray);
   // Constructor from an array, not checked!

   TLorentzVector(const TVector3 & vector3, Double_t t);
   // Constructor giving a 3-Vector and a time component.

   TLorentzVector(const TLorentzVector & lorentzvector);
   // Copy constructor.

   virtual ~TLorentzVector();
   // Destructor

   // inline operator TVector3 () const;
   // inline operator TVector3 & ();
   // Conversion (cast) to TVector3.

   inline Double_t X() const;
   inline Double_t Y() const;
   inline Double_t Z() const;
   inline Double_t T() const;
   // Get position and time.

   inline void SetX(Double_t a);
   inline void SetY(Double_t a);
   inline void SetZ(Double_t a);
   inline void SetT(Double_t a);
   // Set position and time.

   inline Double_t Px() const;
   inline Double_t Py() const;
   inline Double_t Pz() const;
   inline Double_t P()  const;
   inline Double_t E()  const;
   inline Double_t Energy() const;
   // Get momentum and energy.

   inline void SetPx(Double_t a);
   inline void SetPy(Double_t a);
   inline void SetPz(Double_t a);
   inline void SetE(Double_t a);
   // Set momentum and energy.

   inline TVector3 Vect() const ;
   // Get spatial component.

   inline void SetVect(const TVector3 & vect3);
   // Set spatial component.

   inline Double_t Theta() const;
   inline Double_t CosTheta() const;
   inline Double_t Phi() const; //returns phi from -pi to pi
   inline Double_t Rho() const;
   // Get spatial vector components in spherical coordinate system.

   inline void SetTheta(Double_t theta);
   inline void SetPhi(Double_t phi);
   inline void SetRho(Double_t rho);
   // Set spatial vector components in spherical coordinate system.

   inline void SetPxPyPzE(Double_t px, Double_t py, Double_t pz, Double_t e);
   inline void SetXYZT(Double_t  x, Double_t  y, Double_t  z, Double_t t);
   inline void SetXYZM(Double_t  x, Double_t  y, Double_t  z, Double_t m);
   inline void SetPtEtaPhiM(Double_t pt, Double_t eta, Double_t phi, Double_t m);
   inline void SetPtEtaPhiE(Double_t pt, Double_t eta, Double_t phi, Double_t e);
   // Setters to provide the functionality (but a more meanigful name) of
   // the previous version eg SetV4... PsetV4...

   inline void GetXYZT(Double_t *carray) const;
   inline void GetXYZT(Float_t *carray) const;
   // Getters into an arry
   // no checking!

   Double_t operator () (int i) const;
   inline Double_t operator [] (int i) const;
   // Get components by index.

   Double_t & operator () (int i);
   inline Double_t & operator [] (int i);
   // Set components by index.

   inline TLorentzVector & operator = (const TLorentzVector &);
   // Assignment.

   inline TLorentzVector   operator +  (const TLorentzVector &) const;
   inline TLorentzVector & operator += (const TLorentzVector &);
   // Additions.

   inline TLorentzVector   operator -  (const TLorentzVector &) const;
   inline TLorentzVector & operator -= (const TLorentzVector &);
   // Subtractions.

   inline TLorentzVector operator - () const;
   // Unary minus.

   inline TLorentzVector operator * (Double_t a) const;
   inline TLorentzVector & operator *= (Double_t a);
   // Scaling with real numbers.

   inline Bool_t operator == (const TLorentzVector &) const;
   inline Bool_t operator != (const TLorentzVector &) const;
   // Comparisons.

   inline Double_t Perp2() const;
   // Transverse component of the spatial vector squared.

   inline Double_t Pt() const;
   inline Double_t Perp() const;
   // Transverse component of the spatial vector (R in cylindrical system).

   inline void SetPerp(Double_t);
   // Set the transverse component of the spatial vector.

   inline Double_t Perp2(const TVector3 & v) const;
   // Transverse component of the spatial vector w.r.t. given axis squared.

   inline Double_t Pt(const TVector3 & v) const;
   inline Double_t Perp(const TVector3 & v) const;
   // Transverse component of the spatial vector w.r.t. given axis.

   inline Double_t Et2() const;
   // Transverse energy squared.

   inline Double_t Et() const;
   // Transverse energy.

   inline Double_t Et2(const TVector3 &) const;
   // Transverse energy w.r.t. given axis squared.

   inline Double_t Et(const TVector3 &) const;
   // Transverse energy w.r.t. given axis.

   inline Double_t DeltaPhi(const TLorentzVector &) const;
   inline Double_t DeltaR(const TLorentzVector &) const;
   inline Double_t DrEtaPhi(const TLorentzVector &) const;
   inline TVector2 EtaPhiVector();

   inline Double_t Angle(const TVector3 & v) const;
   // Angle wrt. another vector.

   inline Double_t Mag2() const;
   inline Double_t M2() const;
   // Invariant mass squared.

   inline Double_t Mag() const;
   inline Double_t M() const;
   // Invariant mass. If mag2() is negative then -sqrt(-mag2()) is returned.

   inline Double_t Mt2() const;
   // Transverse mass squared.

   inline Double_t Mt() const;
   // Transverse mass.

   inline Double_t Beta() const;
   inline Double_t Gamma() const;

   inline Double_t Dot(const TLorentzVector &) const;
   inline Double_t operator * (const TLorentzVector &) const;
   // Scalar product.

   inline void SetVectMag(const TVector3 & spatial, Double_t magnitude);
   inline void SetVectM(const TVector3 & spatial, Double_t mass);
   // Copy spatial coordinates, and set energy = sqrt(mass^2 + spatial^2)

   inline Double_t Plus() const;
   inline Double_t Minus() const;
   // Returns t +/- z.
   // Related to the positive/negative light-cone component,
   // which some define this way and others define as (t +/- z)/sqrt(2)

   inline TVector3 BoostVector() const ;
   // Returns the spatial components divided by the time component.

   void Boost(Double_t, Double_t, Double_t);
   inline void Boost(const TVector3 &);
   // Lorentz boost.

   Double_t Rapidity() const;
   // Returns the rapidity, i.e. 0.5*ln((E+pz)/(E-pz))

   inline Double_t Eta() const;
   inline Double_t PseudoRapidity() const;
   // Returns the pseudo-rapidity, i.e. -ln(tan(theta/2))

   inline void RotateX(Double_t angle);
   // Rotate the spatial component around the x-axis.

   inline void RotateY(Double_t angle);
   // Rotate the spatial component around the y-axis.

   inline void RotateZ(Double_t angle);
   // Rotate the spatial component around the z-axis.

   inline void RotateUz(TVector3 & newUzVector);
   // Rotates the reference frame from Uz to newUz (unit vector).

   inline void Rotate(Double_t, const TVector3 &);
   // Rotate the spatial component around specified axis.

   inline TLorentzVector & operator *= (const TRotation &);
   inline TLorentzVector & Transform(const TRotation &);
   // Transformation with HepRotation.

   TLorentzVector & operator *= (const TLorentzRotation &);
   TLorentzVector & Transform(const TLorentzRotation &);
   // Transformation with HepLorenzRotation.

   virtual void        Print(Option_t *option="") const;

   ClassDef(TLorentzVector,4) // A four vector with (-,-,-,+) metric
};


//inline TLorentzVector operator * (const TLorentzVector &, Double_t a);
// moved to TLorentzVector::operator * (Double_t a)
inline TLorentzVector operator * (Double_t a, const TLorentzVector &);
// Scaling LorentzVector with a real number


inline Double_t TLorentzVector::X() const { return fP.X(); }
inline Double_t TLorentzVector::Y() const { return fP.Y(); }
inline Double_t TLorentzVector::Z() const { return fP.Z(); }
inline Double_t TLorentzVector::T() const { return fE; }

inline void TLorentzVector::SetX(Double_t a) { fP.SetX(a); }
inline void TLorentzVector::SetY(Double_t a) { fP.SetY(a); }
inline void TLorentzVector::SetZ(Double_t a) { fP.SetZ(a); }
inline void TLorentzVector::SetT(Double_t a) { fE = a; }

inline Double_t TLorentzVector::Px() const { return X(); }
inline Double_t TLorentzVector::Py() const { return Y(); }
inline Double_t TLorentzVector::Pz() const { return Z(); }
inline Double_t TLorentzVector::P()  const { return fP.Mag(); }
inline Double_t TLorentzVector::E()  const { return T(); }
inline Double_t TLorentzVector::Energy()  const { return T(); }

inline void TLorentzVector::SetPx(Double_t a) { SetX(a); }
inline void TLorentzVector::SetPy(Double_t a) { SetY(a); }
inline void TLorentzVector::SetPz(Double_t a) { SetZ(a); }
inline void TLorentzVector::SetE(Double_t a)  { SetT(a); }

inline TVector3 TLorentzVector::Vect() const { return fP; }

inline void TLorentzVector::SetVect(const TVector3 &p) { fP = p; }

inline Double_t TLorentzVector::Phi() const {
   return fP.Phi();
}

inline Double_t TLorentzVector::Theta() const {
   return fP.Theta();
}

inline Double_t TLorentzVector::CosTheta() const {
   return fP.CosTheta();
}


inline Double_t TLorentzVector::Rho() const {
   return fP.Mag();
}

inline void TLorentzVector::SetTheta(Double_t th) {
   fP.SetTheta(th);
}

inline void TLorentzVector::SetPhi(Double_t phi) {
   fP.SetPhi(phi);
}

inline void TLorentzVector::SetRho(Double_t rho) {
   fP.SetMag(rho);
}

inline void TLorentzVector::SetXYZT(Double_t  x, Double_t  y, Double_t  z, Double_t t) {
   fP.SetXYZ(x, y, z);
   SetT(t);
}

inline void TLorentzVector::SetPxPyPzE(Double_t px, Double_t py, Double_t pz, Double_t e) {
   SetXYZT(px, py, pz, e);
}

inline void TLorentzVector::SetXYZM(Double_t  x, Double_t  y, Double_t  z, Double_t m) {
   if ( m  >= 0 ) 
      SetXYZT( x, y, z, TMath::Sqrt(x*x+y*y+z*z+m*m) );
   else 
      SetXYZT( x, y, z, TMath::Sqrt( TMath::Max((x*x+y*y+z*z-m*m), 0. ) ) );
}

inline void TLorentzVector::SetPtEtaPhiM(Double_t pt, Double_t eta, Double_t phi, Double_t m) {
   pt = TMath::Abs(pt);
   SetXYZM(pt*TMath::Cos(phi), pt*TMath::Sin(phi), pt*sinh(eta) ,m);
}

inline void TLorentzVector::SetPtEtaPhiE(Double_t pt, Double_t eta, Double_t phi, Double_t e) {
   pt = TMath::Abs(pt);
   SetXYZT(pt*TMath::Cos(phi), pt*TMath::Sin(phi), pt*sinh(eta) ,e);
}

inline void TLorentzVector::GetXYZT(Double_t *carray) const {
   fP.GetXYZ(carray);
   carray[3] = fE;
}

inline void TLorentzVector::GetXYZT(Float_t *carray) const{
   fP.GetXYZ(carray);
   carray[3] = fE;
}

Double_t & TLorentzVector::operator [] (int i)       { return (*this)(i); }
Double_t   TLorentzVector::operator [] (int i) const { return (*this)(i); }

inline TLorentzVector &TLorentzVector::operator = (const TLorentzVector & q) {
   fP = q.Vect();
   fE = q.T();
   return *this;
}

inline TLorentzVector TLorentzVector::operator + (const TLorentzVector & q) const {
   return TLorentzVector(fP+q.Vect(), fE+q.T());
}

inline TLorentzVector &TLorentzVector::operator += (const TLorentzVector & q) {
   fP += q.Vect();
   fE += q.T();
   return *this;
}

inline TLorentzVector TLorentzVector::operator - (const TLorentzVector & q) const {
   return TLorentzVector(fP-q.Vect(), fE-q.T());
}

inline TLorentzVector &TLorentzVector::operator -= (const TLorentzVector & q) {
   fP -= q.Vect();
   fE -= q.T();
   return *this;
}

inline TLorentzVector TLorentzVector::operator - () const {
   return TLorentzVector(-X(), -Y(), -Z(), -T());
}

inline TLorentzVector& TLorentzVector::operator *= (Double_t a) {
   fP *= a;
   fE *= a;
   return *this;
}

inline TLorentzVector TLorentzVector::operator * (Double_t a) const {
   return TLorentzVector(a*X(), a*Y(), a*Z(), a*T());
}

inline Bool_t TLorentzVector::operator == (const TLorentzVector & q) const {
   return (Vect() == q.Vect() && T() == q.T());
}

inline Bool_t TLorentzVector::operator != (const TLorentzVector & q) const {
   return (Vect() != q.Vect() || T() != q.T());
}

inline Double_t TLorentzVector::Perp2() const  { return fP.Perp2(); }

inline Double_t TLorentzVector::Perp()  const  { return fP.Perp(); }

inline Double_t TLorentzVector::Pt() const { return Perp(); }

inline void TLorentzVector::SetPerp(Double_t r) {
   fP.SetPerp(r);
}

inline Double_t TLorentzVector::Perp2(const TVector3 &v) const {
   return fP.Perp2(v);
}

inline Double_t TLorentzVector::Perp(const TVector3 &v) const {
   return fP.Perp(v);
}

inline Double_t TLorentzVector::Pt(const TVector3 &v) const {
   return Perp(v);
}

inline Double_t TLorentzVector::Et2() const {
   Double_t pt2 = fP.Perp2();
   return pt2 == 0 ? 0 : E()*E() * pt2/(pt2+Z()*Z());
}

inline Double_t TLorentzVector::Et() const {
   Double_t etet = Et2();
   return E() < 0.0 ? -sqrt(etet) : sqrt(etet);
}

inline Double_t TLorentzVector::Et2(const TVector3 & v) const {
   Double_t pt2 = fP.Perp2(v);
   Double_t pv = fP.Dot(v.Unit());
   return pt2 == 0 ? 0 : E()*E() * pt2/(pt2+pv*pv);
}

inline Double_t TLorentzVector::Et(const TVector3 & v) const {
   Double_t etet = Et2(v);
   return E() < 0.0 ? -sqrt(etet) : sqrt(etet);
}

inline Double_t TLorentzVector::DeltaPhi(const TLorentzVector & v) const {
   return TVector2::Phi_mpi_pi(Phi()-v.Phi());
}

inline Double_t TLorentzVector::Eta() const {
   return PseudoRapidity();
}
inline Double_t TLorentzVector::DeltaR(const TLorentzVector & v) const {
   Double_t deta = Eta()-v.Eta();
   Double_t dphi = TVector2::Phi_mpi_pi(Phi()-v.Phi());
   return TMath::Sqrt( deta*deta+dphi*dphi );
}

inline Double_t TLorentzVector::DrEtaPhi(const TLorentzVector & v) const{
   return DeltaR(v);
}

inline TVector2 TLorentzVector::EtaPhiVector() {
   return TVector2 (Eta(),Phi());
}


inline Double_t TLorentzVector::Angle(const TVector3 &v) const {
   return fP.Angle(v);
}

inline Double_t TLorentzVector::Mag2() const {
   return T()*T() - fP.Mag2();
}

inline Double_t TLorentzVector::Mag() const {
   Double_t mm = Mag2();
   return mm < 0.0 ? -TMath::Sqrt(-mm) : TMath::Sqrt(mm);
}

inline Double_t TLorentzVector::M2() const { return Mag2(); }
inline Double_t TLorentzVector::M() const { return Mag(); }

inline Double_t TLorentzVector::Mt2() const {
   return E()*E() - Z()*Z();
}

inline Double_t TLorentzVector::Mt() const {
   Double_t mm = Mt2();
   return mm < 0.0 ? -TMath::Sqrt(-mm) : TMath::Sqrt(mm);
}

inline Double_t TLorentzVector::Beta() const {
   return fP.Mag() / fE;
}

inline Double_t TLorentzVector::Gamma() const {
   Double_t b = Beta();
   return 1.0/TMath::Sqrt(1- b*b);
}

inline void TLorentzVector::SetVectMag(const TVector3 & spatial, Double_t magnitude) {
   SetXYZM(spatial.X(), spatial.Y(), spatial.Z(), magnitude);
}

inline void TLorentzVector::SetVectM(const TVector3 & spatial, Double_t mass) {
   SetVectMag(spatial, mass);
}

inline Double_t TLorentzVector::Dot(const TLorentzVector & q) const {
   return T()*q.T() - Z()*q.Z() - Y()*q.Y() - X()*q.X();
}

inline Double_t TLorentzVector::operator * (const TLorentzVector & q) const {
   return Dot(q);
}

//Member functions Plus() and Minus() return the positive and negative
//light-cone components:
//
//  Double_t pcone = v.Plus();
//  Double_t mcone = v.Minus();
//
//CAVEAT: The values returned are T{+,-}Z. It is known that some authors
//find it easier to define these components as (T{+,-}Z)/sqrt(2). Thus
//check what definition is used in the physics you're working in and adapt
//your code accordingly.

inline Double_t TLorentzVector::Plus() const {
   return T() + Z();
}

inline Double_t TLorentzVector::Minus() const {
   return T() - Z();
}

inline TVector3 TLorentzVector::BoostVector() const {
   return TVector3(X()/T(), Y()/T(), Z()/T());
}

inline void TLorentzVector::Boost(const TVector3 & b) {
   Boost(b.X(), b.Y(), b.Z());
}

inline Double_t TLorentzVector::PseudoRapidity() const {
   return fP.PseudoRapidity();
}

inline void TLorentzVector::RotateX(Double_t angle) {
   fP.RotateX(angle);
}

inline void TLorentzVector::RotateY(Double_t angle) {
   fP.RotateY(angle);
}

inline void TLorentzVector::RotateZ(Double_t angle) {
   fP.RotateZ(angle);
}

inline void TLorentzVector::RotateUz(TVector3 &newUzVector) {
   fP.RotateUz(newUzVector);
}

inline void TLorentzVector::Rotate(Double_t a, const TVector3 &v) {
   fP.Rotate(a,v);
}

inline TLorentzVector &TLorentzVector::operator *= (const TRotation & m) {
   fP *= m;
   return *this;
}

inline TLorentzVector &TLorentzVector::Transform(const TRotation & m) {
   fP.Transform(m);
   return *this;
}

inline TLorentzVector operator * (Double_t a, const TLorentzVector & p) {
   return TLorentzVector(a*p.X(), a*p.Y(), a*p.Z(), a*p.T());
}


#endif
 TLorentzVector.h:1
 TLorentzVector.h:2
 TLorentzVector.h:3
 TLorentzVector.h:4
 TLorentzVector.h:5
 TLorentzVector.h:6
 TLorentzVector.h:7
 TLorentzVector.h:8
 TLorentzVector.h:9
 TLorentzVector.h:10
 TLorentzVector.h:11
 TLorentzVector.h:12
 TLorentzVector.h:13
 TLorentzVector.h:14
 TLorentzVector.h:15
 TLorentzVector.h:16
 TLorentzVector.h:17
 TLorentzVector.h:18
 TLorentzVector.h:19
 TLorentzVector.h:20
 TLorentzVector.h:21
 TLorentzVector.h:22
 TLorentzVector.h:23
 TLorentzVector.h:24
 TLorentzVector.h:25
 TLorentzVector.h:26
 TLorentzVector.h:27
 TLorentzVector.h:28
 TLorentzVector.h:29
 TLorentzVector.h:30
 TLorentzVector.h:31
 TLorentzVector.h:32
 TLorentzVector.h:33
 TLorentzVector.h:34
 TLorentzVector.h:35
 TLorentzVector.h:36
 TLorentzVector.h:37
 TLorentzVector.h:38
 TLorentzVector.h:39
 TLorentzVector.h:40
 TLorentzVector.h:41
 TLorentzVector.h:42
 TLorentzVector.h:43
 TLorentzVector.h:44
 TLorentzVector.h:45
 TLorentzVector.h:46
 TLorentzVector.h:47
 TLorentzVector.h:48
 TLorentzVector.h:49
 TLorentzVector.h:50
 TLorentzVector.h:51
 TLorentzVector.h:52
 TLorentzVector.h:53
 TLorentzVector.h:54
 TLorentzVector.h:55
 TLorentzVector.h:56
 TLorentzVector.h:57
 TLorentzVector.h:58
 TLorentzVector.h:59
 TLorentzVector.h:60
 TLorentzVector.h:61
 TLorentzVector.h:62
 TLorentzVector.h:63
 TLorentzVector.h:64
 TLorentzVector.h:65
 TLorentzVector.h:66
 TLorentzVector.h:67
 TLorentzVector.h:68
 TLorentzVector.h:69
 TLorentzVector.h:70
 TLorentzVector.h:71
 TLorentzVector.h:72
 TLorentzVector.h:73
 TLorentzVector.h:74
 TLorentzVector.h:75
 TLorentzVector.h:76
 TLorentzVector.h:77
 TLorentzVector.h:78
 TLorentzVector.h:79
 TLorentzVector.h:80
 TLorentzVector.h:81
 TLorentzVector.h:82
 TLorentzVector.h:83
 TLorentzVector.h:84
 TLorentzVector.h:85
 TLorentzVector.h:86
 TLorentzVector.h:87
 TLorentzVector.h:88
 TLorentzVector.h:89
 TLorentzVector.h:90
 TLorentzVector.h:91
 TLorentzVector.h:92
 TLorentzVector.h:93
 TLorentzVector.h:94
 TLorentzVector.h:95
 TLorentzVector.h:96
 TLorentzVector.h:97
 TLorentzVector.h:98
 TLorentzVector.h:99
 TLorentzVector.h:100
 TLorentzVector.h:101
 TLorentzVector.h:102
 TLorentzVector.h:103
 TLorentzVector.h:104
 TLorentzVector.h:105
 TLorentzVector.h:106
 TLorentzVector.h:107
 TLorentzVector.h:108
 TLorentzVector.h:109
 TLorentzVector.h:110
 TLorentzVector.h:111
 TLorentzVector.h:112
 TLorentzVector.h:113
 TLorentzVector.h:114
 TLorentzVector.h:115
 TLorentzVector.h:116
 TLorentzVector.h:117
 TLorentzVector.h:118
 TLorentzVector.h:119
 TLorentzVector.h:120
 TLorentzVector.h:121
 TLorentzVector.h:122
 TLorentzVector.h:123
 TLorentzVector.h:124
 TLorentzVector.h:125
 TLorentzVector.h:126
 TLorentzVector.h:127
 TLorentzVector.h:128
 TLorentzVector.h:129
 TLorentzVector.h:130
 TLorentzVector.h:131
 TLorentzVector.h:132
 TLorentzVector.h:133
 TLorentzVector.h:134
 TLorentzVector.h:135
 TLorentzVector.h:136
 TLorentzVector.h:137
 TLorentzVector.h:138
 TLorentzVector.h:139
 TLorentzVector.h:140
 TLorentzVector.h:141
 TLorentzVector.h:142
 TLorentzVector.h:143
 TLorentzVector.h:144
 TLorentzVector.h:145
 TLorentzVector.h:146
 TLorentzVector.h:147
 TLorentzVector.h:148
 TLorentzVector.h:149
 TLorentzVector.h:150
 TLorentzVector.h:151
 TLorentzVector.h:152
 TLorentzVector.h:153
 TLorentzVector.h:154
 TLorentzVector.h:155
 TLorentzVector.h:156
 TLorentzVector.h:157
 TLorentzVector.h:158
 TLorentzVector.h:159
 TLorentzVector.h:160
 TLorentzVector.h:161
 TLorentzVector.h:162
 TLorentzVector.h:163
 TLorentzVector.h:164
 TLorentzVector.h:165
 TLorentzVector.h:166
 TLorentzVector.h:167
 TLorentzVector.h:168
 TLorentzVector.h:169
 TLorentzVector.h:170
 TLorentzVector.h:171
 TLorentzVector.h:172
 TLorentzVector.h:173
 TLorentzVector.h:174
 TLorentzVector.h:175
 TLorentzVector.h:176
 TLorentzVector.h:177
 TLorentzVector.h:178
 TLorentzVector.h:179
 TLorentzVector.h:180
 TLorentzVector.h:181
 TLorentzVector.h:182
 TLorentzVector.h:183
 TLorentzVector.h:184
 TLorentzVector.h:185
 TLorentzVector.h:186
 TLorentzVector.h:187
 TLorentzVector.h:188
 TLorentzVector.h:189
 TLorentzVector.h:190
 TLorentzVector.h:191
 TLorentzVector.h:192
 TLorentzVector.h:193
 TLorentzVector.h:194
 TLorentzVector.h:195
 TLorentzVector.h:196
 TLorentzVector.h:197
 TLorentzVector.h:198
 TLorentzVector.h:199
 TLorentzVector.h:200
 TLorentzVector.h:201
 TLorentzVector.h:202
 TLorentzVector.h:203
 TLorentzVector.h:204
 TLorentzVector.h:205
 TLorentzVector.h:206
 TLorentzVector.h:207
 TLorentzVector.h:208
 TLorentzVector.h:209
 TLorentzVector.h:210
 TLorentzVector.h:211
 TLorentzVector.h:212
 TLorentzVector.h:213
 TLorentzVector.h:214
 TLorentzVector.h:215
 TLorentzVector.h:216
 TLorentzVector.h:217
 TLorentzVector.h:218
 TLorentzVector.h:219
 TLorentzVector.h:220
 TLorentzVector.h:221
 TLorentzVector.h:222
 TLorentzVector.h:223
 TLorentzVector.h:224
 TLorentzVector.h:225
 TLorentzVector.h:226
 TLorentzVector.h:227
 TLorentzVector.h:228
 TLorentzVector.h:229
 TLorentzVector.h:230
 TLorentzVector.h:231
 TLorentzVector.h:232
 TLorentzVector.h:233
 TLorentzVector.h:234
 TLorentzVector.h:235
 TLorentzVector.h:236
 TLorentzVector.h:237
 TLorentzVector.h:238
 TLorentzVector.h:239
 TLorentzVector.h:240
 TLorentzVector.h:241
 TLorentzVector.h:242
 TLorentzVector.h:243
 TLorentzVector.h:244
 TLorentzVector.h:245
 TLorentzVector.h:246
 TLorentzVector.h:247
 TLorentzVector.h:248
 TLorentzVector.h:249
 TLorentzVector.h:250
 TLorentzVector.h:251
 TLorentzVector.h:252
 TLorentzVector.h:253
 TLorentzVector.h:254
 TLorentzVector.h:255
 TLorentzVector.h:256
 TLorentzVector.h:257
 TLorentzVector.h:258
 TLorentzVector.h:259
 TLorentzVector.h:260
 TLorentzVector.h:261
 TLorentzVector.h:262
 TLorentzVector.h:263
 TLorentzVector.h:264
 TLorentzVector.h:265
 TLorentzVector.h:266
 TLorentzVector.h:267
 TLorentzVector.h:268
 TLorentzVector.h:269
 TLorentzVector.h:270
 TLorentzVector.h:271
 TLorentzVector.h:272
 TLorentzVector.h:273
 TLorentzVector.h:274
 TLorentzVector.h:275
 TLorentzVector.h:276
 TLorentzVector.h:277
 TLorentzVector.h:278
 TLorentzVector.h:279
 TLorentzVector.h:280
 TLorentzVector.h:281
 TLorentzVector.h:282
 TLorentzVector.h:283
 TLorentzVector.h:284
 TLorentzVector.h:285
 TLorentzVector.h:286
 TLorentzVector.h:287
 TLorentzVector.h:288
 TLorentzVector.h:289
 TLorentzVector.h:290
 TLorentzVector.h:291
 TLorentzVector.h:292
 TLorentzVector.h:293
 TLorentzVector.h:294
 TLorentzVector.h:295
 TLorentzVector.h:296
 TLorentzVector.h:297
 TLorentzVector.h:298
 TLorentzVector.h:299
 TLorentzVector.h:300
 TLorentzVector.h:301
 TLorentzVector.h:302
 TLorentzVector.h:303
 TLorentzVector.h:304
 TLorentzVector.h:305
 TLorentzVector.h:306
 TLorentzVector.h:307
 TLorentzVector.h:308
 TLorentzVector.h:309
 TLorentzVector.h:310
 TLorentzVector.h:311
 TLorentzVector.h:312
 TLorentzVector.h:313
 TLorentzVector.h:314
 TLorentzVector.h:315
 TLorentzVector.h:316
 TLorentzVector.h:317
 TLorentzVector.h:318
 TLorentzVector.h:319
 TLorentzVector.h:320
 TLorentzVector.h:321
 TLorentzVector.h:322
 TLorentzVector.h:323
 TLorentzVector.h:324
 TLorentzVector.h:325
 TLorentzVector.h:326
 TLorentzVector.h:327
 TLorentzVector.h:328
 TLorentzVector.h:329
 TLorentzVector.h:330
 TLorentzVector.h:331
 TLorentzVector.h:332
 TLorentzVector.h:333
 TLorentzVector.h:334
 TLorentzVector.h:335
 TLorentzVector.h:336
 TLorentzVector.h:337
 TLorentzVector.h:338
 TLorentzVector.h:339
 TLorentzVector.h:340
 TLorentzVector.h:341
 TLorentzVector.h:342
 TLorentzVector.h:343
 TLorentzVector.h:344
 TLorentzVector.h:345
 TLorentzVector.h:346
 TLorentzVector.h:347
 TLorentzVector.h:348
 TLorentzVector.h:349
 TLorentzVector.h:350
 TLorentzVector.h:351
 TLorentzVector.h:352
 TLorentzVector.h:353
 TLorentzVector.h:354
 TLorentzVector.h:355
 TLorentzVector.h:356
 TLorentzVector.h:357
 TLorentzVector.h:358
 TLorentzVector.h:359
 TLorentzVector.h:360
 TLorentzVector.h:361
 TLorentzVector.h:362
 TLorentzVector.h:363
 TLorentzVector.h:364
 TLorentzVector.h:365
 TLorentzVector.h:366
 TLorentzVector.h:367
 TLorentzVector.h:368
 TLorentzVector.h:369
 TLorentzVector.h:370
 TLorentzVector.h:371
 TLorentzVector.h:372
 TLorentzVector.h:373
 TLorentzVector.h:374
 TLorentzVector.h:375
 TLorentzVector.h:376
 TLorentzVector.h:377
 TLorentzVector.h:378
 TLorentzVector.h:379
 TLorentzVector.h:380
 TLorentzVector.h:381
 TLorentzVector.h:382
 TLorentzVector.h:383
 TLorentzVector.h:384
 TLorentzVector.h:385
 TLorentzVector.h:386
 TLorentzVector.h:387
 TLorentzVector.h:388
 TLorentzVector.h:389
 TLorentzVector.h:390
 TLorentzVector.h:391
 TLorentzVector.h:392
 TLorentzVector.h:393
 TLorentzVector.h:394
 TLorentzVector.h:395
 TLorentzVector.h:396
 TLorentzVector.h:397
 TLorentzVector.h:398
 TLorentzVector.h:399
 TLorentzVector.h:400
 TLorentzVector.h:401
 TLorentzVector.h:402
 TLorentzVector.h:403
 TLorentzVector.h:404
 TLorentzVector.h:405
 TLorentzVector.h:406
 TLorentzVector.h:407
 TLorentzVector.h:408
 TLorentzVector.h:409
 TLorentzVector.h:410
 TLorentzVector.h:411
 TLorentzVector.h:412
 TLorentzVector.h:413
 TLorentzVector.h:414
 TLorentzVector.h:415
 TLorentzVector.h:416
 TLorentzVector.h:417
 TLorentzVector.h:418
 TLorentzVector.h:419
 TLorentzVector.h:420
 TLorentzVector.h:421
 TLorentzVector.h:422
 TLorentzVector.h:423
 TLorentzVector.h:424
 TLorentzVector.h:425
 TLorentzVector.h:426
 TLorentzVector.h:427
 TLorentzVector.h:428
 TLorentzVector.h:429
 TLorentzVector.h:430
 TLorentzVector.h:431
 TLorentzVector.h:432
 TLorentzVector.h:433
 TLorentzVector.h:434
 TLorentzVector.h:435
 TLorentzVector.h:436
 TLorentzVector.h:437
 TLorentzVector.h:438
 TLorentzVector.h:439
 TLorentzVector.h:440
 TLorentzVector.h:441
 TLorentzVector.h:442
 TLorentzVector.h:443
 TLorentzVector.h:444
 TLorentzVector.h:445
 TLorentzVector.h:446
 TLorentzVector.h:447
 TLorentzVector.h:448
 TLorentzVector.h:449
 TLorentzVector.h:450
 TLorentzVector.h:451
 TLorentzVector.h:452
 TLorentzVector.h:453
 TLorentzVector.h:454
 TLorentzVector.h:455
 TLorentzVector.h:456
 TLorentzVector.h:457
 TLorentzVector.h:458
 TLorentzVector.h:459
 TLorentzVector.h:460
 TLorentzVector.h:461
 TLorentzVector.h:462
 TLorentzVector.h:463
 TLorentzVector.h:464
 TLorentzVector.h:465
 TLorentzVector.h:466
 TLorentzVector.h:467
 TLorentzVector.h:468
 TLorentzVector.h:469
 TLorentzVector.h:470
 TLorentzVector.h:471
 TLorentzVector.h:472
 TLorentzVector.h:473
 TLorentzVector.h:474
 TLorentzVector.h:475
 TLorentzVector.h:476
 TLorentzVector.h:477
 TLorentzVector.h:478
 TLorentzVector.h:479
 TLorentzVector.h:480
 TLorentzVector.h:481
 TLorentzVector.h:482
 TLorentzVector.h:483
 TLorentzVector.h:484
 TLorentzVector.h:485
 TLorentzVector.h:486
 TLorentzVector.h:487
 TLorentzVector.h:488
 TLorentzVector.h:489
 TLorentzVector.h:490
 TLorentzVector.h:491
 TLorentzVector.h:492
 TLorentzVector.h:493
 TLorentzVector.h:494
 TLorentzVector.h:495
 TLorentzVector.h:496
 TLorentzVector.h:497
 TLorentzVector.h:498
 TLorentzVector.h:499
 TLorentzVector.h:500
 TLorentzVector.h:501
 TLorentzVector.h:502
 TLorentzVector.h:503
 TLorentzVector.h:504
 TLorentzVector.h:505
 TLorentzVector.h:506
 TLorentzVector.h:507
 TLorentzVector.h:508
 TLorentzVector.h:509
 TLorentzVector.h:510
 TLorentzVector.h:511
 TLorentzVector.h:512
 TLorentzVector.h:513
 TLorentzVector.h:514
 TLorentzVector.h:515
 TLorentzVector.h:516
 TLorentzVector.h:517
 TLorentzVector.h:518
 TLorentzVector.h:519
 TLorentzVector.h:520
 TLorentzVector.h:521
 TLorentzVector.h:522
 TLorentzVector.h:523
 TLorentzVector.h:524
 TLorentzVector.h:525
 TLorentzVector.h:526
 TLorentzVector.h:527
 TLorentzVector.h:528
 TLorentzVector.h:529
 TLorentzVector.h:530
 TLorentzVector.h:531
 TLorentzVector.h:532
 TLorentzVector.h:533
 TLorentzVector.h:534
 TLorentzVector.h:535
 TLorentzVector.h:536
 TLorentzVector.h:537
 TLorentzVector.h:538
 TLorentzVector.h:539
 TLorentzVector.h:540
 TLorentzVector.h:541
 TLorentzVector.h:542
 TLorentzVector.h:543
 TLorentzVector.h:544
 TLorentzVector.h:545
 TLorentzVector.h:546
 TLorentzVector.h:547
 TLorentzVector.h:548
 TLorentzVector.h:549
 TLorentzVector.h:550
 TLorentzVector.h:551
 TLorentzVector.h:552
 TLorentzVector.h:553
 TLorentzVector.h:554
 TLorentzVector.h:555
 TLorentzVector.h:556
 TLorentzVector.h:557
 TLorentzVector.h:558
 TLorentzVector.h:559
 TLorentzVector.h:560
 TLorentzVector.h:561
 TLorentzVector.h:562
 TLorentzVector.h:563
 TLorentzVector.h:564
 TLorentzVector.h:565
 TLorentzVector.h:566
 TLorentzVector.h:567
 TLorentzVector.h:568
 TLorentzVector.h:569
 TLorentzVector.h:570
 TLorentzVector.h:571
 TLorentzVector.h:572
 TLorentzVector.h:573
 TLorentzVector.h:574
 TLorentzVector.h:575
 TLorentzVector.h:576
 TLorentzVector.h:577
 TLorentzVector.h:578
 TLorentzVector.h:579
 TLorentzVector.h:580
 TLorentzVector.h:581
 TLorentzVector.h:582
 TLorentzVector.h:583
 TLorentzVector.h:584
 TLorentzVector.h:585
 TLorentzVector.h:586
 TLorentzVector.h:587
 TLorentzVector.h:588
 TLorentzVector.h:589
 TLorentzVector.h:590
 TLorentzVector.h:591
 TLorentzVector.h:592
 TLorentzVector.h:593
 TLorentzVector.h:594
 TLorentzVector.h:595
 TLorentzVector.h:596
 TLorentzVector.h:597
 TLorentzVector.h:598
 TLorentzVector.h:599
 TLorentzVector.h:600