ROOT   6.08/07 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
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
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
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
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 */
Scalar R() const
Polar R, converting if necessary from internal coordinate system.
PositionVector3D & operator=(const PositionVector3D< OtherCoords, Tag > &v)
Assignment operator from a position vector of arbitrary type.
PositionVector3D< CoordSystem, Tag > & SetX(Scalar xx)
Change X - Cartesian3D coordinates only.
This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecu...
Definition: StringConv.hxx:21
PositionVector3D operator*(Scalar a) const
Multiply a vector by a real number.
return c
Scalar Rho() const
Cylindrical transverse component rho.
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.
Class describing a 3D cartesian coordinate system (x, y, z coordinates)
Definition: Cartesian3D.h:51
TArc * a
Definition: textangle.C:12
PositionVector3D operator/(Scalar a) const
Division of a vector with a real number.
PositionVector3D(const PositionVector3D< T, Tag > &v)
Construct from a position vector expressed in different coordinates, or using a different Scalar type...
DisplacementVector2D< CoordSystem1, U > operator+(DisplacementVector2D< CoordSystem1, U > v1, const DisplacementVector2D< CoordSystem2, U > &v2)
Scalar Phi() const
Polar phi, converting if necessary from internal coordinate system.
Scalar X() const
Cartesian X, 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.
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...
Scalar Z() const
Cartesian Z, converting if necessary from internal coordinate system.
Scalar Theta() const
Polar theta, converting if necessary from internal coordinate system.
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
static double p2(double t, double a, double b, double c)
void GetCoordinates(IT begin, IT end) const
get internal data into 3 Scalars at *begin to *end (3 past begin)
PositionVector3D< CoordSystem, Tag > & SetCoordinates(const Scalar src[])
Set internal data based on a C-style array of 3 Scalar numbers.
void GetCoordinates(Scalar dest[]) const
get internal data into a C-style array of 3 Scalar numbers
bool operator==(const PositionVector3D &rhs) const
Exact equality.
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 Z() const
Cartesian Z, 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
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
PositionVector3D< CoordSystem, Tag > & SetPhi(Scalar ang)
Change Phi - Polar3D or CylindricalEta3D coordinates.
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.
static double p1(double t, double a, double b)
Scalar Mag2() const
Magnitute squared ( r^2 in spherical coordinate)
PositionVector3D & operator*=(Scalar a)
multiply this vector by a scalar quantity
PositionVector3D & operator+=(const DisplacementVector3D< OtherCoords, Tag > &v)
Self Addition with a displacement vector.
void set_manip(std::basic_ios< char_t, traits_t > &ios, manip_t m, char_t ch)
Definition: GenVectorIO.h:74
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...
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
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...
void GetCoordinates(IT begin) const
get internal data into 3 Scalars at *begin
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
bool operator!=(const PositionVector3D &rhs) const
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
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.
const CoordSystem & Coordinates() const
Retrieve a copy of the coordinates object.
PositionVector3D & operator/=(Scalar a)
divide this vector by a scalar quantity
PositionVector3D< CoordSystem, Tag > & SetZ(Scalar zz)
Change Z - Cartesian3D coordinates only.
Plane3D::Scalar Scalar
Definition: Plane3D.cxx:29
PositionVector3D & operator-=(const DisplacementVector3D< OtherCoords, Tag > &v)
Self Difference with a displacement vector.
Scalar Dot(const DisplacementVector3D< OtherCoords, Tag > &v) const
Return the scalar (Dot) product of this with a displacement vector in any coordinate system...
Scalar Perp2() const
Transverse component squared (rho^2 in cylindrical coordinates.
PositionVector3D< CoordSystem, Tag > & SetTheta(Scalar ang)
Change Theta - Polar3D coordinates only.
PositionVector3D< CoordSystem, Tag > & SetY(Scalar yy)
Change Y - Cartesian3D coordinates only.