ROOT   6.14/05 Reference Guide
TVector3.cxx
Go to the documentation of this file.
1 // @(#)root/physics:$Id$
2 // Author: Pasha Murat, Peter Malzacher 12/02/99
3 // Aug 11 1999: added Pt == 0 guard to Eta()
4 // Oct 8 1999: changed Warning to Error and
5 // return fX in Double_t & operator()
7 // Warning-> Error in Double_t operator()
8
9 /** \class TVector3
10  \ingroup Physics
11
12 TVector3 is a general three vector class, which can be used for
13 the description of different vectors in 3D.
14
16
17 TVector3 has been implemented as a vector of three Double_t
18 variables, representing the cartesian coordinates. By default all components
19 are initialized to zero:
20
21 ~~~
22  TVector3 v1; // v1 = (0,0,0)
23  TVector3 v3(1,2,3); // v3 = (1,2,3)
24  TVector3 v4(v2); // v4 = v2
25 ~~~
26
27 It is also possible (but not recommended) to initialize a TVector3
28 with a Double_t or Float_t C array.
29
30 You can get the basic components either by name or by index using operator():
31
32 ~~~
33  xx = v1.X(); or xx = v1(0);
34  yy = v1.Y(); yy = v1(1);
35  zz = v1.Z(); zz = v1(2);
36 ~~~
37
38 The member functions SetX(), SetY(), SetZ() and SetXYZ() allow to set the components:
39
40 ~~~
41  v1.SetX(1.); v1.SetY(2.); v1.SetZ(3.);
42  v1.SetXYZ(1.,2.,3.);
43 ~~~
44
45 ### Non-cartesian coordinates
46
47 To get information on the TVector3 in spherical (rho,phi,theta)
48 or cylindrical (z,r,theta) coordinates, the
49
50 the member functions Mag() (=magnitude=rho in spherical coordinates),
51 Mag2(), Theta(), CosTheta(), Phi(), Perp() (the transverse component=r in
52 cylindrical coordinates), Perp2() can be used:
53
54
55 ~~~
56  Double_t m = v.Mag(); // get magnitude (=rho=Sqrt(x*x+y*y+z*z)))
57  Double_t m2 = v.Mag2(); // get magnitude squared
58  Double_t t = v.Theta(); // get polar angle
59  Double_t ct = v.CosTheta(); // get cos of theta
60  Double_t p = v.Phi(); // get azimuth angle
61  Double_t pp = v.Perp(); // get transverse component
62  Double_t pp2= v.Perp2(); // get transvers component squared
63 ~~~
64
65 It is also possible to get the transverse component with respect to
66 another vector:
67
68 ~~~
69  Double_t ppv1 = v.Perp(v1);
70  Double_t pp2v1 = v.Perp2(v1);
71 ~~~
72
73 The pseudo-rapidity ( eta=-ln (tan (theta/2)) ) can be obtained by Eta()
74 or PseudoRapidity():
75
76 ~~~
77  Double_t eta = v.PseudoRapidity();
78 ~~~
79
80 There are set functions to change one of the non-cartesian coordinates:
81
82 ~~~
83  v.SetTheta(.5); // keeping rho and phi
84  v.SetPhi(.8); // keeping rho and theta
85  v.SetMag(10.); // keeping theta and phi
86  v.SetPerp(3.); // keeping z and phi
87 ~~~
88
89 ### Arithmetic / Comparison
90
91 The TVector3 class provides the operators to add, subtract, scale and compare
92 vectors:
93
94 ~~~
95  v3 = -v1;
96  v1 = v2+v3;
97  v1 += v3;
98  v1 = v1 - v3
99  v1 -= v3;
100  v1 *= 10;
101  v1 = 5*v2;
102  if (v1==v2) {...}
103  if (v1!=v2) {...}
104 ~~~
105
106 ### Related Vectors
107
108 ~~~
109  v2 = v1.Unit(); // get unit vector parallel to v1
110  v2 = v1.Orthogonal(); // get vector orthogonal to v1
111 ~~~
112
113 ### Scalar and vector products
114
115 ~~~
116  s = v1.Dot(v2); // scalar product
117  s = v1 * v2; // scalar product
118  v = v1.Cross(v2); // vector product
119 ~~~
120
121 ### Angle between two vectors
122
123 ~~~
124  Double_t a = v1.Angle(v2);
125 ~~~
126
127 ### Rotations
128
129 #### Rotation around axes
130
131 ~~~
132  v.RotateX(.5);
133  v.RotateY(TMath::Pi());
134  v.RotateZ(angle);
135 ~~~
136
137 #### Rotation around a vector
138
139 ~~~
140  v1.Rotate(TMath::Pi()/4, v2); // rotation around v2
141 ~~~
142
143 #### Rotation by TRotation
144 TVector3 objects can be rotated by objects of the TRotation
145 class using the Transform() member functions,
146
147 the operator *= or the operator * of the TRotation class:
148
149 ~~~
150  TRotation m;
151  ...
152  v1.transform(m);
153  v1 = m*v1;
154  v1 *= m; // Attention v1 = m*v1
155 ~~~
156
157 #### Transformation from rotated frame
158
159 ~~~
160  TVector3 direction = v.Unit()
161  v1.RotateUz(direction); // direction must be TVector3 of unit length
162 ~~~
163
164 transforms v1 from the rotated frame (z' parallel to direction, x' in
165 the theta plane and y' in the xy plane as well as perpendicular to the
166 theta plane) to the (x,y,z) frame.
167 */
168
169
170 #include "TMatrix.h"
171 #include "TVector3.h"
172
173 #include "TBuffer.h"
174 #include "TRotation.h"
175 #include "TMath.h"
176
178
179
180 ////////////////////////////////////////////////////////////////////////////////
181 /// Multiplication operator
182
184  return *this = m * (*this);
185 }
186
187 ////////////////////////////////////////////////////////////////////////////////
188 /// Transform this vector with a TRotation
189
191  return *this = m * (*this);
192 }
193
194 ////////////////////////////////////////////////////////////////////////////////
195 /// Return the angle w.r.t. another 3-vector.
196
198 {
199  Double_t ptot2 = Mag2()*q.Mag2();
200  if(ptot2 <= 0) {
201  return 0.0;
202  } else {
203  Double_t arg = Dot(q)/TMath::Sqrt(ptot2);
204  if(arg > 1.0) arg = 1.0;
205  if(arg < -1.0) arg = -1.0;
206  return TMath::ACos(arg);
207  }
208 }
209
210 ////////////////////////////////////////////////////////////////////////////////
211 /// Return the transverse component (R in cylindrical coordinate system)
212
214 {
215  return TMath::Sqrt(Perp2());
216 }
217
218
219 ////////////////////////////////////////////////////////////////////////////////
220 /// Return the transverse component (R in cylindrical coordinate system)
221
223 {
224  return TMath::Sqrt(Perp2(p));
225 }
226
227 ////////////////////////////////////////////////////////////////////////////////
228 /// Return the azimuth angle. Returns phi from -pi to pi.
229
231 {
232  return fX == 0.0 && fY == 0.0 ? 0.0 : TMath::ATan2(fY,fX);
233 }
234
235 ////////////////////////////////////////////////////////////////////////////////
236 /// Return the polar angle
237
239 {
240  return fX == 0.0 && fY == 0.0 && fZ == 0.0 ? 0.0 : TMath::ATan2(Perp(),fZ);
241 }
242
243 ////////////////////////////////////////////////////////////////////////////////
244 /// Return unit vector parallel to this.
245
247 {
248  Double_t tot2 = Mag2();
249  Double_t tot = (tot2 > 0) ? 1.0/TMath::Sqrt(tot2) : 1.0;
250  TVector3 p(fX*tot,fY*tot,fZ*tot);
251  return p;
252 }
253
254 ////////////////////////////////////////////////////////////////////////////////
255 /// Rotate vector around X.
256
258  Double_t s = TMath::Sin(angle);
259  Double_t c = TMath::Cos(angle);
260  Double_t yy = fY;
261  fY = c*yy - s*fZ;
262  fZ = s*yy + c*fZ;
263 }
264
265 ////////////////////////////////////////////////////////////////////////////////
266 /// Rotate vector around Y.
267
269  Double_t s = TMath::Sin(angle);
270  Double_t c = TMath::Cos(angle);
271  Double_t zz = fZ;
272  fZ = c*zz - s*fX;
273  fX = s*zz + c*fX;
274 }
275
276 ////////////////////////////////////////////////////////////////////////////////
277 /// Rotate vector around Z.
278
280  Double_t s = TMath::Sin(angle);
281  Double_t c = TMath::Cos(angle);
282  Double_t xx = fX;
283  fX = c*xx - s*fY;
284  fY = s*xx + c*fY;
285 }
286
287 ////////////////////////////////////////////////////////////////////////////////
288 /// Rotate vector.
289
290 void TVector3::Rotate(Double_t angle, const TVector3 & axis){
291  TRotation trans;
292  trans.Rotate(angle, axis);
293  operator*=(trans);
294 }
295
296 ////////////////////////////////////////////////////////////////////////////////
297 /// NewUzVector must be normalized !
298
299 void TVector3::RotateUz(const TVector3& NewUzVector) {
300  Double_t u1 = NewUzVector.fX;
301  Double_t u2 = NewUzVector.fY;
302  Double_t u3 = NewUzVector.fZ;
303  Double_t up = u1*u1 + u2*u2;
304
305  if (up) {
306  up = TMath::Sqrt(up);
307  Double_t px = fX, py = fY, pz = fZ;
308  fX = (u1*u3*px - u2*py + u1*up*pz)/up;
309  fY = (u2*u3*px + u1*py + u2*up*pz)/up;
310  fZ = (u3*u3*px - px + u3*up*pz)/up;
311  } else if (u3 < 0.) { fX = -fX; fZ = -fZ; } // phi=0 teta=pi
312  else {};
313 }
314
315 ////////////////////////////////////////////////////////////////////////////////
316 /// Double_t m = Mag();
317 /// return 0.5*log( (m+fZ)/(m-fZ) );
318 /// guard against Pt=0
319
321  double cosTheta = CosTheta();
322  if (cosTheta*cosTheta < 1) return -0.5* TMath::Log( (1.0-cosTheta)/(1.0+cosTheta) );
323  if (fZ == 0) return 0;
324  //Warning("PseudoRapidity","transvers momentum = 0! return +/- 10e10");
325  if (fZ > 0) return 10e10;
326  else return -10e10;
327 }
328
329 ////////////////////////////////////////////////////////////////////////////////
330 /// Set Pt, Eta and Phi
331
333  Double_t apt = TMath::Abs(pt);
334  SetXYZ(apt*TMath::Cos(phi), apt*TMath::Sin(phi), apt/TMath::Tan(2.0*TMath::ATan(TMath::Exp(-eta))) );
335 }
336
337 ////////////////////////////////////////////////////////////////////////////////
338 /// Set Pt, Theta and Phi
339
341  fX = pt * TMath::Cos(phi);
342  fY = pt * TMath::Sin(phi);
343  Double_t tanTheta = TMath::Tan(theta);
344  fZ = tanTheta ? pt / tanTheta : 0;
345 }
346
347 ////////////////////////////////////////////////////////////////////////////////
348 /// Set theta keeping mag and phi constant (BaBar).
349
351 {
352  Double_t ma = Mag();
353  Double_t ph = Phi();
354  SetX(ma*TMath::Sin(th)*TMath::Cos(ph));
355  SetY(ma*TMath::Sin(th)*TMath::Sin(ph));
356  SetZ(ma*TMath::Cos(th));
357 }
358
359 ////////////////////////////////////////////////////////////////////////////////
360 /// Set phi keeping mag and theta constant (BaBar).
361
363 {
364  Double_t xy = Perp();
365  SetX(xy*TMath::Cos(ph));
366  SetY(xy*TMath::Sin(ph));
367 }
368
369 ////////////////////////////////////////////////////////////////////////////////
370 /// Return deltaR with respect to v.
371
373 {
374  Double_t deta = Eta()-v.Eta();
375  Double_t dphi = TVector2::Phi_mpi_pi(Phi()-v.Phi());
376  return TMath::Sqrt( deta*deta+dphi*dphi );
377 }
378
379 ////////////////////////////////////////////////////////////////////////////////
380 /// Setter with mag, theta, phi.
381
383 {
384  Double_t amag = TMath::Abs(mag);
385  fX = amag * TMath::Sin(theta) * TMath::Cos(phi);
386  fY = amag * TMath::Sin(theta) * TMath::Sin(phi);
387  fZ = amag * TMath::Cos(theta);
388 }
389
390 ////////////////////////////////////////////////////////////////////////////////
391 /// Stream an object of class TVector3.
392
393 void TVector3::Streamer(TBuffer &R__b)
394 {
396  UInt_t R__s, R__c;
397  Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
398  if (R__v > 2) {
399  R__b.ReadClassBuffer(TVector3::Class(), this, R__v, R__s, R__c);
400  return;
401  }
402  //====process old versions before automatic schema evolution
403  if (R__v < 2) TObject::Streamer(R__b);
404  R__b >> fX;
405  R__b >> fY;
406  R__b >> fZ;
407  R__b.CheckByteCount(R__s, R__c, TVector3::IsA());
408  //====end of old versions
409
410  } else {
411  R__b.WriteClassBuffer(TVector3::Class(),this);
412  }
413 }
414
415 ////////////////////////////////////////////////////////////////////////////////
416 /// Operator +
417
419  return TVector3(a.X() + b.X(), a.Y() + b.Y(), a.Z() + b.Z());
420 }
421
422 ////////////////////////////////////////////////////////////////////////////////
423 /// Operator -
424
426  return TVector3(a.X() - b.X(), a.Y() - b.Y(), a.Z() - b.Z());
427 }
428
429 ////////////////////////////////////////////////////////////////////////////////
430 /// Operator *
431
433  return TVector3(a*p.X(), a*p.Y(), a*p.Z());
434 }
435
436 ////////////////////////////////////////////////////////////////////////////////
437 /// Operator *
438
440  return TVector3(a*p.X(), a*p.Y(), a*p.Z());
441 }
442
443 ////////////////////////////////////////////////////////////////////////////////
445  return a.Dot(b);
446 }
447
448 ////////////////////////////////////////////////////////////////////////////////
449 /// Operator *
450
451 TVector3 operator * (const TMatrix & m, const TVector3 & v ) {
452  return TVector3( m(0,0)*v.X()+m(0,1)*v.Y()+m(0,2)*v.Z(),
453  m(1,0)*v.X()+m(1,1)*v.Y()+m(1,2)*v.Z(),
454  m(2,0)*v.X()+m(2,1)*v.Y()+m(2,2)*v.Z());
455 }
456
457 ////////////////////////////////////////////////////////////////////////////////
458 /// Print vector parameters.
459
461 {
462  Printf("%s %s (x,y,z)=(%f,%f,%f) (rho,theta,phi)=(%f,%f,%f)",GetName(),GetTitle(),X(),Y(),Z(),
464 }
Double_t X() const
Definition: TVector3.h:216
Double_t Dot(const TVector3 &) const
Definition: TVector3.h:331
Definition: TBuffer.h:83
void RotateUz(const TVector3 &)
NewUzVector must be normalized !
Definition: TVector3.cxx:299
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
TVector3 operator*(const TVector3 &p, Double_t a)
Operator *.
Definition: TVector3.cxx:432
auto * m
Definition: textangle.C:8
Double_t Log(Double_t x)
Definition: TMath.h:759
void SetY(Double_t)
Definition: TVector3.h:224
short Version_t
Definition: RtypesCore.h:61
const char Option_t
Definition: RtypesCore.h:62
Double_t CosTheta() const
Definition: TVector3.h:371
Buffer base class used for serializing objects.
Definition: TBuffer.h:40
virtual Int_t CheckByteCount(UInt_t startpos, UInt_t bcnt, const TClass *clss)=0
Double_t Eta() const
Definition: TVector3.h:400
Double_t Mag2() const
Definition: TVector3.h:339
Double_t fY
Definition: TVector3.h:185
void RotateX(Double_t)
Rotate vector around X.
Definition: TVector3.cxx:257
Double_t Angle(const TVector3 &) const
Return the angle w.r.t. another 3-vector.
Definition: TVector3.cxx:197
Short_t Abs(Short_t d)
Definition: TMathBase.h:108
Double_t Mag() const
Definition: TVector3.h:86
TMatrixT.
Definition: TMatrixDfwd.h:22
TVector3 Unit() const
Return unit vector parallel to this.
Definition: TVector3.cxx:246
TVector3 operator-() const
Definition: TVector3.h:320
Double_t fZ
Definition: TVector3.h:185
void Class()
Definition: Class.C:29
TVector3 & operator*=(Double_t)
Definition: TVector3.h:324
Double_t Y() const
Definition: TVector3.h:217
void Rotate(Double_t, const TVector3 &)
Rotate vector.
Definition: TVector3.cxx:290
static Double_t Phi_mpi_pi(Double_t x)
Returns phi angle in the interval [-PI,PI)
Definition: TVector2.cxx:101
void SetXYZ(Double_t x, Double_t y, Double_t z)
Definition: TVector3.h:227
Double_t ATan2(Double_t, Double_t)
Definition: TMath.h:678
TRotation & Rotate(Double_t, const TVector3 &)
Rotate along an axis.
Definition: TRotation.cxx:324
Double_t Perp() const
Return the transverse component (R in cylindrical coordinate system)
Definition: TVector3.cxx:213
void RotateY(Double_t)
Rotate vector around Y.
Definition: TVector3.cxx:268
TVector3 is a general three vector class, which can be used for the description of different vectors ...
Definition: TVector3.h:22
Double_t Z() const
Definition: TVector3.h:218
The TRotation class describes a rotation of objects of the TVector3 class.
Definition: TRotation.h:20
TPaveText * pt
void SetTheta(Double_t)
Set theta keeping mag and phi constant (BaBar).
Definition: TVector3.cxx:350
SVector< double, 2 > v
Definition: Dict.h:5
XPoint xy[kMAXMK]
Definition: TGX11.cxx:122
auto * a
Definition: textangle.C:12
Double_t Theta() const
Return the polar angle.
Definition: TVector3.cxx:238
unsigned int UInt_t
Definition: RtypesCore.h:42
void Print(Option_t *option="") const
Print vector parameters.
Definition: TVector3.cxx:460
Double_t ACos(Double_t)
Definition: TMath.h:667
Double_t PseudoRapidity() const
Double_t m = Mag(); return 0.5*log( (m+fZ)/(m-fZ) ); guard against Pt=0.
Definition: TVector3.cxx:320
#define Printf
Definition: TGeoToOCC.h:18
Double_t Cos(Double_t)
Definition: TMath.h:640
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
Double_t Exp(Double_t x)
Definition: TMath.h:726
Double_t fX
Definition: TVector3.h:185
#define ClassImp(name)
Definition: Rtypes.h:359
double Double_t
Definition: RtypesCore.h:55
void SetZ(Double_t)
Definition: TVector3.h:225
TVector3 & Transform(const TRotation &)
Transform this vector with a TRotation.
Definition: TVector3.cxx:190
static constexpr double s
void RotateZ(Double_t)
Rotate vector around Z.
Definition: TVector3.cxx:279
void SetPhi(Double_t)
Set phi keeping mag and theta constant (BaBar).
Definition: TVector3.cxx:362
Conversion from radian to degree: .
Definition: TMath.h:74
virtual const char * GetTitle() const
Returns title of object.
Definition: TObject.cxx:401
Double_t DeltaR(const TVector3 &) const
Return deltaR with respect to v.
Definition: TVector3.cxx:372
Double_t Phi() const
Return the azimuth angle. Returns phi from -pi to pi.
Definition: TVector3.cxx:230
TVector3()
Constructors.
Definition: TVector3.h:247
Double_t Perp2() const
Definition: TVector3.h:353
Double_t Sin(Double_t)
Definition: TMath.h:636
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
void SetX(Double_t)
Definition: TVector3.h:223
#define c(i)
Definition: RSha256.hxx:101
Double_t Sqrt(Double_t x)
Definition: TMath.h:690
virtual const char * GetName() const
Returns name of object.
Definition: TObject.cxx:357
TVector3 operator+(const TVector3 &a, const TVector3 &b)
Operator +.
Definition: TVector3.cxx:418
void SetPtThetaPhi(Double_t pt, Double_t theta, Double_t phi)
Set Pt, Theta and Phi.
Definition: TVector3.cxx:340
float * q
Definition: THbookFile.cxx:87
void SetMagThetaPhi(Double_t mag, Double_t theta, Double_t phi)
Setter with mag, theta, phi.
Definition: TVector3.cxx:382
Double_t Tan(Double_t)
Definition: TMath.h:644
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
void SetPtEtaPhi(Double_t pt, Double_t eta, Double_t phi)
Set Pt, Eta and Phi.
Definition: TVector3.cxx:332
Double_t ATan(Double_t)
Definition: TMath.h:674