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