Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
TLorentzVector.h
Go to the documentation of this file.
1 // @(#)root/physics:$Id$
2 // Author: Pasha Murat , Peter Malzacher 12/02/99
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TLorentzVector
13 #define ROOT_TLorentzVector
14 
15 
16 //////////////////////////////////////////////////////////////////////////
17 // //
18 // TLorentzVector //
19 // //
20 // Place holder for real lorentz vector class. //
21 // //
22 //////////////////////////////////////////////////////////////////////////
23 
24 #include "TMath.h"
25 #include "TVector3.h"
26 #include "TRotation.h"
27 
28 
29 class TLorentzRotation;
30 
31 
32 class TLorentzVector : public TObject {
33 
34 private:
35 
36  TVector3 fP; // 3 vector component
37  Double_t fE; // time or energy of (x,y,z,t) or (px,py,pz,e)
38 
39 public:
40 
41  typedef Double_t Scalar; // to be able to use it with the ROOT::Math::VectorUtil functions
42 
43  enum { kX=0, kY=1, kZ=2, kT=3, kNUM_COORDINATES=4, kSIZE=kNUM_COORDINATES };
44  // Safe indexing of the coordinates when using with matrices, arrays, etc.
45 
46  TLorentzVector();
47 
48  TLorentzVector(Double_t x, Double_t y, Double_t z, Double_t t);
49  // Constructor giving the components x, y, z, t.
50 
51  TLorentzVector(const Double_t * carray);
52  TLorentzVector(const Float_t * carray);
53  // Constructor from an array, not checked!
54 
55  TLorentzVector(const TVector3 & vector3, Double_t t);
56  // Constructor giving a 3-Vector and a time component.
57 
58  TLorentzVector(const TLorentzVector & lorentzvector);
59  // Copy constructor.
60 
61  virtual ~TLorentzVector(){};
62  // Destructor
63 
64  // inline operator TVector3 () const;
65  // inline operator TVector3 & ();
66  // Conversion (cast) to TVector3.
67 
68  inline Double_t X() const;
69  inline Double_t Y() const;
70  inline Double_t Z() const;
71  inline Double_t T() const;
72  // Get position and time.
73 
74  inline void SetX(Double_t a);
75  inline void SetY(Double_t a);
76  inline void SetZ(Double_t a);
77  inline void SetT(Double_t a);
78  // Set position and time.
79 
80  inline Double_t Px() const;
81  inline Double_t Py() const;
82  inline Double_t Pz() const;
83  inline Double_t P() const;
84  inline Double_t E() const;
85  inline Double_t Energy() const;
86  // Get momentum and energy.
87 
88  inline void SetPx(Double_t a);
89  inline void SetPy(Double_t a);
90  inline void SetPz(Double_t a);
91  inline void SetE(Double_t a);
92  // Set momentum and energy.
93 
94  inline TVector3 Vect() const ;
95  // Get spatial component.
96 
97  inline void SetVect(const TVector3 & vect3);
98  // Set spatial component.
99 
100  inline Double_t Theta() const;
101  inline Double_t CosTheta() const;
102  inline Double_t Phi() const; //returns phi from -pi to pi
103  inline Double_t Rho() const;
104  // Get spatial vector components in spherical coordinate system.
105 
106  inline void SetTheta(Double_t theta);
107  inline void SetPhi(Double_t phi);
108  inline void SetRho(Double_t rho);
109  // Set spatial vector components in spherical coordinate system.
110 
111  inline void SetPxPyPzE(Double_t px, Double_t py, Double_t pz, Double_t e);
112  inline void SetXYZT(Double_t x, Double_t y, Double_t z, Double_t t);
113  inline void SetXYZM(Double_t x, Double_t y, Double_t z, Double_t m);
114  inline void SetPtEtaPhiM(Double_t pt, Double_t eta, Double_t phi, Double_t m);
115  inline void SetPtEtaPhiE(Double_t pt, Double_t eta, Double_t phi, Double_t e);
116  // Setters to provide the functionality (but a more meanigful name) of
117  // the previous version eg SetV4... PsetV4...
118 
119  inline void GetXYZT(Double_t *carray) const;
120  inline void GetXYZT(Float_t *carray) const;
121  // Getters into an arry
122  // no checking!
123 
124  Double_t operator () (int i) const;
125  inline Double_t operator [] (int i) const;
126  // Get components by index.
127 
128  Double_t & operator () (int i);
129  inline Double_t & operator [] (int i);
130  // Set components by index.
131 
132  inline TLorentzVector & operator = (const TLorentzVector &);
133  // Assignment.
134 
135  inline TLorentzVector operator + (const TLorentzVector &) const;
136  inline TLorentzVector & operator += (const TLorentzVector &);
137  // Additions.
138 
139  inline TLorentzVector operator - (const TLorentzVector &) const;
140  inline TLorentzVector & operator -= (const TLorentzVector &);
141  // Subtractions.
142 
143  inline TLorentzVector operator - () const;
144  // Unary minus.
145 
146  inline TLorentzVector operator * (Double_t a) const;
147  inline TLorentzVector & operator *= (Double_t a);
148  // Scaling with real numbers.
149 
150  inline Bool_t operator == (const TLorentzVector &) const;
151  inline Bool_t operator != (const TLorentzVector &) const;
152  // Comparisons.
153 
154  inline Double_t Perp2() const;
155  // Transverse component of the spatial vector squared.
156 
157  inline Double_t Pt() const;
158  inline Double_t Perp() const;
159  // Transverse component of the spatial vector (R in cylindrical system).
160 
161  inline void SetPerp(Double_t);
162  // Set the transverse component of the spatial vector.
163 
164  inline Double_t Perp2(const TVector3 & v) const;
165  // Transverse component of the spatial vector w.r.t. given axis squared.
166 
167  inline Double_t Pt(const TVector3 & v) const;
168  inline Double_t Perp(const TVector3 & v) const;
169  // Transverse component of the spatial vector w.r.t. given axis.
170 
171  inline Double_t Et2() const;
172  // Transverse energy squared.
173 
174  inline Double_t Et() const;
175  // Transverse energy.
176 
177  inline Double_t Et2(const TVector3 &) const;
178  // Transverse energy w.r.t. given axis squared.
179 
180  inline Double_t Et(const TVector3 &) const;
181  // Transverse energy w.r.t. given axis.
182 
183  inline Double_t DeltaPhi(const TLorentzVector &) const;
184  inline Double_t DeltaR(const TLorentzVector &) const;
185  inline Double_t DrEtaPhi(const TLorentzVector &) const;
186  inline TVector2 EtaPhiVector();
187 
188  inline Double_t Angle(const TVector3 & v) const;
189  // Angle wrt. another vector.
190 
191  inline Double_t Mag2() const;
192  inline Double_t M2() const;
193  // Invariant mass squared.
194 
195  inline Double_t Mag() const;
196  inline Double_t M() const;
197  // Invariant mass. If mag2() is negative then -sqrt(-mag2()) is returned.
198 
199  inline Double_t Mt2() const;
200  // Transverse mass squared.
201 
202  inline Double_t Mt() const;
203  // Transverse mass.
204 
205  inline Double_t Beta() const;
206  inline Double_t Gamma() const;
207 
208  inline Double_t Dot(const TLorentzVector &) const;
209  inline Double_t operator * (const TLorentzVector &) const;
210  // Scalar product.
211 
212  inline void SetVectMag(const TVector3 & spatial, Double_t magnitude);
213  inline void SetVectM(const TVector3 & spatial, Double_t mass);
214  // Copy spatial coordinates, and set energy = sqrt(mass^2 + spatial^2)
215 
216  inline Double_t Plus() const;
217  inline Double_t Minus() const;
218  // Returns t +/- z.
219  // Related to the positive/negative light-cone component,
220  // which some define this way and others define as (t +/- z)/sqrt(2)
221 
222  inline TVector3 BoostVector() const ;
223  // Returns the spatial components divided by the time component.
224 
225  void Boost(Double_t, Double_t, Double_t);
226  inline void Boost(const TVector3 &);
227  // Lorentz boost.
228 
229  Double_t Rapidity() const;
230  // Returns the rapidity, i.e. 0.5*ln((E+pz)/(E-pz))
231 
232  inline Double_t Eta() const;
233  inline Double_t PseudoRapidity() const;
234  // Returns the pseudo-rapidity, i.e. -ln(tan(theta/2))
235 
236  inline void RotateX(Double_t angle);
237  // Rotate the spatial component around the x-axis.
238 
239  inline void RotateY(Double_t angle);
240  // Rotate the spatial component around the y-axis.
241 
242  inline void RotateZ(Double_t angle);
243  // Rotate the spatial component around the z-axis.
244 
245  inline void RotateUz(const TVector3 & newUzVector);
246  // Rotates the reference frame from Uz to newUz (unit vector).
247 
248  inline void Rotate(Double_t, const TVector3 &);
249  // Rotate the spatial component around specified axis.
250 
251  inline TLorentzVector & operator *= (const TRotation &);
252  inline TLorentzVector & Transform(const TRotation &);
253  // Transformation with HepRotation.
254 
255  TLorentzVector & operator *= (const TLorentzRotation &);
256  TLorentzVector & Transform(const TLorentzRotation &);
257  // Transformation with HepLorenzRotation.
258 
259  virtual void Print(Option_t *option="") const;
260 
261  ClassDef(TLorentzVector,4) // A four vector with (-,-,-,+) metric
262 };
263 
264 
265 //inline TLorentzVector operator * (const TLorentzVector &, Double_t a);
266 // moved to TLorentzVector::operator * (Double_t a)
267 inline TLorentzVector operator * (Double_t a, const TLorentzVector &);
268 // Scaling LorentzVector with a real number
269 
270 
271 inline Double_t TLorentzVector::X() const { return fP.X(); }
272 inline Double_t TLorentzVector::Y() const { return fP.Y(); }
273 inline Double_t TLorentzVector::Z() const { return fP.Z(); }
274 inline Double_t TLorentzVector::T() const { return fE; }
275 
276 inline void TLorentzVector::SetX(Double_t a) { fP.SetX(a); }
277 inline void TLorentzVector::SetY(Double_t a) { fP.SetY(a); }
278 inline void TLorentzVector::SetZ(Double_t a) { fP.SetZ(a); }
279 inline void TLorentzVector::SetT(Double_t a) { fE = a; }
280 
281 inline Double_t TLorentzVector::Px() const { return X(); }
282 inline Double_t TLorentzVector::Py() const { return Y(); }
283 inline Double_t TLorentzVector::Pz() const { return Z(); }
284 inline Double_t TLorentzVector::P() const { return fP.Mag(); }
285 inline Double_t TLorentzVector::E() const { return T(); }
286 inline Double_t TLorentzVector::Energy() const { return T(); }
287 
288 inline void TLorentzVector::SetPx(Double_t a) { SetX(a); }
289 inline void TLorentzVector::SetPy(Double_t a) { SetY(a); }
290 inline void TLorentzVector::SetPz(Double_t a) { SetZ(a); }
291 inline void TLorentzVector::SetE(Double_t a) { SetT(a); }
292 
293 inline TVector3 TLorentzVector::Vect() const { return fP; }
294 
295 inline void TLorentzVector::SetVect(const TVector3 &p) { fP = p; }
296 
297 inline Double_t TLorentzVector::Phi() const {
298  return fP.Phi();
299 }
300 
301 inline Double_t TLorentzVector::Theta() const {
302  return fP.Theta();
303 }
304 
305 inline Double_t TLorentzVector::CosTheta() const {
306  return fP.CosTheta();
307 }
308 
309 
310 inline Double_t TLorentzVector::Rho() const {
311  return fP.Mag();
312 }
313 
314 inline void TLorentzVector::SetTheta(Double_t th) {
315  fP.SetTheta(th);
316 }
317 
318 inline void TLorentzVector::SetPhi(Double_t phi) {
319  fP.SetPhi(phi);
320 }
321 
322 inline void TLorentzVector::SetRho(Double_t rho) {
323  fP.SetMag(rho);
324 }
325 
326 inline void TLorentzVector::SetXYZT(Double_t x, Double_t y, Double_t z, Double_t t) {
327  fP.SetXYZ(x, y, z);
328  SetT(t);
329 }
330 
331 inline void TLorentzVector::SetPxPyPzE(Double_t px, Double_t py, Double_t pz, Double_t e) {
332  SetXYZT(px, py, pz, e);
333 }
334 
335 inline void TLorentzVector::SetXYZM(Double_t x, Double_t y, Double_t z, Double_t m) {
336  if ( m >= 0 )
337  SetXYZT( x, y, z, TMath::Sqrt(x*x+y*y+z*z+m*m) );
338  else
339  SetXYZT( x, y, z, TMath::Sqrt( TMath::Max((x*x+y*y+z*z-m*m), 0. ) ) );
340 }
341 
342 inline void TLorentzVector::SetPtEtaPhiM(Double_t pt, Double_t eta, Double_t phi, Double_t m) {
343  pt = TMath::Abs(pt);
344  SetXYZM(pt*TMath::Cos(phi), pt*TMath::Sin(phi), pt*sinh(eta) ,m);
345 }
346 
347 inline void TLorentzVector::SetPtEtaPhiE(Double_t pt, Double_t eta, Double_t phi, Double_t e) {
348  pt = TMath::Abs(pt);
349  SetXYZT(pt*TMath::Cos(phi), pt*TMath::Sin(phi), pt*sinh(eta) ,e);
350 }
351 
352 inline void TLorentzVector::GetXYZT(Double_t *carray) const {
353  fP.GetXYZ(carray);
354  carray[3] = fE;
355 }
356 
357 inline void TLorentzVector::GetXYZT(Float_t *carray) const{
358  fP.GetXYZ(carray);
359  carray[3] = fE;
360 }
361 
362 inline Double_t & TLorentzVector::operator [] (int i) { return (*this)(i); }
363 inline Double_t TLorentzVector::operator [] (int i) const { return (*this)(i); }
364 
365 inline TLorentzVector &TLorentzVector::operator = (const TLorentzVector & q) {
366  fP = q.Vect();
367  fE = q.T();
368  return *this;
369 }
370 
371 inline TLorentzVector TLorentzVector::operator + (const TLorentzVector & q) const {
372  return TLorentzVector(fP+q.Vect(), fE+q.T());
373 }
374 
375 inline TLorentzVector &TLorentzVector::operator += (const TLorentzVector & q) {
376  fP += q.Vect();
377  fE += q.T();
378  return *this;
379 }
380 
381 inline TLorentzVector TLorentzVector::operator - (const TLorentzVector & q) const {
382  return TLorentzVector(fP-q.Vect(), fE-q.T());
383 }
384 
385 inline TLorentzVector &TLorentzVector::operator -= (const TLorentzVector & q) {
386  fP -= q.Vect();
387  fE -= q.T();
388  return *this;
389 }
390 
391 inline TLorentzVector TLorentzVector::operator - () const {
392  return TLorentzVector(-X(), -Y(), -Z(), -T());
393 }
394 
395 inline TLorentzVector& TLorentzVector::operator *= (Double_t a) {
396  fP *= a;
397  fE *= a;
398  return *this;
399 }
400 
401 inline TLorentzVector TLorentzVector::operator * (Double_t a) const {
402  return TLorentzVector(a*X(), a*Y(), a*Z(), a*T());
403 }
404 
405 inline Bool_t TLorentzVector::operator == (const TLorentzVector & q) const {
406  return (Vect() == q.Vect() && T() == q.T());
407 }
408 
409 inline Bool_t TLorentzVector::operator != (const TLorentzVector & q) const {
410  return (Vect() != q.Vect() || T() != q.T());
411 }
412 
413 inline Double_t TLorentzVector::Perp2() const { return fP.Perp2(); }
414 
415 inline Double_t TLorentzVector::Perp() const { return fP.Perp(); }
416 
417 inline Double_t TLorentzVector::Pt() const { return Perp(); }
418 
419 inline void TLorentzVector::SetPerp(Double_t r) {
420  fP.SetPerp(r);
421 }
422 
423 inline Double_t TLorentzVector::Perp2(const TVector3 &v) const {
424  return fP.Perp2(v);
425 }
426 
427 inline Double_t TLorentzVector::Perp(const TVector3 &v) const {
428  return fP.Perp(v);
429 }
430 
431 inline Double_t TLorentzVector::Pt(const TVector3 &v) const {
432  return Perp(v);
433 }
434 
435 inline Double_t TLorentzVector::Et2() const {
436  Double_t pt2 = fP.Perp2();
437  return pt2 == 0 ? 0 : E()*E() * pt2/(pt2+Z()*Z());
438 }
439 
440 inline Double_t TLorentzVector::Et() const {
441  Double_t etet = Et2();
442  return E() < 0.0 ? -sqrt(etet) : sqrt(etet);
443 }
444 
445 inline Double_t TLorentzVector::Et2(const TVector3 & v) const {
446  Double_t pt2 = fP.Perp2(v);
447  Double_t pv = fP.Dot(v.Unit());
448  return pt2 == 0 ? 0 : E()*E() * pt2/(pt2+pv*pv);
449 }
450 
451 inline Double_t TLorentzVector::Et(const TVector3 & v) const {
452  Double_t etet = Et2(v);
453  return E() < 0.0 ? -sqrt(etet) : sqrt(etet);
454 }
455 
456 inline Double_t TLorentzVector::DeltaPhi(const TLorentzVector & v) const {
457  return TVector2::Phi_mpi_pi(Phi()-v.Phi());
458 }
459 
460 inline Double_t TLorentzVector::Eta() const {
461  return PseudoRapidity();
462 }
463 inline Double_t TLorentzVector::DeltaR(const TLorentzVector & v) const {
464  Double_t deta = Eta()-v.Eta();
465  Double_t dphi = TVector2::Phi_mpi_pi(Phi()-v.Phi());
466  return TMath::Sqrt( deta*deta+dphi*dphi );
467 }
468 
469 inline Double_t TLorentzVector::DrEtaPhi(const TLorentzVector & v) const{
470  return DeltaR(v);
471 }
472 
473 inline TVector2 TLorentzVector::EtaPhiVector() {
474  return TVector2 (Eta(),Phi());
475 }
476 
477 
478 inline Double_t TLorentzVector::Angle(const TVector3 &v) const {
479  return fP.Angle(v);
480 }
481 
482 inline Double_t TLorentzVector::Mag2() const {
483  return T()*T() - fP.Mag2();
484 }
485 
486 inline Double_t TLorentzVector::Mag() const {
487  Double_t mm = Mag2();
488  return mm < 0.0 ? -TMath::Sqrt(-mm) : TMath::Sqrt(mm);
489 }
490 
491 inline Double_t TLorentzVector::M2() const { return Mag2(); }
492 inline Double_t TLorentzVector::M() const { return Mag(); }
493 
494 inline Double_t TLorentzVector::Mt2() const {
495  return E()*E() - Z()*Z();
496 }
497 
498 inline Double_t TLorentzVector::Mt() const {
499  Double_t mm = Mt2();
500  return mm < 0.0 ? -TMath::Sqrt(-mm) : TMath::Sqrt(mm);
501 }
502 
503 inline Double_t TLorentzVector::Beta() const {
504  return fP.Mag() / fE;
505 }
506 
507 inline Double_t TLorentzVector::Gamma() const {
508  Double_t b = Beta();
509  return 1.0/TMath::Sqrt(1- b*b);
510 }
511 
512 inline void TLorentzVector::SetVectMag(const TVector3 & spatial, Double_t magnitude) {
513  SetXYZM(spatial.X(), spatial.Y(), spatial.Z(), magnitude);
514 }
515 
516 inline void TLorentzVector::SetVectM(const TVector3 & spatial, Double_t mass) {
517  SetVectMag(spatial, mass);
518 }
519 
520 inline Double_t TLorentzVector::Dot(const TLorentzVector & q) const {
521  return T()*q.T() - Z()*q.Z() - Y()*q.Y() - X()*q.X();
522 }
523 
524 inline Double_t TLorentzVector::operator * (const TLorentzVector & q) const {
525  return Dot(q);
526 }
527 
528 //Member functions Plus() and Minus() return the positive and negative
529 //light-cone components:
530 //
531 // Double_t pcone = v.Plus();
532 // Double_t mcone = v.Minus();
533 //
534 //CAVEAT: The values returned are T{+,-}Z. It is known that some authors
535 //find it easier to define these components as (T{+,-}Z)/sqrt(2). Thus
536 //check what definition is used in the physics you're working in and adapt
537 //your code accordingly.
538 
539 inline Double_t TLorentzVector::Plus() const {
540  return T() + Z();
541 }
542 
543 inline Double_t TLorentzVector::Minus() const {
544  return T() - Z();
545 }
546 
547 inline TVector3 TLorentzVector::BoostVector() const {
548  return TVector3(X()/T(), Y()/T(), Z()/T());
549 }
550 
551 inline void TLorentzVector::Boost(const TVector3 & b) {
552  Boost(b.X(), b.Y(), b.Z());
553 }
554 
555 inline Double_t TLorentzVector::PseudoRapidity() const {
556  return fP.PseudoRapidity();
557 }
558 
559 inline void TLorentzVector::RotateX(Double_t angle) {
560  fP.RotateX(angle);
561 }
562 
563 inline void TLorentzVector::RotateY(Double_t angle) {
564  fP.RotateY(angle);
565 }
566 
567 inline void TLorentzVector::RotateZ(Double_t angle) {
568  fP.RotateZ(angle);
569 }
570 
571 inline void TLorentzVector::RotateUz(const TVector3 &newUzVector) {
572  fP.RotateUz(newUzVector);
573 }
574 
575 inline void TLorentzVector::Rotate(Double_t a, const TVector3 &v) {
576  fP.Rotate(a,v);
577 }
578 
579 inline TLorentzVector &TLorentzVector::operator *= (const TRotation & m) {
580  fP *= m;
581  return *this;
582 }
583 
584 inline TLorentzVector &TLorentzVector::Transform(const TRotation & m) {
585  fP.Transform(m);
586  return *this;
587 }
588 
589 inline TLorentzVector operator * (Double_t a, const TLorentzVector & p) {
590  return TLorentzVector(a*p.X(), a*p.Y(), a*p.Z(), a*p.T());
591 }
592 
593 inline TLorentzVector::TLorentzVector()
594  : fP(), fE(0.0) {}
595 
596 inline TLorentzVector::TLorentzVector(Double_t x, Double_t y, Double_t z, Double_t t)
597  : fP(x,y,z), fE(t) {}
598 
599 inline TLorentzVector::TLorentzVector(const Double_t * x0)
600  : fP(x0), fE(x0[3]) {}
601 
602 inline TLorentzVector::TLorentzVector(const Float_t * x0)
603  : fP(x0), fE(x0[3]) {}
604 
605 inline TLorentzVector::TLorentzVector(const TVector3 & p, Double_t e)
606  : fP(p), fE(e) {}
607 
608 inline TLorentzVector::TLorentzVector(const TLorentzVector & p) : TObject(p)
609  , fP(p.Vect()), fE(p.T()) {}
610 
611 
612 
613 inline Double_t TLorentzVector::operator () (int i) const
614 {
615  //dereferencing operator const
616  switch(i) {
617  case kX:
618  return fP.X();
619  case kY:
620  return fP.Y();
621  case kZ:
622  return fP.Z();
623  case kT:
624  return fE;
625  default:
626  Error("operator()()", "bad index (%d) returning 0",i);
627  }
628  return 0.;
629 }
630 
631 inline Double_t & TLorentzVector::operator () (int i)
632 {
633  //dereferencing operator
634  switch(i) {
635  case kX:
636  return fP.fX;
637  case kY:
638  return fP.fY;
639  case kZ:
640  return fP.fZ;
641  case kT:
642  return fE;
643  default:
644  Error("operator()()", "bad index (%d) returning &fE",i);
645  }
646  return fE;
647 }
648 
649 #endif