Logo ROOT  
Reference Guide
DisplacementVector3D.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 , LCG ROOT MathLib Team and *
7 * FNAL LCG ROOT MathLib Team *
8 * *
9 * *
10 **********************************************************************/
11
12// Header source file for class DisplacementVector3D
13//
14// Created by: Lorenzo Moneta at Mon May 30 12:21:43 2005
15// Major rewrite: M. FIschler at Wed Jun 8 2005
16//
17// Last update: $Id$
18//
19
20#ifndef ROOT_Math_GenVector_DisplacementVector3D
21#define ROOT_Math_GenVector_DisplacementVector3D 1
22
24
26
28
30
32
33#include <cassert>
34
35
36namespace ROOT {
37
38 namespace Math {
39
40
41//__________________________________________________________________________________________
42 /**
43 Class describing a generic displacement vector in 3 dimensions.
44 This class is templated on the type of Coordinate system.
45 One example is the XYZVector which is a vector based on
46 double precision x,y,z data members by using the
47 ROOT::Math::Cartesian3D<double> Coordinate system.
48 The class is having also an extra template parameter, the coordinate system tag,
49 to be able to identify (tag) vector described in different reference coordinate system,
50 like global or local coordinate systems.
51
52 @ingroup GenVector
53 */
54
55 template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
57
58 public:
59
60 typedef typename CoordSystem::Scalar Scalar;
61 typedef CoordSystem CoordinateType;
63
64 // ------ ctors ------
65
66 /**
67 Default constructor. Construct an empty object with zero values
68 */
70
71
72 /**
73 Construct from three values of type <em>Scalar</em>.
74 In the case of a XYZVector the values are x,y,z
75 In the case of a polar vector they are r,theta, phi
76 */
78 fCoordinates ( a , b, c ) { }
79
80 /**
81 Construct from a displacement vector expressed in different
82 coordinates, or using a different Scalar type, but with same coordinate system tag
83 */
84 template <class OtherCoords>
86 fCoordinates ( v.Coordinates() ) { }
87
88
89 /**
90 Construct from a position vector expressed in different coordinates
91 but with the same coordinate system tag
92 */
93 template <class OtherCoords>
95 fCoordinates ( p.Coordinates() ) { }
96
97
98 /**
99 Construct from a foreign 3D vector type, for example, Hep3Vector
100 Precondition: v must implement methods x(), y() and z()
101 */
102 template <class ForeignVector>
103 explicit DisplacementVector3D( const ForeignVector & v) :
104 fCoordinates ( Cartesian3D<Scalar>( v.x(), v.y(), v.z() ) ) { }
105
106
107#ifdef LATER
108 /**
109 construct from a generic linear algebra vector of at least size 3
110 implementing operator [].
111 \par v LAVector
112 \par index0 index where coordinates starts (typically zero)
113 It works for all Coordinates types,
114 ( x= v[index0] for Cartesian and r=v[index0] for Polar )
115 */
116 template <class LAVector>
117 DisplacementVector3D(const LAVector & v, size_t index0 ) {
118 fCoordinates = CoordSystem ( v[index0], v[index0+1], v[index0+2] );
119 }
120#endif
121
122 // compiler-generated copy ctor and dtor are fine.
123
124 // ------ assignment ------
125
126 /**
127 Assignment operator from a displacement vector of arbitrary type
128 */
129 template <class OtherCoords>
132 fCoordinates = v.Coordinates();
133 return *this;
134 }
135
136 /**
137 Assignment operator from a position vector
138 (not necessarily efficient unless one or the other is Cartesian)
139 */
140 template <class OtherCoords>
142 ( const PositionVector3D<OtherCoords,Tag> & rhs) {
143 SetXYZ(rhs.x(), rhs.y(), rhs.z());
144 return *this;
145 }
146
147
148 /**
149 Assignment from a foreign 3D vector type, for example, Hep3Vector
150 Precondition: v must implement methods x(), y() and z()
151 */
152 template <class ForeignVector>
153 DisplacementVector3D & operator= ( const ForeignVector & v) {
154 SetXYZ( v.x(), v.y(), v.z() );
155 return *this;
156 }
157
158
159#ifdef LATER
160 /**
161 assign from a generic linear algebra vector of at least size 3
162 implementing operator []. This could be also a C array
163 \par v LAVector
164 \par index0 index where coordinates starts (typically zero)
165 It works for all Coordinates types,
166 ( x= v[index0] for Cartesian and r=v[index0] for Polar )
167 */
168 template <class LAVector>
169 DisplacementVector3D & assignFrom(const LAVector & v, size_t index0 = 0) {
170 fCoordinates = CoordSystem ( v[index0], v[index0+1], v[index0+2] );
171 return *this;
172 }
173#endif
174
175 // ------ Set, Get, and access coordinate data ------
176
177 /**
178 Retrieve a copy of the coordinates object
179 */
180 CoordSystem Coordinates() const {
181 return fCoordinates;
182 }
183
184 /**
185 Set internal data based on a C-style array of 3 Scalar numbers
186 */
188 { fCoordinates.SetCoordinates(src); return *this; }
189
190 /**
191 Set internal data based on 3 Scalar numbers
192 */
194 { fCoordinates.SetCoordinates(a, b, c); return *this; }
195
196 /**
197 Set internal data based on 3 Scalars at *begin to *end
198 */
199 template <class IT>
201 { IT a = begin; IT b = ++begin; IT c = ++begin;
202 (void)end;
203 assert (++begin==end);
204 SetCoordinates (*a,*b,*c);
205 return *this;
206 }
207
208 /**
209 get internal data into 3 Scalar numbers
210 */
211 void GetCoordinates( Scalar& a, Scalar& b, Scalar& c ) const
212 { fCoordinates.GetCoordinates(a, b, c); }
213
214 /**
215 get internal data into a C-style array of 3 Scalar numbers
216 */
217 void GetCoordinates( Scalar dest[] ) const
218 { fCoordinates.GetCoordinates(dest); }
219
220 /**
221 get internal data into 3 Scalars at *begin to *end (3 past begin)
222 */
223 template <class IT>
224 void GetCoordinates( IT begin, IT end ) const
225 { IT a = begin; IT b = ++begin; IT c = ++begin;
226 (void)end;
227 assert (++begin==end);
228 GetCoordinates (*a,*b,*c);
229 }
230 /**
231 get internal data into 3 Scalars starting at *begin
232 */
233 template <class IT>
234 void GetCoordinates( IT begin) const {
235 Scalar a = Scalar(0);
236 Scalar b = Scalar(0);
237 Scalar c = Scalar(0);
238 GetCoordinates(a, b, c);
239 *begin++ = a;
240 *begin++ = b;
241 *begin = c;
242 }
243
244 /**
245 set the values of the vector from the cartesian components (x,y,z)
246 (if the vector is held in polar or cylindrical eta coordinates,
247 then (x, y, z) are converted to that form)
248 */
250 fCoordinates.SetXYZ(a, b, c);
251 return *this;
252 }
253
254 // ------------------- Equality -----------------
255
256 /**
257 Exact equality
258 */
259 bool operator==(const DisplacementVector3D & rhs) const {
260 return fCoordinates==rhs.fCoordinates;
261 }
262 bool operator!= (const DisplacementVector3D & rhs) const {
263 return !(operator==(rhs));
264 }
265
266 // ------ Individual element access, in various coordinate systems ------
267
268 /**
269 Cartesian X, converting if necessary from internal coordinate system.
270 */
271 Scalar X() const { return fCoordinates.X(); }
272
273 /**
274 Cartesian Y, converting if necessary from internal coordinate system.
275 */
276 Scalar Y() const { return fCoordinates.Y(); }
277
278 /**
279 Cartesian Z, converting if necessary from internal coordinate system.
280 */
281 Scalar Z() const { return fCoordinates.Z(); }
282
283 /**
284 Polar R, converting if necessary from internal coordinate system.
285 */
286 Scalar R() const { return fCoordinates.R(); }
287
288 /**
289 Polar theta, converting if necessary from internal coordinate system.
290 */
291 Scalar Theta() const { return fCoordinates.Theta(); }
292
293 /**
294 Polar phi, converting if necessary from internal coordinate system.
295 */
296 Scalar Phi() const { return fCoordinates.Phi(); }
297
298 /**
299 Polar eta, converting if necessary from internal coordinate system.
300 */
301 Scalar Eta() const { return fCoordinates.Eta(); }
302
303 /**
304 Cylindrical transverse component rho
305 */
306 Scalar Rho() const { return fCoordinates.Rho(); }
307
308 // ----- Other fundamental properties -----
309
310 /**
311 Magnitute squared ( r^2 in spherical coordinate)
312 */
313 Scalar Mag2() const { return fCoordinates.Mag2();}
314
315 /**
316 Transverse component squared (rho^2 in cylindrical coordinates.
317 */
318 Scalar Perp2() const { return fCoordinates.Perp2();}
319
320 /**
321 return unit vector parallel to this (scalar)
322 */
323 template <typename SCALAR = Scalar, typename std::enable_if<std::is_arithmetic<SCALAR>::value>::type * = nullptr>
325 {
326 const auto tot = R();
327 return tot == 0 ? *this : DisplacementVector3D(*this) / tot;
328 }
329
330 /**
331 return unit vector parallel to this (vector)
332 */
333 template <typename SCALAR = Scalar, typename std::enable_if<!std::is_arithmetic<SCALAR>::value>::type * = nullptr>
335 {
336 SCALAR tot = R();
337 tot(tot == SCALAR(0)) = SCALAR(1);
338 return DisplacementVector3D(*this) / tot;
339 }
340
341 // ------ Setting of individual elements present in coordinate system ------
342
343 /**
344 Change X - Cartesian3D coordinates only
345 */
347
348 /**
349 Change Y - Cartesian3D coordinates only
350 */
352
353 /**
354 Change Z - Cartesian3D coordinates only
355 */
357
358 /**
359 Change R - Polar3D coordinates only
360 */
362
363 /**
364 Change Theta - Polar3D coordinates only
365 */
367
368 /**
369 Change Phi - Polar3D or CylindricalEta3D coordinates
370 */
372
373 /**
374 Change Rho - CylindricalEta3D coordinates only
375 */
377
378 /**
379 Change Eta - CylindricalEta3D coordinates only
380 */
381 DisplacementVector3D<CoordSystem, Tag>& SetEta (Scalar etaval) { fCoordinates.SetEta(etaval); return *this;}
382
383
384 // ------ Operations combining two vectors ------
385 // -- need to have the specialized version in order to avoid
386
387 /**
388 Return the scalar (dot) product of two displacement vectors.
389 It is possible to perform the product for any type of vector coordinates,
390 but they must have the same coordinate system tag
391 */
392 template< class OtherCoords >
394 return X()*v.X() + Y()*v.Y() + Z()*v.Z();
395 }
396 /**
397 Return the scalar (dot) product of two vectors.
398 It is possible to perform the product for any classes
399 implementing x(), y() and z() member functions
400 */
401 template< class OtherVector >
402 Scalar Dot( const OtherVector & v) const {
403 return X()*v.x() + Y()*v.y() + Z()*v.z();
404 }
405
406 /**
407 Return vector (cross) product of two displacement vectors,
408 as a vector in the coordinate system of this class.
409 It is possible to perform the product for any type of vector coordinates,
410 but they must have the same coordinate system tag
411 */
412 template <class OtherCoords>
415 result.SetXYZ ( Y()*v.Z() - v.Y()*Z(),
416 Z()*v.X() - v.Z()*X(),
417 X()*v.Y() - v.X()*Y() );
418 return result;
419 }
420 /**
421 Return vector (cross) product of two vectors,
422 as a vector in the coordinate system of this class.
423 It is possible to perform the product for any classes
424 implementing X(), Y() and Z() member functions
425 */
426 template <class OtherVector>
427 DisplacementVector3D Cross( const OtherVector & v) const {
429 result.SetXYZ ( Y()*v.z() - v.y()*Z(),
430 Z()*v.x() - v.z()*X(),
431 X()*v.y() - v.x()*Y() );
432 return result;
433 }
434
435
436
437 /**
438 Self Addition with a displacement vector.
439 */
440 template <class OtherCoords>
443 SetXYZ( X() + v.X(), Y() + v.Y(), Z() + v.Z() );
444 return *this;
445 }
446
447 /**
448 Self Difference with a displacement vector.
449 */
450 template <class OtherCoords>
453 SetXYZ( x() - v.x(), y() - v.y(), z() - v.z() );
454 return *this;
455 }
456
457
458 /**
459 multiply this vector by a scalar quantity
460 */
462 fCoordinates.Scale(a);
463 return *this;
464 }
465
466 /**
467 divide this vector by a scalar quantity
468 */
470 fCoordinates.Scale(1/a);
471 return *this;
472 }
473
474 // The following methods (v*a and v/a) could instead be free functions.
475 // They were moved into the class to solve a problem on AIX.
476
477 /**
478 Multiply a vector by a real number
479 */
481 DisplacementVector3D tmp(*this);
482 tmp *= a;
483 return tmp;
484 }
485
486 /**
487 Negative of the vector
488 */
490 return operator*( Scalar(-1) );
491 }
492
493 /**
494 Positive of the vector, return itself
495 */
496 DisplacementVector3D operator + ( ) const {return *this;}
497
498 /**
499 Division of a vector with a real number
500 */
502 DisplacementVector3D tmp(*this);
503 tmp /= a;
504 return tmp;
505 }
506
507
508 // Methods providing limited backward name compatibility with CLHEP
509
510 Scalar x() const { return fCoordinates.X(); }
511 Scalar y() const { return fCoordinates.Y(); }
512 Scalar z() const { return fCoordinates.Z(); }
513 Scalar r() const { return fCoordinates.R(); }
514 Scalar theta() const { return fCoordinates.Theta(); }
515 Scalar phi() const { return fCoordinates.Phi(); }
516 Scalar eta() const { return fCoordinates.Eta(); }
517 Scalar rho() const { return fCoordinates.Rho(); }
518 Scalar mag2() const { return fCoordinates.Mag2(); }
519 Scalar perp2() const { return fCoordinates.Perp2(); }
520 DisplacementVector3D unit() const {return Unit();}
521
522
523 private:
524
525 CoordSystem fCoordinates; // internal coordinate system
526
527#ifdef NOT_SURE_THIS_SHOULD_BE_FORBIDDEN
528 /**
529 Cross product involving a position vector is inappropriate
530 */
531 template <class T2>
533#endif
534
535 // the following methods should not compile
536
537 // this should not compile (if from a vector or points with different tag
538 template <class OtherCoords, class OtherTag>
540
541 template <class OtherCoords, class OtherTag>
543
544 template <class OtherCoords, class OtherTag>
546
547
548 template <class OtherCoords, class OtherTag>
550
551 template <class OtherCoords, class OtherTag>
553
554 template <class OtherCoords, class OtherTag>
556
557 template<class OtherCoords, class OtherTag >
559
560 template<class OtherCoords, class OtherTag >
562
563
564 };
565
566// ---------- DisplacementVector3D class template ends here ------------
567// ---------------------------------------------------------------------
568
569
570
571 /**
572 Addition of DisplacementVector3D vectors.
573 The (coordinate system) type of the returned vector is defined to
574 be identical to that of the first vector, which is passed by value
575 */
576 template <class CoordSystem1, class CoordSystem2, class U>
577 inline
581 return v1 += v2;
582 }
583
584 /**
585 Difference between two DisplacementVector3D vectors.
586 The (coordinate system) type of the returned vector is defined to
587 be identical to that of the first vector.
588 */
589 template <class CoordSystem1, class CoordSystem2, class U>
590 inline
591 DisplacementVector3D<CoordSystem1,U>
594 return v1 -= v2;
595 }
596
597 //#endif // not __CINT__
598
599 /**
600 Multiplication of a displacement vector by real number a*v
601 */
602 template <class CoordSystem, class U>
603 inline
604 DisplacementVector3D<CoordSystem,U>
607 return v *= a;
608 // Note - passing v by value and using operator *= may save one
609 // copy relative to passing v by const ref and creating a temporary.
610 }
611
612
613 // v1*v2 notation for Cross product of two vectors is omitted,
614 // since it is always confusing as to whether dot product is meant.
615
616
617
618 // ------------- I/O to/from streams -------------
619
620 template <class char_t, class traits_t, class T, class U,
622 nullptr>
623 std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
624 DisplacementVector3D<T, U> const &v)
625 {
626 if (os) {
627
628 typename T::Scalar a, b, c;
629 v.GetCoordinates(a, b, c);
630
633 typedef GenVector_detail::BitReproducible BR;
634 BR::Output(os, a);
635 BR::Output(os, b);
636 BR::Output(os, c);
637 } else {
640 }
641 }
642 return os;
643 } // op<< <>()
644
645 template <class char_t, class traits_t, class T, class U,
647 nullptr>
648 std::basic_ostream<char_t, traits_t> &operator<<(std::basic_ostream<char_t, traits_t> &os,
649 DisplacementVector3D<T, U> const &v)
650 {
651 if (os) {
652 os << "{ ";
653 for (std::size_t i = 0; i < PositionVector3D<T, U>::Scalar::Size; ++i) {
654 os << "(" << v.x()[i] << "," << v.y()[i] << "," << v.z()[i] << ") ";
655 }
656 os << "}";
657 }
658 return os;
659 } // op<< <>()
660
661 template< class char_t, class traits_t, class T, class U >
662 inline
663 std::basic_istream<char_t,traits_t> &
664 operator >> ( std::basic_istream<char_t,traits_t> & is
666 )
667 {
668 if( !is ) return is;
669
670 typename T::Scalar a, b, c;
671
675 BR::Input(is, a);
676 BR::Input(is, b);
677 BR::Input(is, c);
678 }
679 else {
681 detail::require_delim( is, detail::sep ); is >> b;
682 detail::require_delim( is, detail::sep ); is >> c;
684 }
685
686 if( is )
687 v.SetCoordinates(a, b, c);
688 return is;
689
690 } // op>> <>()
691
692
693
694 } // namespace Math
695
696} // namespace ROOT
697
698
699#endif /* ROOT_Math_GenVector_DisplacementVector3D */
700
typedef void(GLAPIENTRYP _GLUfuncptr)(void)
#define b(i)
Definition: RSha256.hxx:100
#define c(i)
Definition: RSha256.hxx:101
int type
Definition: TGX11.cxx:121
Class describing a 3D cartesian coordinate system (x, y, z coordinates)
Definition: Cartesian3D.h:44
Class describing a generic displacement vector in 3 dimensions.
DisplacementVector3D< CoordSystem, Tag > & SetCoordinates(IT begin, IT end)
Set internal data based on 3 Scalars at *begin to *end.
Scalar Theta() const
Polar theta, converting if necessary from internal coordinate system.
DisplacementVector3D & operator-=(const DisplacementVector3D< OtherCoords, OtherTag > &)
CoordSystem Coordinates() const
Retrieve a copy of the coordinates object.
DisplacementVector3D< CoordSystem, Tag > & SetRho(Scalar rr)
Change Rho - CylindricalEta3D coordinates only.
DisplacementVector3D & operator=(const DisplacementVector3D< OtherCoords, Tag > &v)
Assignment operator from a displacement vector of arbitrary type.
DisplacementVector3D & operator+=(const DisplacementVector3D< OtherCoords, OtherTag > &)
DisplacementVector3D< CoordSystem, Tag > & SetEta(Scalar etaval)
Change Eta - CylindricalEta3D coordinates only.
Scalar R() const
Polar R, converting if necessary from internal coordinate system.
DisplacementVector3D & operator/=(Scalar a)
divide this vector by a scalar quantity
DisplacementVector3D< CoordSystem, Tag > & SetPhi(Scalar ang)
Change Phi - Polar3D or CylindricalEta3D coordinates.
DisplacementVector3D< CoordSystem, Tag > & SetR(Scalar rr)
Change R - Polar3D coordinates only.
DisplacementVector3D Cross(const OtherVector &v) const
Return vector (cross) product of two vectors, as a vector in the coordinate system of this class.
DisplacementVector3D Unit() const
return unit vector parallel to this (scalar)
DisplacementVector3D operator+() const
Positive of the vector, return itself.
DisplacementVector3D operator-() const
Negative of the vector.
DisplacementVector3D< CoordSystem, Tag > & SetCoordinates(Scalar a, Scalar b, Scalar c)
Set internal data based on 3 Scalar numbers.
DisplacementVector3D< CoordSystem, Tag > & SetY(Scalar yy)
Change Y - Cartesian3D coordinates only.
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
DisplacementVector3D< CoordSystem, Tag > & SetZ(Scalar zz)
Change Z - Cartesian3D coordinates only.
void GetCoordinates(Scalar dest[]) const
get internal data into a C-style array of 3 Scalar numbers
DisplacementVector3D(const PositionVector3D< OtherCoords, OtherTag > &)
void GetCoordinates(Scalar &a, Scalar &b, Scalar &c) const
get internal data into 3 Scalar numbers
void GetCoordinates(IT begin) const
get internal data into 3 Scalars starting at *begin
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
DisplacementVector3D(const PositionVector3D< OtherCoords, Tag > &p)
Construct from a position vector expressed in different coordinates but with the same coordinate syst...
Scalar Dot(const OtherVector &v) const
Return the scalar (dot) product of two vectors.
DisplacementVector3D Cross(const DisplacementVector3D< OtherCoords, Tag > &v) const
Return vector (cross) product of two displacement vectors, as a vector in the coordinate system of th...
DisplacementVector3D< CoordSystem, Tag > & SetTheta(Scalar ang)
Change Theta - Polar3D coordinates only.
DisplacementVector3D operator*(Scalar a) const
Multiply a vector by a real number.
bool operator==(const DisplacementVector3D &rhs) const
Exact equality.
Scalar Rho() const
Cylindrical transverse component rho.
DisplacementVector3D Cross(const DisplacementVector3D< OtherCoords, OtherTag > &) const
bool operator!=(const DisplacementVector3D &rhs) const
DisplacementVector3D unit() const
DisplacementVector3D()
Default constructor.
DisplacementVector3D< CoordSystem, Tag > & SetCoordinates(const Scalar src[])
Set internal data based on a C-style array of 3 Scalar numbers.
DisplacementVector3D(Scalar a, Scalar b, Scalar c)
Construct from three values of type Scalar.
DisplacementVector3D(const ForeignVector &v)
Construct from a foreign 3D vector type, for example, Hep3Vector Precondition: v must implement metho...
DisplacementVector3D & operator=(const PositionVector3D< OtherCoords, OtherTag > &)
Scalar Dot(const DisplacementVector3D< OtherCoords, OtherTag > &) const
Scalar Phi() const
Polar phi, converting if necessary from internal coordinate system.
DisplacementVector3D< CoordSystem, Tag > & SetX(Scalar xx)
Change X - Cartesian3D coordinates only.
Scalar Mag2() const
Magnitute squared ( r^2 in spherical coordinate)
DisplacementVector3D< CoordSystem, Tag > & SetXYZ(Scalar a, Scalar b, Scalar c)
set the values of the vector from the cartesian components (x,y,z) (if the vector is held in polar or...
Scalar Perp2() const
Transverse component squared (rho^2 in cylindrical coordinates.
DisplacementVector3D & operator*=(Scalar a)
multiply this vector by a scalar quantity
DisplacementVector3D operator/(Scalar a) const
Division of a vector with a real number.
Scalar Eta() const
Polar eta, converting if necessary from internal coordinate system.
Scalar Z() const
Cartesian Z, converting if necessary from internal coordinate system.
DisplacementVector3D(const DisplacementVector3D< OtherCoords, Tag > &v)
Construct from a displacement vector expressed in different coordinates, or using a different Scalar ...
void GetCoordinates(IT begin, IT end) const
get internal data into 3 Scalars at *begin to *end (3 past begin)
DisplacementVector3D(const DisplacementVector3D< OtherCoords, OtherTag > &)
Scalar Dot(const DisplacementVector3D< OtherCoords, Tag > &v) const
Return the scalar (dot) product of two displacement vectors.
DisplacementVector3D & operator=(const DisplacementVector3D< OtherCoords, OtherTag > &)
Class describing a generic position vector (point) in 3 dimensions.
Namespace for new Math classes and functions.
double T(double x)
Definition: ChebyshevPol.h:34
char_t get_manip(std::basic_ios< char_t, traits_t > &ios, manip_t m)
Definition: GenVectorIO.h:54
std::basic_istream< char_t, traits_t > & require_delim(std::basic_istream< char_t, traits_t > &is, manip_t m)
Definition: GenVectorIO.h:113
void set_manip(std::basic_ios< char_t, traits_t > &ios, manip_t m, char_t ch)
Definition: GenVectorIO.h:74
std::ostream & operator<<(std::ostream &os, const AxisAngle &a)
Stream Output and Input.
Definition: AxisAngle.cxx:91
std::basic_istream< char_t, traits_t > & operator>>(std::basic_istream< char_t, traits_t > &is, DisplacementVector2D< T, U > &v)
DisplacementVector2D< CoordSystem1, U > operator+(DisplacementVector2D< CoordSystem1, U > v1, const DisplacementVector2D< CoordSystem2, U > &v2)
Addition of DisplacementVector2D vectors.
DisplacementVector2D< CoordSystem1, U > operator-(DisplacementVector2D< CoordSystem1, U > v1, DisplacementVector2D< CoordSystem2, U > const &v2)
Difference between two DisplacementVector2D vectors.
AxisAngle operator*(RotationX const &r1, AxisAngle const &r2)
Multiplication of an axial rotation by an AxisAngle.
Rotation3D::Scalar Scalar
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.
const char * Size
Definition: TXMLSetup.cxx:56
auto * a
Definition: textangle.C:12
#define dest(otri, vertexptr)
Definition: triangle.c:1041