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 
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 */
HepGeom::BasicVector3D::operator+
BasicVector3D< double > operator+(const BasicVector3D< double > &v)
Definition: Geometry/BasicVector3D.h:477
HepGeom::BasicVector3D::operator-=
BasicVector3D< T > & operator-=(const BasicVector3D< T > &v)
Definition: Geometry/BasicVector3D.h:104
HepGeom::BasicVector3D::rho
T rho() const
Definition: Geometry/BasicVector3D.h:176
HepGeom::BasicVector3D::perp
T perp() const
Definition: Geometry/BasicVector3D.h:173
X
Definition: testSharedPtrBasic.cc:28
HepGeom::BasicVector3D::setPhi
void setPhi(T ph)
Definition: Geometry/BasicVector3D.h:237
a
@ a
Definition: testCategories.cc:125
HepGeom::BasicVector3D::setTheta
void setTheta(T th)
Definition: Geometry/BasicVector3D.h:240
HepGeom::BasicVector3D::cross
BasicVector3D< T > cross(const BasicVector3D< T > &v) const
Definition: Geometry/BasicVector3D.h:276
HepGeom::BasicVector3D::operator*
BasicVector3D< double > operator*(const BasicVector3D< double > &v, double a)
Definition: Geometry/BasicVector3D.h:511
HepGeom::BasicVector3D::operator+
BasicVector3D< float > operator+(const BasicVector3D< float > &v)
Definition: Geometry/BasicVector3D.h:369
HepGeom::BasicVector3D::perp2
T perp2(const BasicVector3D< T > &v) const
Definition: Geometry/BasicVector3D.h:284
HepGeom::BasicVector3D< float >
HepGeom::BasicVector3D::setEta
void setEta(T a)
HepGeom::BasicVector3D::y
T y() const
Definition: CLHEP/Geometry/BasicVector3D.h:145
HepGeom::BasicVector3D::theta
T theta() const
Definition: Geometry/BasicVector3D.h:207
HepGeom::BasicVector3D::setY
void setY(T a)
Definition: Geometry/BasicVector3D.h:155
b
@ b
Definition: testCategories.cc:125
HepGeom::BasicVector3D::BasicVector3D
BasicVector3D()
Definition: Geometry/BasicVector3D.h:36
HepGeom::BasicVector3D::setPerp
void setPerp(T rh)
Definition: Geometry/BasicVector3D.h:180
HepGeom::BasicVector3D::BasicVector3D
BasicVector3D(T x1, T y1, T z1)
Definition: Geometry/BasicVector3D.h:52
HepGeom::BasicVector3D::operator!=
bool operator!=(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
Definition: Geometry/BasicVector3D.h:448
HepGeom::BasicVector3D::operator+
BasicVector3D< double > operator+(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
Definition: Geometry/BasicVector3D.h:484
HepGeom::BasicVector3D::operator==
bool operator==(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
Definition: Geometry/BasicVector3D.h:439
HepGeom::BasicVector3D::operator-
BasicVector3D< float > operator-(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
Definition: Geometry/BasicVector3D.h:394
HepGeom::BasicVector3D::operator/
BasicVector3D< float > operator/(const BasicVector3D< float > &v, double a)
Definition: Geometry/BasicVector3D.h:430
HepGeom::BasicVector3D::perp
T perp(const BasicVector3D< T > &v) const
Definition: Geometry/BasicVector3D.h:291
HepGeom::BasicVector3D::z
T z() const
Definition: CLHEP/Geometry/BasicVector3D.h:148
HepGeom::BasicVector3D::operator*
float operator*(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
Definition: Geometry/BasicVector3D.h:412
HepGeom::BasicVector3D::r
T r() const
Definition: Geometry/BasicVector3D.h:199
HepGeom::BasicVector3D::dot
T dot(const BasicVector3D< T > &v) const
Definition: Geometry/BasicVector3D.h:270
HepGeom::BasicVector3D::BasicVector3D
BasicVector3D(const BasicVector3D< float > &v)
Definition: Geometry/BasicVector3D.h:61
HepGeom::BasicVector3D::perp2
T perp2() const
Definition: Geometry/BasicVector3D.h:170
HepGeom::BasicVector3D::operator==
bool operator==(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
Definition: Geometry/BasicVector3D.h:547
HepGeom::BasicVector3D::eta
T eta() const
Definition: Geometry/BasicVector3D.h:255
HepGeom::BasicVector3D::NUM_COORDINATES
@ NUM_COORDINATES
Definition: CLHEP/Geometry/BasicVector3D.h:46
HepGeom::BasicVector3D::mag
T mag() const
Definition: Geometry/BasicVector3D.h:196
HepGeom::BasicVector3D::operator*
BasicVector3D< double > operator*(double a, const BasicVector3D< double > &v)
Definition: Geometry/BasicVector3D.h:529
HepGeom::BasicVector3D::operator/
BasicVector3D< double > operator/(const BasicVector3D< double > &v, double a)
Definition: Geometry/BasicVector3D.h:538
HepGeom::BasicVector3D::setR
void setR(T ma)
Definition: Geometry/BasicVector3D.h:234
HepGeom::BasicVector3D::rotate
BasicVector3D< T > & rotate(T a, const BasicVector3D< T > &v)
HepGeom::BasicVector3D::SIZE
@ SIZE
Definition: CLHEP/Geometry/BasicVector3D.h:47
HepGeom::BasicVector3D::v_
T v_[3]
Definition: CLHEP/Geometry/BasicVector3D.h:30
Z
Definition: testSharedPtrConvertible.cc:34
HepGeom::BasicVector3D::operator/=
BasicVector3D< T > & operator/=(double a)
Definition: Geometry/BasicVector3D.h:114
HepGeom::BasicVector3D::mag2
T mag2() const
Definition: Geometry/BasicVector3D.h:193
HepGeom::BasicVector3D::setZ
void setZ(T a)
Definition: Geometry/BasicVector3D.h:158
v
they are gone ZOOM Features Discontinued The following features of the ZOOM package were felt to be extreme overkill These have been after checking that no existing user code was utilizing as in SpaceVector v
Definition: keyMergeIssues.doc:324
HepGeom::BasicVector3D::operator=
BasicVector3D< T > & operator=(const BasicVector3D< T > &v)
Definition: CLHEP/Geometry/BasicVector3D.h:94
HepGeom::BasicVector3D::operator!=
bool operator!=(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
Definition: Geometry/BasicVector3D.h:557
Hep3Vector
Issues Concerning the PhysicsVectors CLHEP Vector Merge The merge of ZOOM PhysicsVdectors and the CLHEP Vector package is completed The purpose of this document is to list the major issues that affected the merge of these and where relevant describe the resolutions More detailed documents describe more minor issues General Approach As agreed at the June CLHEP the approach is to combine the features of each ZOOM class with the corresponding CLHEP class expanding the interface to create a single lingua franca of what a Hep3Vector(for example) means. We are not forming SpaceVector as an class derived from Hep3Vector and enhancing it in that way. Another rule imposed by the agreement is to avoid using the Exceptions package(even though that will later go into CLHEP for other uses). A desirable goal is to avoid cluttering the interface and enlarging the code linked in when ordinary CLHEP Vector functionallity is used. To this end
HepGeom::BasicVector3D::pseudoRapidity
T pseudoRapidity() const
HepGeom::BasicVector3D::getTheta
T getTheta() const
Definition: Geometry/BasicVector3D.h:222
HepGeom::BasicVector3D::operator()
T & operator()(int i)
Definition: Geometry/BasicVector3D.h:131
HepGeom::BasicVector3D::operator*=
BasicVector3D< T > & operator*=(double a)
Definition: Geometry/BasicVector3D.h:109
HepGeom::BasicVector3D::operator+=
BasicVector3D< T > & operator+=(const BasicVector3D< T > &v)
Definition: Geometry/BasicVector3D.h:99
HepGeom::BasicVector3D::operator-
BasicVector3D< double > operator-(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
Definition: Geometry/BasicVector3D.h:502
HepGeom::BasicVector3D::operator[]
T & operator[](int i)
Definition: Geometry/BasicVector3D.h:134
HepGeom::BasicVector3D::getPhi
T getPhi() const
Definition: Geometry/BasicVector3D.h:219
HepGeom::BasicVector3D::set
void set(T x1, T y1, T z1)
Definition: Geometry/BasicVector3D.h:162
HepGeom::BasicVector3D::operator()
T operator()(int i) const
Definition: Geometry/BasicVector3D.h:124
HepGeom::operator>>
std::istream & operator>>(std::istream &is, BasicVector3D< float > &a)
Definition: BasicVector3D.cc:115
Y
Definition: testSharedPtrBasic.cc:34
HepGeom::BasicVector3D::getEta
T getEta() const
Definition: Geometry/BasicVector3D.h:258
HepGeom::BasicVector3D::setMag
void setMag(T ma)
Definition: Geometry/BasicVector3D.h:226
HepGeom
Definition: CLHEP/Geometry/BasicVector3D.h:19
s
Methods applicble to containers of as in std::list< LorentzVector > s
Definition: keyMergeIssues.doc:328
HepGeom::BasicVector3D::operator*
BasicVector3D< float > operator*(const BasicVector3D< float > &v, double a)
Definition: Geometry/BasicVector3D.h:403
i
long i
Definition: JamesRandomSeeding.txt:27
HepGeom::BasicVector3D::operator-
BasicVector3D< float > operator-(const BasicVector3D< float > &v)
Definition: Geometry/BasicVector3D.h:385
HepGeom::BasicVector3D::rotateZ
BasicVector3D< T > & rotateZ(T a)
HepGeom::BasicVector3D::cosTheta
T cosTheta() const
Definition: Geometry/BasicVector3D.h:212
HepGeom::BasicVector3D::angle
T angle(const BasicVector3D< T > &v) const
HepGeom::BasicVector3D::operator*
BasicVector3D< float > operator*(double a, const BasicVector3D< float > &v)
Definition: Geometry/BasicVector3D.h:421
HepGeom::BasicVector3D::operator-
BasicVector3D< double > operator-(const BasicVector3D< double > &v)
Definition: Geometry/BasicVector3D.h:493
HepGeom::BasicVector3D::rotateX
BasicVector3D< T > & rotateX(T a)
HepGeom::BasicVector3D::~BasicVector3D
virtual ~BasicVector3D()
Definition: Geometry/BasicVector3D.h:67
defs.h
HepGeom::BasicVector3D::orthogonal
BasicVector3D< T > orthogonal() const
Definition: Geometry/BasicVector3D.h:313
HepGeom::BasicVector3D::x
T x() const
Definition: CLHEP/Geometry/BasicVector3D.h:142
HepGeom::operator<<
std::ostream & operator<<(std::ostream &os, const BasicVector3D< float > &a)
Definition: BasicVector3D.cc:108
HepGeom::BasicVector3D::getR
T getR() const
Definition: Geometry/BasicVector3D.h:216
HepGeom::BasicVector3D::rotateY
BasicVector3D< T > & rotateY(T a)
HepGeom::BasicVector3D::operator[]
T operator[](int i) const
Definition: Geometry/BasicVector3D.h:127
HepGeom::BasicVector3D::unit
BasicVector3D< T > unit() const
Definition: Geometry/BasicVector3D.h:305
HepGeom::BasicVector3D::setX
void setX(T a)
Definition: Geometry/BasicVector3D.h:152
HepGeom::BasicVector3D::operator*
double operator*(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
Definition: Geometry/BasicVector3D.h:520
HepGeom::BasicVector3D::phi
T phi() const
Definition: Geometry/BasicVector3D.h:202
HepGeom::BasicVector3D::operator+
BasicVector3D< float > operator+(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
Definition: Geometry/BasicVector3D.h:376