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