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

/*************************************************************************
*                                                                       *
* 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 &);

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

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