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 */
53
55
56public:
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 */
73
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 */
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 );
109
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
133
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[0], rhs.fM[1], rhs.fM[2], rhs.fM[3],
154 rhs.fM[4], rhs.fM[5], rhs.fM[6], rhs.fM[7],
155 rhs.fM[8], rhs.fM[9], rhs.fM[10], rhs.fM[11],
156 rhs.fM[12], rhs.fM[13], rhs.fM[14], rhs.fM[15] );
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 */
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 ==============
213
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
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
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>
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 }
396
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
436
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; }
443
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
457private:
458
460
461}; // LorentzRotation
462
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
471std::ostream & operator<< (std::ostream & os, const LorentzRotation & r);
472
473// ============================================ vetted to here ============
474
475#ifdef NOTYET
476/**
477 Distance between two Lorentz rotations
478 */
479template <class R>
480inline
481typename Rotation3D::Scalar
482Distance ( 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 */
ROOT::R::TRInterface & r
Definition Object.C:4
#define b(i)
Definition RSha256.hxx:100
#define a(i)
Definition RSha256.hxx:99
#define e(i)
Definition RSha256.hxx:103
XPoint xy[kMAXMK]
Definition TGX11.cxx:123
float * q
typedef void((*Func_t)())
AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotat...
Definition AxisAngle.h:41
Class representing a Lorentz Boost along the X axis, by beta.
Definition BoostX.h:37
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:37
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:37
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:46
EulerAngles class describing rotation as three angles (Euler Angles).
Definition EulerAngles.h:43
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 ...
Scalar Px() const
spatial X component
Class describing a 4D cartesian coordinate system (x, y, z, t coordinates) or momentum-energy vectors...
Definition PxPyPzE4D.h:42
Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k).
Definition Quaternion.h:47
Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix.
Definition Rotation3D.h:65
Rotation class representing a 3D rotation about the X axis by the angle of rotation.
Definition RotationX.h:43
Rotation class representing a 3D rotation about the Y axis by the angle of rotation.
Definition RotationY.h:43
Rotation class representing a 3D rotation about the Z axis by the angle of rotation.
Definition RotationZ.h:43
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:320
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
auto * m
Definition textangle.C:8
auto * tt
Definition textangle.C:16