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