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