 ROOT   Reference Guide LorentzRotation.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 ROOT MathLib Team *
7  * *
8  * *
9  **********************************************************************/
10
11 // Header file for LorentzRotation
12 //
13 // Created by: Mark Fischler Mon Aug 8 2005
14 //
15 // Last update: $Id$
16 //
17 #ifndef ROOT_Math_GenVector_LorentzRotation
18 #define ROOT_Math_GenVector_LorentzRotation 1
19
21
24
32 #include "Math/GenVector/Boost.h"
33 #include "Math/GenVector/BoostX.h"
34 #include "Math/GenVector/BoostY.h"
35 #include "Math/GenVector/BoostZ.h"
36
37 namespace ROOT {
38
39  namespace Math {
40
41 //__________________________________________________________________________________________
42  /**
43  Lorentz transformation class with the (4D) transformation represented by
44  a 4x4 orthosymplectic matrix.
46  specialized Lorentz transformations.
47  Also, the 3-D rotation classes can be considered to be special Lorentz
48  transformations which do not mix space and time components.
49
50  @ingroup GenVector
51
52  */
53
54 class LorentzRotation {
55
56 public:
57
58  typedef double Scalar;
59
61  kXX = 0, kXY = 1, kXZ = 2, kXT = 3
62  , kYX = 4, kYY = 5, kYZ = 6, kYT = 7
63  , kZX = 8, kZY = 9, kZZ = 10, kZT = 11
64  , kTX = 12, kTY = 13, kTZ = 14, kTT = 15
65  };
66
67  // ========== Constructors and Assignment =====================
68
69  /**
70  Default constructor (identity transformation)
71  */
74  /**
75  Construct given a pair of pointers or iterators defining the
76  beginning and end of an array of sixteen Scalars
77  */
78  template<class IT>
79  LorentzRotation(IT begin, IT end) { SetComponents(begin,end); }
80
81  // The compiler-generated and dtor are OK but we have implementwd the copy-ctor and
82  // assignment operators since we have a template assignment
83
84  /**
85  Copy constructor
86  */
87  LorentzRotation( LorentzRotation const & r ) {
88  *this = r;
89  }
90
91  /**
92  Construct from a pure boost
93  */
94  explicit LorentzRotation( Boost const & b ) { b.GetLorentzRotation( fM+0 ); }
95  explicit LorentzRotation( BoostX const & bx ) { bx.GetLorentzRotation( fM+0 ); }
96  explicit LorentzRotation( BoostY const & by ) { by.GetLorentzRotation( fM+0 ); }
97  explicit LorentzRotation( BoostZ const & bz ) { bz.GetLorentzRotation( fM+0 ); }
98
99  /**
100  Construct from a 3-D rotation (no space-time mixing)
101  */
102  explicit LorentzRotation( Rotation3D const & r );
103  explicit LorentzRotation( AxisAngle const & a );
104  explicit LorentzRotation( EulerAngles const & e );
105  explicit LorentzRotation( Quaternion const & q );
106  explicit LorentzRotation( RotationX const & r );
107  explicit LorentzRotation( RotationY const & r );
108  explicit LorentzRotation( RotationZ const & r );
110  /**
111  Construct from a linear algebra matrix of size at least 4x4,
112  which must support operator()(i,j) to obtain elements (0,3) thru (3,3).
113  Precondition: The matrix is assumed to be orthosymplectic. NO checking
115  Note: (0,0) refers to the XX component; (3,3) refers to the TT component.
116  */
117  template<class ForeignMatrix>
118  explicit LorentzRotation(const ForeignMatrix & m) { SetComponents(m); }
119
120  /**
121  Construct from four orthosymplectic vectors (which must have methods
122  x(), y(), z() and t()) which will be used as the columns of the Lorentz
123  rotation matrix. The orthosymplectic conditions will be checked, and
124  values adjusted so that the result will always be a good Lorentz rotation
125  matrix.
126  */
127  template<class Foreign4Vector>
128  LorentzRotation(const Foreign4Vector& v1,
129  const Foreign4Vector& v2,
130  const Foreign4Vector& v3,
131  const Foreign4Vector& v4 ) { SetComponents(v1, v2, v3, v4); }
132
134  /**
135  Raw constructor from sixteen Scalar components (without any checking)
136  */
138  Scalar yx, Scalar yy, Scalar yz, Scalar yt,
139  Scalar zx, Scalar zy, Scalar zz, Scalar zt,
140  Scalar tx, Scalar ty, Scalar tz, Scalar tt)
141  {
142  SetComponents (xx, xy, xz, xt,
143  yx, yy, yz, yt,
144  zx, zy, zz, zt,
145  tx, ty, tz, tt);
146  }
147
148  /**
149  Assign from another LorentzRotation
150  */
152  operator=( LorentzRotation const & rhs ) {
153  SetComponents( rhs.fM, rhs.fM, rhs.fM, rhs.fM,
154  rhs.fM, rhs.fM, rhs.fM, rhs.fM,
155  rhs.fM, rhs.fM, rhs.fM, rhs.fM,
156  rhs.fM, rhs.fM, rhs.fM, rhs.fM );
157  return *this;
158  }
159
160  /**
161  Assign from a pure boost
162  */
164  operator=( Boost const & b ) { return operator=(LorentzRotation(b)); }
166  operator=( BoostX const & b ) { return operator=(LorentzRotation(b)); }
168  operator=( BoostY const & b ) { return operator=(LorentzRotation(b)); }
170  operator=( BoostZ const & b ) { return operator=(LorentzRotation(b)); }
171
172  /**
173  Assign from a 3-D rotation
174  */
176  operator=( Rotation3D const & r ) { return operator=(LorentzRotation(r)); }
178  operator=( AxisAngle const & a ) { return operator=(LorentzRotation(a)); }
180  operator=( EulerAngles const & e ) { return operator=(LorentzRotation(e)); }
182  operator=( Quaternion const & q ) { return operator=(LorentzRotation(q)); }
184  operator=( RotationZ const & r ) { return operator=(LorentzRotation(r)); }
186  operator=( RotationY const & r ) { return operator=(LorentzRotation(r)); }
188  operator=( RotationX const & r ) { return operator=(LorentzRotation(r)); }
189
190  /**
191  Assign from a linear algebra matrix of size at least 4x4,
192  which must support operator()(i,j) to obtain elements (0,3) thru (3,3).
193  Precondition: The matrix is assumed to be orthosymplectic. NO checking
195  */
196  template<class ForeignMatrix>
198  operator=(const ForeignMatrix & m) {
199  SetComponents( m(0,0), m(0,1), m(0,2), m(0,3),
200  m(1,0), m(1,1), m(1,2), m(1,3),
201  m(2,0), m(2,1), m(2,2), m(2,3),
202  m(3,0), m(3,1), m(3,2), m(3,3) );
203  return *this;
204  }
205
206  /**
207  Re-adjust components to eliminate small deviations from a perfect
208  orthosyplectic matrix.
209  */
210  void Rectify();
211
212  // ======== Components ==============
214  /**
215  Set components from four orthosymplectic vectors (which must have methods
216  x(), y(), z(), and t()) which will be used as the columns of the
217  Lorentz rotation matrix. The values will be adjusted
218  so that the result will always be a good Lorentz rotation matrix.
219  */
220  template<class Foreign4Vector>
221  void
222  SetComponents (const Foreign4Vector& v1,
223  const Foreign4Vector& v2,
224  const Foreign4Vector& v3,
225  const Foreign4Vector& v4 ) {
226  fM[kXX]=v1.x(); fM[kXY]=v2.x(); fM[kXZ]=v3.x(); fM[kXT]=v4.x();
227  fM[kYX]=v1.y(); fM[kYY]=v2.y(); fM[kYZ]=v3.y(); fM[kYT]=v4.y();
228  fM[kZX]=v1.z(); fM[kZY]=v2.z(); fM[kZZ]=v3.z(); fM[kZT]=v4.z();
229  fM[kTX]=v1.t(); fM[kTY]=v2.t(); fM[kTZ]=v3.t(); fM[kTT]=v4.t();
230  Rectify();
231  }
232
233  /**
234  Get components into four 4-vectors which will be the (orthosymplectic)
235  columns of the rotation matrix. (The 4-vector class must have a
236  constructor from 4 Scalars used as x, y, z, t)
237  */
238  template<class Foreign4Vector>
239  void
240  GetComponents ( Foreign4Vector& v1,
241  Foreign4Vector& v2,
242  Foreign4Vector& v3,
243  Foreign4Vector& v4 ) const {
244  v1 = Foreign4Vector ( fM[kXX], fM[kYX], fM[kZX], fM[kTX] );
245  v2 = Foreign4Vector ( fM[kXY], fM[kYY], fM[kZY], fM[kTY] );
246  v3 = Foreign4Vector ( fM[kXZ], fM[kYZ], fM[kZZ], fM[kTZ] );
247  v4 = Foreign4Vector ( fM[kXT], fM[kYT], fM[kZT], fM[kTT] );
248  }
249
250  /**
251  Set the 16 matrix components given an iterator to the start of
252  the desired data, and another to the end (16 past start).
253  */
254  template<class IT>
255  void SetComponents(IT begin, IT end) {
256  for (int i = 0; i <16; ++i) {
257  fM[i] = *begin;
258  ++begin;
259  }
260  (void)end;
261  assert (end==begin);
262  }
263
264  /**
265  Get the 16 matrix components into data specified by an iterator begin
266  and another to the end of the desired data (16 past start).
267  */
268  template<class IT>
269  void GetComponents(IT begin, IT end) const {
270  for (int i = 0; i <16; ++i) {
271  *begin = fM[i];
272  ++begin;
273  }
274  (void)end;
275  assert (end==begin);
276  }
277
278  /**
279  Get the 16 matrix components into data specified by an iterator begin
280  */
281  template<class IT>
282  void GetComponents(IT begin) const {
283  std::copy ( fM+0, fM+16, begin );
284  }
285
286  /**
287  Set components from a linear algebra matrix of size at least 4x4,
288  which must support operator()(i,j) to obtain elements (0,0) thru (3,3).
289  Precondition: The matrix is assumed to be orthosymplectic. NO checking
291  */
292  template<class ForeignMatrix>
293  void
294  SetRotationMatrix (const ForeignMatrix & m) {
295  fM[kXX]=m(0,0); fM[kXY]=m(0,1); fM[kXZ]=m(0,2); fM[kXT]=m(0,3);
296  fM[kYX]=m(1,0); fM[kYY]=m(1,1); fM[kYZ]=m(1,2); fM[kYT]=m(1,3);
297  fM[kZX]=m(2,0); fM[kZY]=m(2,1); fM[kZZ]=m(2,2); fM[kZT]=m(2,3);
298  fM[kTX]=m(3,0); fM[kTY]=m(3,1); fM[kTZ]=m(3,2); fM[kTT]=m(3,3);
299  }
300
301  /**
302  Get components into a linear algebra matrix of size at least 4x4,
304  (0,0) thru (3,3).
305  */
306  template<class ForeignMatrix>
307  void
308  GetRotationMatrix (ForeignMatrix & m) const {
309  m(0,0)=fM[kXX]; m(0,1)=fM[kXY]; m(0,2)=fM[kXZ]; m(0,3)=fM[kXT];
310  m(1,0)=fM[kYX]; m(1,1)=fM[kYY]; m(1,2)=fM[kYZ]; m(1,3)=fM[kYT];
311  m(2,0)=fM[kZX]; m(2,1)=fM[kZY]; m(2,2)=fM[kZZ]; m(2,3)=fM[kZT];
312  m(3,0)=fM[kTX]; m(3,1)=fM[kTY]; m(3,2)=fM[kTZ]; m(3,3)=fM[kTT];
313  }
314
315  /**
316  Set the components from sixteen scalars -- UNCHECKED for orthosymplectic
317  */
318  void
319  SetComponents (Scalar xx, Scalar xy, Scalar xz, Scalar xt,
320  Scalar yx, Scalar yy, Scalar yz, Scalar yt,
321  Scalar zx, Scalar zy, Scalar zz, Scalar zt,
322  Scalar tx, Scalar ty, Scalar tz, Scalar tt) {
323  fM[kXX]=xx; fM[kXY]=xy; fM[kXZ]=xz; fM[kXT]=xt;
324  fM[kYX]=yx; fM[kYY]=yy; fM[kYZ]=yz; fM[kYT]=yt;
325  fM[kZX]=zx; fM[kZY]=zy; fM[kZZ]=zz; fM[kZT]=zt;
326  fM[kTX]=tx; fM[kTY]=ty; fM[kTZ]=tz; fM[kTT]=tt;
327  }
328
329  /**
330  Get the sixteen components into sixteen scalars
331  */
332  void
333  GetComponents (Scalar &xx, Scalar &xy, Scalar &xz, Scalar &xt,
334  Scalar &yx, Scalar &yy, Scalar &yz, Scalar &yt,
335  Scalar &zx, Scalar &zy, Scalar &zz, Scalar &zt,
336  Scalar &tx, Scalar &ty, Scalar &tz, Scalar &tt) const {
337  xx=fM[kXX]; xy=fM[kXY]; xz=fM[kXZ]; xt=fM[kXT];
338  yx=fM[kYX]; yy=fM[kYY]; yz=fM[kYZ]; yt=fM[kYT];
339  zx=fM[kZX]; zy=fM[kZY]; zz=fM[kZZ]; zt=fM[kZT];
340  tx=fM[kTX]; ty=fM[kTY]; tz=fM[kTZ]; tt=fM[kTT];
341  }
342
343  // =========== operations ==============
344
345  /**
346  Lorentz transformation operation on a Minkowski ('Cartesian')
347  LorentzVector
348  */
351  Scalar x = v.Px();
352  Scalar y = v.Py();
353  Scalar z = v.Pz();
354  Scalar t = v.E();
356  ( fM[kXX]*x + fM[kXY]*y + fM[kXZ]*z + fM[kXT]*t
357  , fM[kYX]*x + fM[kYY]*y + fM[kYZ]*z + fM[kYT]*t
358  , fM[kZX]*x + fM[kZY]*y + fM[kZZ]*z + fM[kZT]*t
359  , fM[kTX]*x + fM[kTY]*y + fM[kTZ]*z + fM[kTT]*t );
360  }
361
362  /**
363  Lorentz transformation operation on a LorentzVector in any
364  coordinate system
365  */
366  template <class CoordSystem>
368  operator() (const LorentzVector<CoordSystem> & v) const {
371  return LorentzVector<CoordSystem> ( r_xyzt );
372  }
373
374  /**
375  Lorentz transformation operation on an arbitrary 4-vector v.
376  Preconditions: v must implement methods x(), y(), z(), and t()
377  and the arbitrary vector type must have a constructor taking (x,y,z,t)
378  */
379  template <class Foreign4Vector>
380  Foreign4Vector
381  operator() (const Foreign4Vector & v) const {
384  return Foreign4Vector ( r_xyzt.X(), r_xyzt.Y(), r_xyzt.Z(), r_xyzt.T() );
385  }
386
387  /**
388  Overload operator * for rotation on a vector
389  */
390  template <class A4Vector>
391  inline
392  A4Vector operator* (const A4Vector & v) const
393  {
394  return operator()(v);
395  }
397  /**
398  Invert a Lorentz rotation in place
399  */
400  void Invert();
401
402  /**
403  Return inverse of a rotation
404  */
405  LorentzRotation Inverse() const;
406
407  // ========= Multi-Rotation Operations ===============
408
409  /**
410  Multiply (combine) this Lorentz rotation by another LorentzRotation
411  */
413
414  //#ifdef TODO_LATER
415  /**
416  Multiply (combine) this Lorentz rotation by a pure Lorentz boost
417  */
418  //TODO: implement directly in a more efficient way. Now are implemented
419  // going through another LorentzRotation
420  LorentzRotation operator * (const Boost & b) const { LorentzRotation tmp(b); return (*this)*tmp; }
421  LorentzRotation operator * (const BoostX & b) const { LorentzRotation tmp(b); return (*this)*tmp; }
422  LorentzRotation operator * (const BoostY & b) const { LorentzRotation tmp(b); return (*this)*tmp; }
423  LorentzRotation operator * (const BoostZ & b) const { LorentzRotation tmp(b); return (*this)*tmp; }
424
425  /**
426  Multiply (combine) this Lorentz rotation by a 3-D Rotation
427  */
428  LorentzRotation operator * (const Rotation3D & r) const { LorentzRotation tmp(r); return (*this)*tmp; }
429  LorentzRotation operator * (const AxisAngle & a) const { LorentzRotation tmp(a); return (*this)*tmp; }
430  LorentzRotation operator * (const EulerAngles & e) const { LorentzRotation tmp(e); return (*this)*tmp; }
431  LorentzRotation operator * (const Quaternion & q) const { LorentzRotation tmp(q); return (*this)*tmp; }
432  LorentzRotation operator * (const RotationX & rx) const { LorentzRotation tmp(rx); return (*this)*tmp; }
433  LorentzRotation operator * (const RotationY & ry) const { LorentzRotation tmp(ry); return (*this)*tmp; }
434  LorentzRotation operator * (const RotationZ & rz) const { LorentzRotation tmp(rz); return (*this)*tmp; }
435  //#endif
437  /**
438  Post-Multiply (on right) by another LorentzRotation, Boost, or
439  rotation : T = T*R
440  */
441  template <class R>
442  LorentzRotation & operator *= (const R & r) { return *this = (*this)*r; }
444  /**
445  Equality/inequality operators
446  */
447  bool operator == (const LorentzRotation & rhs) const {
448  for (unsigned int i=0; i < 16; ++i) {
449  if( fM[i] != rhs.fM[i] ) return false;
450  }
451  return true;
452  }
453  bool operator != (const LorentzRotation & rhs) const {
454  return ! operator==(rhs);
455  }
456
457 private:
458
459  Scalar fM;
460
461 }; // LorentzRotation
463 // ============ Class LorentzRotation ends here ============
464
465
466 /**
467  Stream Output and Input
468  */
469  // TODO - I/O should be put in the manipulator form
470
471 std::ostream & operator<< (std::ostream & os, const LorentzRotation & r);
472
473 // ============================================ vetted to here ============
475 #ifdef NOTYET
476 /**
477  Distance between two Lorentz rotations
478  */
479 template <class R>
480 inline
481 typename Rotation3D::Scalar
482 Distance ( const Rotation3D& r1, const R & r2) {return gv_detail::dist(r1,r2);}
483 #endif
484
485 } //namespace Math
486 } //namespace ROOT
487
488
489
490
491
492
493
494 #endif /* ROOT_Math_GenVector_LorentzRotation */
RotationXfwd.h
ROOT::Math::LorentzRotation::kXY
@ kXY
Definition: LorentzRotation.h:76
ROOT::Math::LorentzVector::Y
Scalar Y() const
Definition: LorentzVector.h:285
m
auto * m
Definition: textangle.C:8
ROOT::Math::LorentzRotation::kYT
@ kYT
Definition: LorentzRotation.h:77
ROOT::Math::LorentzRotation::operator==
bool operator==(const LorentzRotation &rhs) const
Equality/inequality operators.
Definition: LorentzRotation.h:462
ROOT::Math::LorentzRotation::kTX
@ kTX
Definition: LorentzRotation.h:79
ROOT::Math::AxisAngle
AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotat...
Definition: AxisAngle.h:51
tt
auto * tt
Definition: textangle.C:16
e
#define e(i)
Definition: RSha256.hxx:121
Rotation3Dfwd.h
ROOT::Math::LorentzRotation::operator()
LorentzVector< ROOT::Math::PxPyPzE4D< double > > operator()(const LorentzVector< ROOT::Math::PxPyPzE4D< double > > &v) const
Lorentz transformation operation on a Minkowski ('Cartesian') LorentzVector.
Definition: LorentzRotation.h:365
ROOT::Math::LorentzRotation::SetRotationMatrix
void SetRotationMatrix(const ForeignMatrix &m)
Set components from a linear algebra matrix of size at least 4x4, which must support operator()(i,...
Definition: LorentzRotation.h:309
ROOT::Math::BoostY
Class representing a Lorentz Boost along the Y axis, by beta.
Definition: BoostY.h:47
ROOT::Math::LorentzRotation::operator=
LorentzRotation & operator=(LorentzRotation const &rhs)
Assign from another LorentzRotation.
Definition: LorentzRotation.h:167
ROOT::Math::LorentzRotation::kZZ
@ kZZ
Definition: LorentzRotation.h:78
r
ROOT::R::TRInterface & r
Definition: Object.C:4
ROOT::Math::LorentzRotation::kYZ
@ kYZ
Definition: LorentzRotation.h:77
ROOT::Math::LorentzRotation::kZX
@ kZX
Definition: LorentzRotation.h:78
ROOT::Math::RotationZ
Rotation class representing a 3D rotation about the Z axis by the angle of rotation.
Definition: RotationZ.h:53
ROOT::Math::LorentzRotation::kXX
@ kXX
Definition: LorentzRotation.h:76
ROOT::Math::Rotation3D
Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix.
Definition: Rotation3D.h:75
RotationYfwd.h
ROOT::Math::LorentzRotation::kXT
@ kXT
Definition: LorentzRotation.h:76
ROOT::Math::LorentzRotation::kZT
@ kZT
Definition: LorentzRotation.h:78
x
Double_t x[n]
Definition: legend1.C:17
ROOT::Math::operator<<
std::ostream & operator<<(std::ostream &os, const AxisAngle &a)
Stream Output and Input.
Definition: AxisAngle.cxx:101
ROOT::Math::LorentzRotation::SetComponents
void SetComponents(const Foreign4Vector &v1, const Foreign4Vector &v2, const Foreign4Vector &v3, const Foreign4Vector &v4)
Set components from four orthosymplectic vectors (which must have methods x(), y(),...
Definition: LorentzRotation.h:237
ROOT::Math::BoostX::GetLorentzRotation
void GetLorentzRotation(Scalar r[]) const
Get elements of internal 4x4 symmetric representation, into a data array suitable for direct use as t...
Definition: BoostX.cxx:66
ROOT::Math::BoostZ
Class representing a Lorentz Boost along the Z axis, by beta.
Definition: BoostZ.h:47
ROOT::Math::LorentzRotation::kTZ
@ kTZ
Definition: LorentzRotation.h:79
ROOT::Math::Boost
Lorentz boost class with the (4D) transformation represented internally by a 4x4 orthosymplectic matr...
Definition: Boost.h:56
v
@ v
Definition: rootcling_impl.cxx:3635
b
#define b(i)
Definition: RSha256.hxx:118
ROOT::Math::LorentzRotation::fM
Scalar fM
Definition: LorentzRotation.h:474
q
float * q
Definition: THbookFile.cxx:89
xy
XPoint xy[kMAXMK]
Definition: TGX11.cxx:123
ROOT::Math::LorentzRotation::kXZ
@ kXZ
Definition: LorentzRotation.h:76
ROOT::Math::LorentzRotation::ELorentzRotationMatrixIndex
ELorentzRotationMatrixIndex
Definition: LorentzRotation.h:75
R
#define R(a, b, c, d, e, f, g, h, i)
Definition: RSha256.hxx:128
ROOT::Math::LorentzRotation::operator()
LorentzVector< CoordSystem > operator()(const LorentzVector< CoordSystem > &v) const
Lorentz transformation operation on a LorentzVector in any coordinate system.
Definition: LorentzRotation.h:383
ROOT::Math::gv_detail::dist
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:63
Boost.h
ROOT::Math::LorentzRotation::operator*=
LorentzRotation & operator*=(const R &r)
Post-Multiply (on right) by another LorentzRotation, Boost, or rotation : T = T*R.
Definition: LorentzRotation.h:457
ROOT::Math::LorentzRotation::kTY
@ kTY
Definition: LorentzRotation.h:79
ROOT::Math::LorentzRotation::Scalar
double Scalar
Definition: LorentzRotation.h:73
AxisAnglefwd.h
ROOT::Math::LorentzRotation::kYY
@ kYY
Definition: LorentzRotation.h:77
a
auto * a
Definition: textangle.C:12
LorentzRotationfwd.h
ROOT::Math::Rotation3D::Scalar
double Scalar
Definition: Rotation3D.h:84
ROOT::Math::EulerAngles
EulerAngles class describing rotation as three angles (Euler Angles).
Definition: EulerAngles.h:53
ROOT::Math::LorentzVector::X
Scalar X() const
Definition: LorentzVector.h:280
ROOT::Math::LorentzRotation::GetComponents
void GetComponents(Foreign4Vector &v1, Foreign4Vector &v2, Foreign4Vector &v3, Foreign4Vector &v4) const
Get components into four 4-vectors which will be the (orthosymplectic) columns of the rotation matrix...
Definition: LorentzRotation.h:255
ROOT::Math::LorentzRotation::LorentzRotation
LorentzRotation(IT begin, IT end)
Construct given a pair of pointers or iterators defining the beginning and end of an array of sixteen...
Definition: LorentzRotation.h:94
y
Double_t y[n]
Definition: legend1.C:17
ROOT::Math::RotationX
Rotation class representing a 3D rotation about the X axis by the angle of rotation.
Definition: RotationX.h:53
ROOT::Math::LorentzVector::Z
Scalar Z() const
Definition: LorentzVector.h:290
ROOT::Math::LorentzRotation::operator!=
bool operator!=(const LorentzRotation &rhs) const
Definition: LorentzRotation.h:468
ROOT::Math::LorentzRotation::Invert
void Invert()
Invert a Lorentz rotation in place.
Definition: LorentzRotation.cxx:185
void
typedef void((*Func_t)())
PxPyPzE4D.h
BoostY.h
BoostX.h
ROOT::Math::LorentzRotation::operator*
A4Vector operator*(const A4Vector &v) const
Overload operator * for rotation on a vector.
Definition: LorentzRotation.h:407
ROOT::Math::LorentzVector::T
Scalar T() const
Definition: LorentzVector.h:295
v1
@ v1
Definition: rootcling_impl.cxx:3637
ROOT::Math::LorentzRotation
Lorentz transformation class with the (4D) transformation represented by a 4x4 orthosymplectic matrix...
Definition: LorentzRotation.h:64
ROOT::Math::LorentzRotation::GetRotationMatrix
void GetRotationMatrix(ForeignMatrix &m) const
Get components into a linear algebra matrix of size at least 4x4, which must support operator()(i,...
Definition: LorentzRotation.h:323
ROOT::Math::LorentzRotation::kZY
@ kZY
Definition: LorentzRotation.h:78
BoostZ.h
ROOT::Math::Scalar
Rotation3D::Scalar Scalar
Definition: Rotation3DxAxial.cxx:69
v3
@ v3
Definition: rootcling_impl.cxx:3639
v2
@ v2
Definition: rootcling_impl.cxx:3638
ROOT::Math::LorentzRotation::kYX
@ kYX
Definition: LorentzRotation.h:77
RotationZfwd.h
v4
@ v4
Definition: rootcling_impl.cxx:3640
ROOT::Math::LorentzRotation::Inverse
LorentzRotation Inverse() const
Return inverse of a rotation.
Definition: LorentzRotation.cxx:196
LorentzVector.h
ROOT::Math::LorentzRotation::Rectify
void Rectify()
Re-adjust components to eliminate small deviations from a perfect orthosyplectic matrix.
Definition: LorentzRotation.cxx:132
ROOT::Math::BoostX
Class representing a Lorentz Boost along the X axis, by beta.
Definition: BoostX.h:47
ROOT::Math::LorentzRotation::LorentzRotation
LorentzRotation()
Default constructor (identity transformation)
Definition: LorentzRotation.cxx:46
ROOT::Math::Quaternion
Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k).
Definition: Quaternion.h:57
Quaternionfwd.h
EulerAnglesfwd.h
ROOT::Math::Distance
AxisAngle::Scalar Distance(const AxisAngle &r1, const R &r2)
Distance between two rotations.
Definition: AxisAngle.h:330
ROOT::Math::LorentzRotation::kTT
@ kTT
Definition: LorentzRotation.h:79
ROOT
VSD Structures.
Definition: StringConv.hxx:21
Math
ROOT::Math::PxPyPzE4D
Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors...
Definition: PxPyPzE4D.h:52
ROOT::Math::LorentzVector
Definition: LorentzVector.h:70
ROOT::Math::RotationY
Rotation class representing a 3D rotation about the Y axis by the angle of rotation.
Definition: RotationY.h:53
ROOT::Math::LorentzRotation::LorentzRotation
LorentzRotation(LorentzRotation const &r)
Copy constructor.
Definition: LorentzRotation.h:102