CLHEP VERSION Reference Documentation
   
CLHEP Home Page     CLHEP Documentation     CLHEP Bug Reports

Geometry/BasicVector3D.h
Go to the documentation of this file.
1 // -*- C++ -*-
2 // $Id: BasicVector3D.h,v 1.5 2010/06/16 16:21:27 garren Exp $
3 // ---------------------------------------------------------------------------
4 //
5 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
6 //
7 // History:
8 // 12.06.01 E.Chernyaev - CLHEP-1.7: initial version
9 // 14.03.03 E.Chernyaev - CLHEP-1.9: template version
10 //
11 
12 #ifndef BASIC_VECTOR3D_H
13 #define BASIC_VECTOR3D_H
14 
15 #include <iosfwd>
16 #include "CLHEP/Geometry/defs.h"
17 #include "CLHEP/Vector/ThreeVector.h"
18 
19 namespace HepGeom {
28  template<class T> class BasicVector3D {
29  protected:
30  T v_[3];
31 
36  BasicVector3D() { v_[0] = 0; v_[1] = 0; v_[2] = 0; }
37 
38  public:
42  enum {
43  X = 0,
44  Y = 1,
45  Z = 2,
46  NUM_COORDINATES = 3,
48  };
49 
52  BasicVector3D(T x1, T y1, T z1) { v_[0] = x1; v_[1] = y1; v_[2] = z1; }
53 
62  v_[0] = v.x(); v_[1] = v.y(); v_[2] = v.z();
63  }
64 
67  virtual ~BasicVector3D() {}
68 
69  // -------------------------
70  // Interface to "good old C"
71  // -------------------------
72 
75  operator T * () { return v_; }
76 
79  operator const T * () const { return v_; }
80 
86  operator CLHEP::Hep3Vector () const { return CLHEP::Hep3Vector(x(),y(),z()); }
87 
88  // -----------------------------
89  // General arithmetic operations
90  // -----------------------------
91 
95  v_[0] = v.v_[0]; v_[1] = v.v_[1]; v_[2] = v.v_[2]; return *this;
96  }
100  v_[0] += v.v_[0]; v_[1] += v.v_[1]; v_[2] += v.v_[2]; return *this;
101  }
105  v_[0] -= v.v_[0]; v_[1] -= v.v_[1]; v_[2] -= v.v_[2]; return *this;
106  }
110  v_[0] *= a; v_[1] *= a; v_[2] *= a; return *this;
111  }
115  v_[0] /= a; v_[1] /= a; v_[2] /= a; return *this;
116  }
117 
118  // ------------
119  // Subscripting
120  // ------------
121 
124  T operator()(int i) const { return v_[i]; }
127  T operator[](int i) const { return v_[i]; }
128 
131  T & operator()(int i) { return v_[i]; }
134  T & operator[](int i) { return v_[i]; }
135 
136  // ------------------------------------
137  // Cartesian coordinate system: x, y, z
138  // ------------------------------------
139 
142  T x() const { return v_[0]; }
145  T y() const { return v_[1]; }
148  T z() const { return v_[2]; }
149 
152  void setX(T a) { v_[0] = a; }
155  void setY(T a) { v_[1] = a; }
158  void setZ(T a) { v_[2] = a; }
159 
162  void set(T x1, T y1, T z1) { v_[0] = x1; v_[1] = y1; v_[2] = z1; }
163 
164  // ------------------------------------------
165  // Cylindrical coordinate system: rho, phi, z
166  // ------------------------------------------
167 
170  T perp2() const { return x()*x()+y()*y(); }
173  T perp() const { return std::sqrt(perp2()); }
176  T rho() const { return perp(); }
177 
180  void setPerp(T rh) {
181  T factor = perp();
182  if (factor > 0) {
183  factor = rh/factor; v_[0] *= factor; v_[1] *= factor;
184  }
185  }
186 
187  // ------------------------------------------
188  // Spherical coordinate system: r, phi, theta
189  // ------------------------------------------
190 
193  T mag2() const { return x()*x()+y()*y()+z()*z(); }
196  T mag() const { return std::sqrt(mag2()); }
199  T r() const { return mag(); }
202  T phi() const {
203  return x() == 0 && y() == 0 ? 0 : std::atan2(y(),x());
204  }
207  T theta() const {
208  return x() == 0 && y() == 0 && z() == 0 ? 0 : std::atan2(perp(),z());
209  }
212  T cosTheta() const { T ma = mag(); return ma == 0 ? 1 : z()/ma; }
213 
216  T getR() const { return r(); }
219  T getPhi() const { return phi(); }
222  T getTheta() const { return theta(); }
223 
226  void setMag(T ma) {
227  T factor = mag();
228  if (factor > 0) {
229  factor = ma/factor; v_[0] *= factor; v_[1] *= factor; v_[2] *= factor;
230  }
231  }
234  void setR(T ma) { setMag(ma); }
237  void setPhi(T ph) { T xy = perp(); setX(xy*std::cos(ph)); setY(xy*std::sin(ph)); }
240  void setTheta(T th) {
241  T ma = mag();
242  T ph = phi();
243  set(ma*std::sin(th)*std::cos(ph), ma*std::sin(th)*std::sin(ph), ma*std::cos(th));
244  }
245 
246  // ---------------
247  // Pseudo rapidity
248  // ---------------
249 
252  T pseudoRapidity() const;
255  T eta() const { return pseudoRapidity(); }
258  T getEta() const { return pseudoRapidity(); }
259 
262  void setEta(T a);
263 
264  // -------------------
265  // Combine two vectors
266  // -------------------
267 
270  T dot(const BasicVector3D<T> & v) const {
271  return x()*v.x()+y()*v.y()+z()*v.z();
272  }
273 
277  return BasicVector3D<T>(y()*v.z()-v.y()*z(),
278  z()*v.x()-v.z()*x(),
279  x()*v.y()-v.x()*y());
280  }
281 
284  T perp2(const BasicVector3D<T> & v) const {
285  T tot = v.mag2(), s = dot(v);
286  return tot > 0 ? mag2()-s*s/tot : mag2();
287  }
288 
291  T perp(const BasicVector3D<T> & v) const {
292  return std::sqrt(perp2(v));
293  }
294 
297  T angle(const BasicVector3D<T> & v) const;
298 
299  // ---------------
300  // Related vectors
301  // ---------------
302 
306  T len = mag();
307  return (len > 0) ?
308  BasicVector3D<T>(x()/len, y()/len, z()/len) : BasicVector3D<T>();
309  }
310 
314  T dx = x() < 0 ? -x() : x();
315  T dy = y() < 0 ? -y() : y();
316  T dz = z() < 0 ? -z() : z();
317  if (dx < dy) {
318  return dx < dz ?
319  BasicVector3D<T>(0,z(),-y()) : BasicVector3D<T>(y(),-x(),0);
320  }else{
321  return dy < dz ?
322  BasicVector3D<T>(-z(),0,x()) : BasicVector3D<T>(y(),-x(),0);
323  }
324  }
325 
326  // ---------
327  // Rotations
328  // ---------
329 
341  BasicVector3D<T> & rotate(T a, const BasicVector3D<T> & v);
342  };
343 
344  /*************************************************************************
345  * *
346  * Non-member functions for BasicVector3D<float> *
347  * *
348  *************************************************************************/
349 
354  std::ostream &
355  operator<<(std::ostream &, const BasicVector3D<float> &);
356 
361  std::istream &
362  operator>>(std::istream &, BasicVector3D<float> &);
363 
368  inline BasicVector3D<float>
369  operator+(const BasicVector3D<float> & v) { return v; }
370 
375  inline BasicVector3D<float>
377  return BasicVector3D<float>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
378  }
379 
384  inline BasicVector3D<float>
386  return BasicVector3D<float>(-v.x(), -v.y(), -v.z());
387  }
388 
393  inline BasicVector3D<float>
395  return BasicVector3D<float>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
396  }
397 
402  inline BasicVector3D<float>
403  operator*(const BasicVector3D<float> & v, double a) {
404  return BasicVector3D<float>(v.x()*static_cast<float>(a), v.y()*static_cast<float>(a), v.z()*static_cast<float>(a));
405  }
406 
411  inline float
413  return a.dot(b);
414  }
415 
420  inline BasicVector3D<float>
421  operator*(double a, const BasicVector3D<float> & v) {
422  return BasicVector3D<float>(static_cast<float>(a)*v.x(), static_cast<float>(a)*v.y(), static_cast<float>(a)*v.z());
423  }
424 
429  inline BasicVector3D<float>
430  operator/(const BasicVector3D<float> & v, double a) {
431  return BasicVector3D<float>(v.x()/static_cast<float>(a), v.y()/static_cast<float>(a), v.z()/static_cast<float>(a));
432  }
433 
438  inline bool
440  return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
441  }
442 
447  inline bool
449  return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
450  }
451 
452  /*************************************************************************
453  * *
454  * Non-member functions for BasicVector3D<double> *
455  * *
456  *************************************************************************/
457 
462  std::ostream &
463  operator<<(std::ostream &, const BasicVector3D<double> &);
464 
469  std::istream &
470  operator>>(std::istream &, BasicVector3D<double> &);
471 
476  inline BasicVector3D<double>
477  operator+(const BasicVector3D<double> & v) { return v; }
478 
483  inline BasicVector3D<double>
485  return BasicVector3D<double>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
486  }
487 
492  inline BasicVector3D<double>
494  return BasicVector3D<double>(-v.x(), -v.y(), -v.z());
495  }
496 
501  inline BasicVector3D<double>
503  return BasicVector3D<double>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
504  }
505 
510  inline BasicVector3D<double>
511  operator*(const BasicVector3D<double> & v, double a) {
512  return BasicVector3D<double>(v.x()*a, v.y()*a, v.z()*a);
513  }
514 
519  inline double
521  return a.dot(b);
522  }
523 
528  inline BasicVector3D<double>
529  operator*(double a, const BasicVector3D<double> & v) {
530  return BasicVector3D<double>(a*v.x(), a*v.y(), a*v.z());
531  }
532 
537  inline BasicVector3D<double>
538  operator/(const BasicVector3D<double> & v, double a) {
539  return BasicVector3D<double>(v.x()/a, v.y()/a, v.z()/a);
540  }
541 
546  inline bool
548  {
549  return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
550  }
551 
556  inline bool
558  {
559  return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
560  }
561 } /* namespace HepGeom */
562 
563 #ifdef ENABLE_BACKWARDS_COMPATIBILITY
564 // backwards compatibility will be enabled ONLY in CLHEP 1.9
565 using namespace HepGeom;
566 #endif
567 
568 #endif /* BASIC_VECTOR3D_H */
BasicVector3D< double > operator+(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< double > operator/(const BasicVector3D< double > &v, double a)
BasicVector3D< T > & rotateZ(T a)
T perp(const BasicVector3D< T > &v) const
BasicVector3D< T > & operator/=(double a)
BasicVector3D< float > operator+(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< T > & operator+=(const BasicVector3D< T > &v)
BasicVector3D(T x1, T y1, T z1)
BasicVector3D< T > unit() const
BasicVector3D< T > orthogonal() const
BasicVector3D< T > cross(const BasicVector3D< T > &v) const
T angle(const BasicVector3D< T > &v) const
BasicVector3D(const BasicVector3D< float > &v)
BasicVector3D< float > operator*(const BasicVector3D< float > &v, double a)
T perp2(const BasicVector3D< T > &v) const
BasicVector3D< float > operator+(const BasicVector3D< float > &v)
BasicVector3D< float > operator-(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< float > operator*(double a, const BasicVector3D< float > &v)
float operator*(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
std::istream & operator>>(std::istream &is, BasicVector3D< float > &a)
T dot(const BasicVector3D< T > &v) const
double operator*(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< double > operator*(const BasicVector3D< double > &v, double a)
bool operator==(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< T > & rotate(T a, const BasicVector3D< T > &v)
bool operator!=(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< double > operator*(double a, const BasicVector3D< double > &v)
BasicVector3D< T > & operator=(const BasicVector3D< T > &v)
bool operator!=(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< double > operator+(const BasicVector3D< double > &v)
void set(T x1, T y1, T z1)
bool operator==(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< double > operator-(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< float > operator/(const BasicVector3D< float > &v, double a)
BasicVector3D< T > & operator-=(const BasicVector3D< T > &v)
BasicVector3D< T > & rotateX(T a)
BasicVector3D< T > & rotateY(T a)
BasicVector3D< T > & operator*=(double a)
BasicVector3D< double > operator-(const BasicVector3D< double > &v)
BasicVector3D< float > operator-(const BasicVector3D< float > &v)