source: trunk/CLHEP/Vector/LorentzVector.h@ 17

Last change on this file since 17 was 4, checked in by Pavel Demin, 16 years ago

first commit
File size: 19.1 KB
RevLine 
[4]1// -*- C++ -*-
2// CLASSDOC OFF
3// $Id: LorentzVector.h,v 1.1 2008-06-04 14:14:58 demin Exp $
4// ---------------------------------------------------------------------------
5// CLASSDOC ON
6//
7// This file is a part of the CLHEP - a Class Library for High Energy Physics.
8//
9// HepLorentzVector is a Lorentz vector consisting of Hep3Vector and
10// double components. Lorentz transformations (rotations and boosts)
11// of these vectors are perfomed by multiplying with objects of
12// the HepLorenzRotation class.
13//
14// .SS See Also
15// ThreeVector.h, Rotation.h, LorentzRotation.h
16//
17// .SS Authors
18// Leif Lonnblad and Anders Nilsson. Modified by Evgueni Tcherniaev, Mark Fischler
19//
20
21#ifndef HEP_LORENTZVECTOR_H
22#define HEP_LORENTZVECTOR_H
23
24#ifdef GNUPRAGMA
25#pragma interface
26#endif
27
28#include <iostream>
29#include "CLHEP/Vector/defs.h"
30#include "CLHEP/Vector/ThreeVector.h"
31
32namespace CLHEP {
33
34// Declarations of classes and global methods
35class HepLorentzVector;
36class HepLorentzRotation;
37class HepRotation;
38class HepAxisAngle;
39class HepEulerAngles;
40class Tcomponent;
41HepLorentzVector rotationXOf( const HepLorentzVector & vec, double delta );
42HepLorentzVector rotationYOf( const HepLorentzVector & vec, double delta );
43HepLorentzVector rotationZOf( const HepLorentzVector & vec, double delta );
44HepLorentzVector rotationOf
45 ( const HepLorentzVector & vec, const Hep3Vector & axis, double delta );
46HepLorentzVector rotationOf
47 ( const HepLorentzVector & vec, const HepAxisAngle & ax );
48HepLorentzVector rotationOf
49 ( const HepLorentzVector & vec, const HepEulerAngles & e );
50HepLorentzVector rotationOf
51 ( const HepLorentzVector & vec, double phi,
52 double theta,
53 double psi );
54inline
55HepLorentzVector boostXOf( const HepLorentzVector & vec, double beta );
56inline
57HepLorentzVector boostYOf( const HepLorentzVector & vec, double beta );
58inline
59HepLorentzVector boostZOf( const HepLorentzVector & vec, double beta );
60inline HepLorentzVector boostOf
61 ( const HepLorentzVector & vec, const Hep3Vector & betaVector );
62inline HepLorentzVector boostOf
63 ( const HepLorentzVector & vec, const Hep3Vector & axis, double beta );
64
65enum ZMpvMetric_t { TimePositive, TimeNegative };
66
67
68/**
69 * @author
70 * @ingroup vector
71 */
72class HepLorentzVector {
73
74public:
75
76 enum { X=0, Y=1, Z=2, T=3, NUM_COORDINATES=4, SIZE=NUM_COORDINATES };
77 // Safe indexing of the coordinates when using with matrices, arrays, etc.
78 // (BaBar)
79
80 inline HepLorentzVector(double x, double y,
81 double z, double t);
82 // Constructor giving the components x, y, z, t.
83
84 inline HepLorentzVector(double x, double y, double z);
85 // Constructor giving the components x, y, z with t-component set to 0.0.
86
87 inline HepLorentzVector(double t);
88 // Constructor giving the t-component with x, y and z set to 0.0.
89
90 inline HepLorentzVector();
91 // Default constructor with x, y, z and t set to 0.0.
92
93 inline HepLorentzVector(const Hep3Vector & p, double e);
94 inline HepLorentzVector(double e, const Hep3Vector & p);
95 // Constructor giving a 3-Vector and a time component.
96
97 inline HepLorentzVector(const HepLorentzVector &);
98 // Copy constructor.
99
100 inline ~HepLorentzVector();
101 // The destructor.
102
103 inline operator const Hep3Vector & () const;
104 inline operator Hep3Vector & ();
105 // Conversion (cast) to Hep3Vector.
106
107 inline double x() const;
108 inline double y() const;
109 inline double z() const;
110 inline double t() const;
111 // Get position and time.
112
113 inline void setX(double);
114 inline void setY(double);
115 inline void setZ(double);
116 inline void setT(double);
117 // Set position and time.
118
119 inline double px() const;
120 inline double py() const;
121 inline double pz() const;
122 inline double e() const;
123 // Get momentum and energy.
124
125 inline void setPx(double);
126 inline void setPy(double);
127 inline void setPz(double);
128 inline void setE(double);
129 // Set momentum and energy.
130
131 inline Hep3Vector vect() const;
132 // Get spatial component.
133
134 inline void setVect(const Hep3Vector &);
135 // Set spatial component.
136
137 inline double theta() const;
138 inline double cosTheta() const;
139 inline double phi() const;
140 inline double rho() const;
141 // Get spatial vector components in spherical coordinate system.
142
143 inline void setTheta(double);
144 inline void setPhi(double);
145 inline void setRho(double);
146 // Set spatial vector components in spherical coordinate system.
147
148 double operator () (int) const;
149 inline double operator [] (int) const;
150 // Get components by index.
151
152 double & operator () (int);
153 inline double & operator [] (int);
154 // Set components by index.
155
156 inline HepLorentzVector & operator = (const HepLorentzVector &);
157 // Assignment.
158
159 inline HepLorentzVector operator + (const HepLorentzVector &) const;
160 inline HepLorentzVector & operator += (const HepLorentzVector &);
161 // Additions.
162
163 inline HepLorentzVector operator - (const HepLorentzVector &) const;
164 inline HepLorentzVector & operator -= (const HepLorentzVector &);
165 // Subtractions.
166
167 inline HepLorentzVector operator - () const;
168 // Unary minus.
169
170 inline HepLorentzVector & operator *= (double);
171 HepLorentzVector & operator /= (double);
172 // Scaling with real numbers.
173
174 inline bool operator == (const HepLorentzVector &) const;
175 inline bool operator != (const HepLorentzVector &) const;
176 // Comparisons.
177
178 inline double perp2() const;
179 // Transverse component of the spatial vector squared.
180
181 inline double perp() const;
182 // Transverse component of the spatial vector (R in cylindrical system).
183
184 inline void setPerp(double);
185 // Set the transverse component of the spatial vector.
186
187 inline double perp2(const Hep3Vector &) const;
188 // Transverse component of the spatial vector w.r.t. given axis squared.
189
190 inline double perp(const Hep3Vector &) const;
191 // Transverse component of the spatial vector w.r.t. given axis.
192
193 inline double angle(const Hep3Vector &) const;
194 // Angle wrt. another vector.
195
196 inline double mag2() const;
197 // Dot product of 4-vector with itself.
198 // By default the metric is TimePositive, and mag2() is the same as m2().
199
200 inline double m2() const;
201 // Invariant mass squared.
202
203 inline double mag() const;
204 inline double m() const;
205 // Invariant mass. If m2() is negative then -sqrt(-m2()) is returned.
206
207 inline double mt2() const;
208 // Transverse mass squared.
209
210 inline double mt() const;
211 // Transverse mass.
212
213 inline double et2() const;
214 // Transverse energy squared.
215
216 inline double et() const;
217 // Transverse energy.
218
219 inline double dot(const HepLorentzVector &) const;
220 inline double operator * (const HepLorentzVector &) const;
221 // Scalar product.
222
223 inline double invariantMass2( const HepLorentzVector & w ) const;
224 // Invariant mass squared of pair of 4-vectors
225
226 double invariantMass ( const HepLorentzVector & w ) const;
227 // Invariant mass of pair of 4-vectors
228
229 inline void setVectMag(const Hep3Vector & spatial, double magnitude);
230 inline void setVectM(const Hep3Vector & spatial, double mass);
231 // Copy spatial coordinates, and set energy = sqrt(mass^2 + spatial^2)
232
233 inline double plus() const;
234 inline double minus() const;
235 // Returns the positive/negative light-cone component t +/- z.
236
237 Hep3Vector boostVector() const;
238 // Boost needed from rest4Vector in rest frame to form this 4-vector
239 // Returns the spatial components divided by the time component.
240
241 HepLorentzVector & boost(double, double, double);
242 inline HepLorentzVector & boost(const Hep3Vector &);
243 // Lorentz boost.
244
245 HepLorentzVector & boostX( double beta );
246 HepLorentzVector & boostY( double beta );
247 HepLorentzVector & boostZ( double beta );
248 // Boost along an axis, by magnitue beta (fraction of speed of light)
249
250 double rapidity() const;
251 // Returns the rapidity, i.e. 0.5*ln((E+pz)/(E-pz))
252
253 inline double pseudoRapidity() const;
254 // Returns the pseudo-rapidity, i.e. -ln(tan(theta/2))
255
256 inline bool isTimelike() const;
257 // Test if the 4-vector is timelike
258
259 inline bool isSpacelike() const;
260 // Test if the 4-vector is spacelike
261
262 inline bool isLightlike(double epsilon=tolerance) const;
263 // Test for lightlike is within tolerance epsilon
264
265 HepLorentzVector & rotateX(double);
266 // Rotate the spatial component around the x-axis.
267
268 HepLorentzVector & rotateY(double);
269 // Rotate the spatial component around the y-axis.
270
271 HepLorentzVector & rotateZ(double);
272 // Rotate the spatial component around the z-axis.
273
274 HepLorentzVector & rotateUz(const Hep3Vector &);
275 // Rotates the reference frame from Uz to newUz (unit vector).
276
277 HepLorentzVector & rotate(double, const Hep3Vector &);
278 // Rotate the spatial component around specified axis.
279
280 inline HepLorentzVector & operator *= (const HepRotation &);
281 inline HepLorentzVector & transform(const HepRotation &);
282 // Transformation with HepRotation.
283
284 HepLorentzVector & operator *= (const HepLorentzRotation &);
285 HepLorentzVector & transform(const HepLorentzRotation &);
286 // Transformation with HepLorenzRotation.
287
288// = = = = = = = = = = = = = = = = = = = = = = = =
289//
290// Esoteric properties and operations on 4-vectors:
291//
292// 0 - Flexible metric convention and axial unit 4-vectors
293// 1 - Construct and set 4-vectors in various ways
294// 2 - Synonyms for accessing coordinates and properties
295// 2a - Setting space coordinates in different ways
296// 3 - Comparisions (dictionary, near-ness, and geometric)
297// 4 - Intrinsic properties
298// 4a - Releativistic kinematic properties
299// 4b - Methods combining two 4-vectors
300// 5 - Properties releative to z axis and to arbitrary directions
301// 7 - Rotations and Boosts
302//
303// = = = = = = = = = = = = = = = = = = = = = = = =
304
305// 0 - Flexible metric convention
306
307 static ZMpvMetric_t setMetric( ZMpvMetric_t m );
308 static ZMpvMetric_t getMetric();
309
310// 1 - Construct and set 4-vectors in various ways
311
312 inline void set (double x, double y, double z, double t);
313 inline void set (double x, double y, double z, Tcomponent t);
314 inline HepLorentzVector(double x, double y, double z, Tcomponent t);
315 // Form 4-vector by supplying cartesian coordinate components
316
317 inline void set (Tcomponent t, double x, double y, double z);
318 inline HepLorentzVector(Tcomponent t, double x, double y, double z);
319 // Deprecated because the 4-doubles form uses x,y,z,t, not t,x,y,z.
320
321 inline void set ( double t );
322
323 inline void set ( Tcomponent t );
324 inline explicit HepLorentzVector( Tcomponent t );
325 // Form 4-vector with zero space components, by supplying t component
326
327 inline void set ( const Hep3Vector & v );
328 inline explicit HepLorentzVector( const Hep3Vector & v );
329 // Form 4-vector with zero time component, by supplying space 3-vector
330
331 inline HepLorentzVector & operator=( const Hep3Vector & v );
332 // Form 4-vector with zero time component, equal to space 3-vector
333
334 inline void set ( const Hep3Vector & v, double t );
335 inline void set ( double t, const Hep3Vector & v );
336 // Set using specified space vector and time component
337
338// 2 - Synonyms for accessing coordinates and properties
339
340 inline double getX() const;
341 inline double getY() const;
342 inline double getZ() const;
343 inline double getT() const;
344 // Get position and time.
345
346 inline Hep3Vector v() const;
347 inline Hep3Vector getV() const;
348 // Get spatial component. Same as vect.
349
350 inline void setV(const Hep3Vector &);
351 // Set spatial component. Same as setVect.
352
353// 2a - Setting space coordinates in different ways
354
355 inline void setV( double x, double y, double z );
356
357 inline void setRThetaPhi( double r, double theta, double phi);
358 inline void setREtaPhi( double r, double eta, double phi);
359 inline void setRhoPhiZ( double rho, double phi, double z );
360
361// 3 - Comparisions (dictionary, near-ness, and geometric)
362
363 int compare( const HepLorentzVector & w ) const;
364
365 bool operator >( const HepLorentzVector & w ) const;
366 bool operator <( const HepLorentzVector & w ) const;
367 bool operator>=( const HepLorentzVector & w ) const;
368 bool operator<=( const HepLorentzVector & w ) const;
369
370 bool isNear ( const HepLorentzVector & w,
371 double epsilon=tolerance ) const;
372 double howNear( const HepLorentzVector & w ) const;
373 // Is near using Euclidean measure t**2 + v**2
374
375 bool isNearCM ( const HepLorentzVector & w,
376 double epsilon=tolerance ) const;
377 double howNearCM( const HepLorentzVector & w ) const;
378 // Is near in CM frame: Applicable only for two timelike HepLorentzVectors
379
380 // If w1 and w2 are already in their CM frame, then w1.isNearCM(w2)
381 // is exactly equivalent to w1.isNear(w2).
382 // If w1 and w2 have T components of zero, w1.isNear(w2) is exactly
383 // equivalent to w1.getV().isNear(w2.v()).
384
385 bool isParallel( const HepLorentzVector & w,
386 double epsilon=tolerance ) const;
387 // Test for isParallel is within tolerance epsilon
388 double howParallel (const HepLorentzVector & w) const;
389
390 static double getTolerance();
391 static double setTolerance( double tol );
392 // Set the tolerance for HepLorentzVectors to be considered near
393 // The same tolerance is used for determining isLightlike, and isParallel
394
395 double deltaR(const HepLorentzVector & v) const;
396 // sqrt ( (delta eta)^2 + (delta phi)^2 ) of space part
397
398// 4 - Intrinsic properties
399
400 double howLightlike() const;
401 // Close to zero for almost lightlike 4-vectors; up to 1.
402
403 inline double euclideanNorm2() const;
404 // Sum of the squares of time and space components; not Lorentz invariant.
405
406 inline double euclideanNorm() const;
407 // Length considering the metric as (+ + + +); not Lorentz invariant.
408
409
410// 4a - Relativistic kinematic properties
411
412// All Relativistic kinematic properties are independent of the sense of metric
413
414 inline double restMass2() const;
415 inline double invariantMass2() const;
416 // Rest mass squared -- same as m2()
417
418 inline double restMass() const;
419 inline double invariantMass() const;
420 // Same as m(). If m2() is negative then -sqrt(-m2()) is returned.
421
422// The following properties are rest-frame related,
423// and are applicable only to non-spacelike 4-vectors
424
425 HepLorentzVector rest4Vector() const;
426 // This 4-vector, boosted into its own rest frame: (0, 0, 0, m())
427 // The following relation holds by definition:
428 // w.rest4Vector().boost(w.boostVector()) == w
429
430 // Beta and gamma of the boost vector
431 double beta() const;
432 // Relativistic beta of the boost vector
433
434 double gamma() const;
435 // Relativistic gamma of the boost vector
436
437 inline double eta() const;
438 // Pseudorapidity (of the space part)
439
440 inline double eta(const Hep3Vector & ref) const;
441 // Pseudorapidity (of the space part) w.r.t. specified direction
442
443 double rapidity(const Hep3Vector & ref) const;
444 // Rapidity in specified direction
445
446 double coLinearRapidity() const;
447 // Rapidity, in the relativity textbook sense: atanh (|P|/E)
448
449 Hep3Vector findBoostToCM() const;
450 // Boost needed to get to center-of-mass frame:
451 // w.findBoostToCM() == - w.boostVector()
452 // w.boost(w.findBoostToCM()) == w.rest4Vector()
453
454 Hep3Vector findBoostToCM( const HepLorentzVector & w ) const;
455 // Boost needed to get to combined center-of-mass frame:
456 // w1.findBoostToCM(w2) == w2.findBoostToCM(w1)
457 // w.findBoostToCM(w) == w.findBoostToCM()
458
459 inline double et2(const Hep3Vector &) const;
460 // Transverse energy w.r.t. given axis squared.
461
462 inline double et(const Hep3Vector &) const;
463 // Transverse energy w.r.t. given axis.
464
465// 4b - Methods combining two 4-vectors
466
467 inline double diff2( const HepLorentzVector & w ) const;
468 // (this - w).dot(this-w); sign depends on metric choice
469
470 inline double delta2Euclidean ( const HepLorentzVector & w ) const;
471 // Euclidean norm of differnce: (delta_T)^2 + (delta_V)^2
472
473// 5 - Properties releative to z axis and to arbitrary directions
474
475 double plus( const Hep3Vector & ref ) const;
476 // t + projection in reference direction
477
478 double minus( const Hep3Vector & ref ) const;
479 // t - projection in reference direction
480
481// 7 - Rotations and boosts
482
483 HepLorentzVector & rotate ( const Hep3Vector & axis, double delta );
484 // Same as rotate (delta, axis)
485
486 HepLorentzVector & rotate ( const HepAxisAngle & ax );
487 HepLorentzVector & rotate ( const HepEulerAngles & e );
488 HepLorentzVector & rotate ( double phi,
489 double theta,
490 double psi );
491 // Rotate using these HepEuler angles - see Goldstein page 107 for conventions
492
493 HepLorentzVector & boost ( const Hep3Vector & axis, double beta );
494 // Normalizes the Hep3Vector to define a direction, and uses beta to
495 // define the magnitude of the boost.
496
497 friend HepLorentzVector rotationXOf
498 ( const HepLorentzVector & vec, double delta );
499 friend HepLorentzVector rotationYOf
500 ( const HepLorentzVector & vec, double delta );
501 friend HepLorentzVector rotationZOf
502 ( const HepLorentzVector & vec, double delta );
503 friend HepLorentzVector rotationOf
504 ( const HepLorentzVector & vec, const Hep3Vector & axis, double delta );
505 friend HepLorentzVector rotationOf
506 ( const HepLorentzVector & vec, const HepAxisAngle & ax );
507 friend HepLorentzVector rotationOf
508 ( const HepLorentzVector & vec, const HepEulerAngles & e );
509 friend HepLorentzVector rotationOf
510 ( const HepLorentzVector & vec, double phi,
511 double theta,
512 double psi );
513
514 inline friend HepLorentzVector boostXOf
515 ( const HepLorentzVector & vec, double beta );
516 inline friend HepLorentzVector boostYOf
517 ( const HepLorentzVector & vec, double beta );
518 inline friend HepLorentzVector boostZOf
519 ( const HepLorentzVector & vec, double beta );
520 inline friend HepLorentzVector boostOf
521 ( const HepLorentzVector & vec, const Hep3Vector & betaVector );
522 inline friend HepLorentzVector boostOf
523 ( const HepLorentzVector & vec, const Hep3Vector & axis, double beta );
524
525private:
526
527 Hep3Vector pp;
528 double ee;
529
530 static double tolerance;
531 static double metric;
532
533}; // HepLorentzVector
534
535// 8 - Axial Unit 4-vectors
536
537static const HepLorentzVector X_HAT4 = HepLorentzVector( 1, 0, 0, 0 );
538static const HepLorentzVector Y_HAT4 = HepLorentzVector( 0, 1, 0, 0 );
539static const HepLorentzVector Z_HAT4 = HepLorentzVector( 0, 0, 1, 0 );
540static const HepLorentzVector T_HAT4 = HepLorentzVector( 0, 0, 0, 1 );
541
542// Global methods
543
544std::ostream & operator << (std::ostream &, const HepLorentzVector &);
545// Output to a stream.
546
547std::istream & operator >> (std::istream &, HepLorentzVector &);
548// Input from a stream.
549
550typedef HepLorentzVector HepLorentzVectorD;
551typedef HepLorentzVector HepLorentzVectorF;
552
553inline HepLorentzVector operator * (const HepLorentzVector &, double a);
554inline HepLorentzVector operator * (double a, const HepLorentzVector &);
555// Scaling LorentzVector with a real number
556
557 HepLorentzVector operator / (const HepLorentzVector &, double a);
558// Dividing LorentzVector by a real number
559
560// Tcomponent definition:
561
562// Signature protection for 4-vector constructors taking 4 components
563class Tcomponent {
564private:
565 double t_;
566public:
567 explicit Tcomponent(double t) : t_(t) {}
568 operator double() const { return t_; }
569}; // Tcomponent
570
571} // namespace CLHEP
572
573#include "CLHEP/Vector/LorentzVector.icc"
574
575#ifdef ENABLE_BACKWARDS_COMPATIBILITY
576// backwards compatibility will be enabled ONLY in CLHEP 1.9
577using namespace CLHEP;
578#endif
579
580#endif /* HEP_LORENTZVECTOR_H */
Note: See TracBrowser for help on using the repository browser.