ROOT   6.14/05 Reference Guide
PxPyPzE4D.h
Go to the documentation of this file.
1 // @(#)root/mathcore:$Id: 04c6d98020d7178ed5f0884f9466bca32b031565$
2 // Authors: W. Brown, M. Fischler, L. Moneta 2005
3
4 /**********************************************************************
5 * *
6 * Copyright (c) 2005 , LCG ROOT MathLib Team *
7 * *
8 * *
9 **********************************************************************/
10
11 // Header file for class PxPyPzE4D
12 //
13 // Created by: fischler at Wed Jul 20 2005
14 // (starting from PxPyPzE4D by moneta)
15 //
16 // Last update: $Id: 04c6d98020d7178ed5f0884f9466bca32b031565$
17 //
18 #ifndef ROOT_Math_GenVector_PxPyPzE4D
19 #define ROOT_Math_GenVector_PxPyPzE4D 1
20
21 #include "Math/GenVector/eta.h"
22
24
25
26 #include <cmath>
27
28 namespace ROOT {
29
30 namespace Math {
31
32 //__________________________________________________________________________________________
33 /**
34  Class describing a 4D cartesian coordinate system (x, y, z, t coordinates)
35  or momentum-energy vectors stored as (Px, Py, Pz, E).
36  The metric used is (-,-,-,+)
37
38  @ingroup GenVector
39 */
40
41 template <class ScalarType = double>
42 class PxPyPzE4D {
43
44 public :
45
46  typedef ScalarType Scalar;
47
48  // --------- Constructors ---------------
49
50  /**
51  Default constructor with x=y=z=t=0
52  */
53  PxPyPzE4D() : fX(0.0), fY(0.0), fZ(0.0), fT(0.0) { }
54
55
56  /**
57  Constructor from x, y , z , t values
58  */
59  PxPyPzE4D(Scalar px, Scalar py, Scalar pz, Scalar e) :
60  fX(px), fY(py), fZ(pz), fT(e) { }
61
62
63  /**
64  construct from any vector or coordinate system class
65  implementing x(), y() and z() and t()
66  */
67  template <class CoordSystem>
68  explicit PxPyPzE4D(const CoordSystem & v) :
69  fX( v.x() ), fY( v.y() ), fZ( v.z() ), fT( v.t() ) { }
70
71  // for g++ 3.2 and 3.4 on 32 bits found that the compiler generated copy ctor and assignment are much slower
72  // so we decided to re-implement them ( there is no no need to have them with g++4)
73  /**
74  copy constructor
75  */
76  PxPyPzE4D(const PxPyPzE4D & v) :
77  fX(v.fX), fY(v.fY), fZ(v.fZ), fT(v.fT) { }
78
79  /**
80  assignment operator
81  */
83  fX = v.fX;
84  fY = v.fY;
85  fZ = v.fZ;
86  fT = v.fT;
87  return *this;
88  }
89
90  /**
91  Set internal data based on an array of 4 Scalar numbers
92  */
93  void SetCoordinates( const Scalar src[] )
94  { fX=src[0]; fY=src[1]; fZ=src[2]; fT=src[3]; }
95
96  /**
97  get internal data into an array of 4 Scalar numbers
98  */
99  void GetCoordinates( Scalar dest[] ) const
100  { dest[0] = fX; dest[1] = fY; dest[2] = fZ; dest[3] = fT; }
101
102  /**
103  Set internal data based on 4 Scalar numbers
104  */
105  void SetCoordinates(Scalar px, Scalar py, Scalar pz, Scalar e)
106  { fX=px; fY=py; fZ=pz; fT=e;}
107
108  /**
109  get internal data into 4 Scalar numbers
110  */
111  void GetCoordinates(Scalar& px, Scalar& py, Scalar& pz, Scalar& e) const
112  { px=fX; py=fY; pz=fZ; e=fT;}
113
114  // --------- Coordinates and Coordinate-like Scalar properties -------------
115
116  // cartesian (Minkowski)coordinate accessors
117
118  Scalar Px() const { return fX;}
119  Scalar Py() const { return fY;}
120  Scalar Pz() const { return fZ;}
121  Scalar E() const { return fT;}
122
123  Scalar X() const { return fX;}
124  Scalar Y() const { return fY;}
125  Scalar Z() const { return fZ;}
126  Scalar T() const { return fT;}
127
128  // other coordinate representation
129
130  /**
131  squared magnitude of spatial components
132  */
133  Scalar P2() const { return fX*fX + fY*fY + fZ*fZ; }
134
135  /**
136  magnitude of spatial components (magnitude of 3-momentum)
137  */
138  Scalar P() const { return sqrt(P2()); }
139  Scalar R() const { return P(); }
140
141  /**
142  vector magnitude squared (or mass squared)
143  */
144  Scalar M2() const { return fT*fT - fX*fX - fY*fY - fZ*fZ;}
145  Scalar Mag2() const { return M2(); }
146
147  /**
148  invariant mass
149  */
150  Scalar M() const
151  {
152  const Scalar mm = M2();
153  if (mm >= 0) {
154  return sqrt(mm);
155  } else {
156  GenVector::Throw ("PxPyPzE4D::M() - Tachyonic:\n"
157  " P^2 > E^2 so the mass would be imaginary");
158  return -sqrt(-mm);
159  }
160  }
161  Scalar Mag() const { return M(); }
162
163  /**
164  transverse spatial component squared
165  */
166  Scalar Pt2() const { return fX*fX + fY*fY;}
167  Scalar Perp2() const { return Pt2();}
168
169  /**
170  Transverse spatial component (P_perp or rho)
171  */
172  Scalar Pt() const { return sqrt(Perp2()); }
173  Scalar Perp() const { return Pt();}
174  Scalar Rho() const { return Pt();}
175
176  /**
177  transverse mass squared
178  */
179  Scalar Mt2() const { return fT*fT - fZ*fZ; }
180
181  /**
182  transverse mass
183  */
184  Scalar Mt() const {
185  const Scalar mm = Mt2();
186  if (mm >= 0) {
187  return sqrt(mm);
188  } else {
189  GenVector::Throw ("PxPyPzE4D::Mt() - Tachyonic:\n"
190  " Pz^2 > E^2 so the transverse mass would be imaginary");
191  return -sqrt(-mm);
192  }
193  }
194
195  /**
196  transverse energy squared
197  */
198  Scalar Et2() const { // is (E^2 * pt ^2) / p^2
199  // but it is faster to form p^2 from pt^2
200  Scalar pt2 = Pt2();
201  return pt2 == 0 ? 0 : fT*fT * pt2/( pt2 + fZ*fZ );
202  }
203
204  /**
205  transverse energy
206  */
207  Scalar Et() const {
208  const Scalar etet = Et2();
209  return fT < 0.0 ? -sqrt(etet) : sqrt(etet);
210  }
211
212  /**
213  azimuthal angle
214  */
215  Scalar Phi() const { return (fX == 0.0 && fY == 0.0) ? 0 : atan2(fY, fX); }
216
217  /**
218  polar angle
219  */
220  Scalar Theta() const { return (fX == 0.0 && fY == 0.0 && fZ == 0.0) ? 0 : atan2(Pt(), fZ); }
221
222  /**
223  pseudorapidity
224  */
225  Scalar Eta() const {
226  return Impl::Eta_FromRhoZ ( Pt(), fZ);
227  }
228
229  // --------- Set Coordinates of this system ---------------
230
231
232  /**
233  set X value
234  */
235  void SetPx( Scalar px) {
236  fX = px;
237  }
238  /**
239  set Y value
240  */
241  void SetPy( Scalar py) {
242  fY = py;
243  }
244  /**
245  set Z value
246  */
247  void SetPz( Scalar pz) {
248  fZ = pz;
249  }
250  /**
251  set T value
252  */
253  void SetE( Scalar e) {
254  fT = e;
255  }
256
257  /**
258  set all values using cartesian coordinates
259  */
260  void SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e) {
261  fX=px;
262  fY=py;
263  fZ=pz;
264  fT=e;
265  }
266
267
268
269  // ------ Manipulations -------------
270
271  /**
272  negate the 4-vector
273  */
274  void Negate( ) { fX = -fX; fY = -fY; fZ = -fZ; fT = -fT;}
275
276  /**
277  scale coordinate values by a scalar quantity a
278  */
279  void Scale( const Scalar & a) {
280  fX *= a;
281  fY *= a;
282  fZ *= a;
283  fT *= a;
284  }
285
286  /**
287  Assignment from a generic coordinate system implementing
288  x(), y(), z() and t()
289  */
290  template <class AnyCoordSystem>
291  PxPyPzE4D & operator = (const AnyCoordSystem & v) {
292  fX = v.x();
293  fY = v.y();
294  fZ = v.z();
295  fT = v.t();
296  return *this;
297  }
298
299  /**
300  Exact equality
301  */
302  bool operator == (const PxPyPzE4D & rhs) const {
303  return fX == rhs.fX && fY == rhs.fY && fZ == rhs.fZ && fT == rhs.fT;
304  }
305  bool operator != (const PxPyPzE4D & rhs) const {return !(operator==(rhs));}
306
307
308  // ============= Compatibility section ==================
309
310  // The following make this coordinate system look enough like a CLHEP
311  // vector that an assignment member template can work with either
312  Scalar x() const { return fX; }
313  Scalar y() const { return fY; }
314  Scalar z() const { return fZ; }
315  Scalar t() const { return fT; }
316
317
318
319 #if defined(__MAKECINT__) || defined(G__DICTIONARY)
320
321  // ====== Set member functions for coordinates in other systems =======
322
323  void SetPt(Scalar pt);
324
325  void SetEta(Scalar eta);
326
327  void SetPhi(Scalar phi);
328
329  void SetM(Scalar m);
330
331 #endif
332
333 private:
334
335  /**
336  (contigous) data containing the coordinate values x,y,z,t
337  */
338
339  ScalarType fX;
340  ScalarType fY;
341  ScalarType fZ;
342  ScalarType fT;
343
344 };
345
346 } // end namespace Math
347 } // end namespace ROOT
348
349
350
351 #if defined(__MAKECINT__) || defined(G__DICTIONARY)
352 // move implementations here to avoid circle dependencies
353
356
357 namespace ROOT {
358
359 namespace Math {
360
361
362  // ====== Set member functions for coordinates in other systems =======
363  // throw always exceptions in this case
364
365 template <class ScalarType>
367  GenVector_exception e("PxPyPzE4D::SetPt() is not supposed to be called");
368  throw e;
369  PtEtaPhiE4D<Scalar> v(*this); v.SetPt(pt); *this = PxPyPzE4D<Scalar>(v);
370 }
371 template <class ScalarType>
373  GenVector_exception e("PxPyPzE4D::SetEta() is not supposed to be called");
374  throw e;
375  PtEtaPhiE4D<Scalar> v(*this); v.SetEta(eta); *this = PxPyPzE4D<Scalar>(v);
376 }
377 template <class ScalarType>
379  GenVector_exception e("PxPyPzE4D::SetPhi() is not supposed to be called");
380  throw e;
381  PtEtaPhiE4D<Scalar> v(*this); v.SetPhi(phi); *this = PxPyPzE4D<Scalar>(v);
382 }
383
384 template <class ScalarType>
386  GenVector_exception e("PxPyPzE4D::SetM() is not supposed to be called");
387  throw e;
388  PtEtaPhiM4D<Scalar> v(*this); v.SetM(m);
389  *this = PxPyPzE4D<Scalar>(v);
390 }
391
392
393 } // end namespace Math
394
395 } // end namespace ROOT
396
397 #endif // endif __MAKE__CINT || G__DICTIONARY
398
399
400 #endif // ROOT_Math_GenVector_PxPyPzE4D
Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and E (or rho...
Definition: PtEtaPhiE4D.h:52
void SetPhi(Scalar phi)
set phi value
Definition: PtEtaPhiE4D.h:266
Scalar Mt() const
transverse mass
Definition: PxPyPzE4D.h:184
Class describing a 4D cylindrical coordinate system using Pt , Phi, Eta and M (mass) The metric used ...
Definition: PtEtaPhiM4D.h:52
PxPyPzE4D()
Default constructor with x=y=z=t=0.
Definition: PxPyPzE4D.h:53
auto * m
Definition: textangle.C:8
Namespace for new ROOT classes and functions.
Definition: StringConv.hxx:21
Scalar Pt() const
Transverse spatial component (P_perp or rho)
Definition: PxPyPzE4D.h:172
void SetCoordinates(const Scalar src[])
Set internal data based on an array of 4 Scalar numbers.
Definition: PxPyPzE4D.h:93
Scalar P2() const
squared magnitude of spatial components
Definition: PxPyPzE4D.h:133
Scalar Pt2() const
transverse spatial component squared
Definition: PxPyPzE4D.h:166
Scalar P() const
magnitude of spatial components (magnitude of 3-momentum)
Definition: PxPyPzE4D.h:138
Scalar Perp2() const
Definition: PxPyPzE4D.h:167
ScalarType fX
(contigous) data containing the coordinate values x,y,z,t
Definition: PxPyPzE4D.h:339
Scalar E() const
Definition: PxPyPzE4D.h:121
Scalar Theta() const
polar angle
Definition: PxPyPzE4D.h:220
void GetCoordinates(Scalar dest[]) const
get internal data into an array of 4 Scalar numbers
Definition: PxPyPzE4D.h:99
static constexpr double mm
Scalar Z() const
Definition: PxPyPzE4D.h:125
PxPyPzE4D(const PxPyPzE4D &v)
copy constructor
Definition: PxPyPzE4D.h:76
Scalar Eta() const
pseudorapidity
Definition: PxPyPzE4D.h:225
VecExpr< UnaryOp< Sqrt< T >, VecExpr< A, T, D >, T >, T, D > sqrt(const VecExpr< A, T, D > &rhs)
void SetPx(Scalar px)
set X value
Definition: PxPyPzE4D.h:235
ScalarType Scalar
Definition: PxPyPzE4D.h:46
Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors...
Definition: PxPyPzE4D.h:42
Scalar Mag() const
Definition: PxPyPzE4D.h:161
void SetPxPyPzE(Scalar px, Scalar py, Scalar pz, Scalar e)
set all values using cartesian coordinates
Definition: PxPyPzE4D.h:260
void GetCoordinates(Scalar &px, Scalar &py, Scalar &pz, Scalar &e) const
get internal data into 4 Scalar numbers
Definition: PxPyPzE4D.h:111
Scalar x() const
Definition: PxPyPzE4D.h:312
Scalar Px() const
Definition: PxPyPzE4D.h:118
Scalar Perp() const
Definition: PxPyPzE4D.h:173
Scalar X() const
Definition: PxPyPzE4D.h:123
bool operator==(const PxPyPzE4D &rhs) const
Exact equality.
Definition: PxPyPzE4D.h:302
void SetM(Scalar mass)
set M value
Definition: PtEtaPhiM4D.h:291
Scalar Y() const
Definition: PxPyPzE4D.h:124
PxPyPzE4D & operator=(const PxPyPzE4D &v)
assignment operator
Definition: PxPyPzE4D.h:82
Scalar R() const
Definition: PxPyPzE4D.h:139
PxPyPzE4D(const CoordSystem &v)
construct from any vector or coordinate system class implementing x(), y() and z() and t() ...
Definition: PxPyPzE4D.h:68
Scalar T() const
Definition: PxPyPzE4D.h:126
void SetPt(Scalar pt)
set Pt value
Definition: PtEtaPhiE4D.h:254
TPaveText * pt
void Throw(const char *)
function throwing exception, by creating internally a GenVector_exception only when needed ...
SVector< double, 2 > v
Definition: Dict.h:5
void Scale(const Scalar &a)
scale coordinate values by a scalar quantity a
Definition: PxPyPzE4D.h:279
auto * a
Definition: textangle.C:12
void SetPz(Scalar pz)
set Z value
Definition: PxPyPzE4D.h:247
void SetPy(Scalar py)
set Y value
Definition: PxPyPzE4D.h:241
void SetEta(Scalar eta)
set eta value
Definition: PtEtaPhiE4D.h:260
Scalar Et() const
transverse energy
Definition: PxPyPzE4D.h:207
Scalar Et2() const
transverse energy squared
Definition: PxPyPzE4D.h:198
Scalar M() const
invariant mass
Definition: PxPyPzE4D.h:150
Scalar z() const
Definition: PxPyPzE4D.h:314
Scalar Rho() const
Definition: PxPyPzE4D.h:174
Scalar Eta_FromRhoZ(Scalar rho, Scalar z)
Calculate eta given rho and zeta.
Definition: eta.h:48
PxPyPzE4D(Scalar px, Scalar py, Scalar pz, Scalar e)
Constructor from x, y , z , t values.
Definition: PxPyPzE4D.h:59
Scalar t() const
Definition: PxPyPzE4D.h:315
double atan2(double, double)
void Negate()
negate the 4-vector
Definition: PxPyPzE4D.h:274
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
Namespace for new Math classes and functions.
Scalar Mt2() const
transverse mass squared
Definition: PxPyPzE4D.h:179
#define dest(otri, vertexptr)
Definition: triangle.c:1040
Scalar y() const
Definition: PxPyPzE4D.h:313
bool operator!=(const PxPyPzE4D &rhs) const
Definition: PxPyPzE4D.h:305
Scalar Pz() const
Definition: PxPyPzE4D.h:120
Scalar Phi() const
azimuthal angle
Definition: PxPyPzE4D.h:215
void SetCoordinates(Scalar px, Scalar py, Scalar pz, Scalar e)
Set internal data based on 4 Scalar numbers.
Definition: PxPyPzE4D.h:105
Scalar Py() const
Definition: PxPyPzE4D.h:119
Scalar M2() const
vector magnitude squared (or mass squared)
Definition: PxPyPzE4D.h:144
Scalar Mag2() const
Definition: PxPyPzE4D.h:145
void SetE(Scalar e)
set T value
Definition: PxPyPzE4D.h:253