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