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

CLHEP/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
19namespace 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,
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
369 operator+(const BasicVector3D<float> & v) { return v; }
370
377 return BasicVector3D<float>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
378 }
379
386 return BasicVector3D<float>(-v.x(), -v.y(), -v.z());
387 }
388
395 return BasicVector3D<float>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
396 }
397
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
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
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
477 operator+(const BasicVector3D<double> & v) { return v; }
478
485 return BasicVector3D<double>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
486 }
487
494 return BasicVector3D<double>(-v.x(), -v.y(), -v.z());
495 }
496
503 return BasicVector3D<double>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
504 }
505
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
529 operator*(double a, const BasicVector3D<double> & v) {
530 return BasicVector3D<double>(a*v.x(), a*v.y(), a*v.z());
531 }
532
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
565using namespace HepGeom;
566#endif
567
568#endif /* BASIC_VECTOR3D_H */
BasicVector3D< float > operator-(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< T > cross(const BasicVector3D< T > &v) const
BasicVector3D< float > operator*(const BasicVector3D< float > &v, double a)
float operator*(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< T > & rotateZ(T a)
BasicVector3D(const BasicVector3D< float > &v)
BasicVector3D< double > operator*(const BasicVector3D< double > &v, double a)
bool operator!=(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< T > & operator/=(double a)
BasicVector3D< T > & rotateX(T a)
BasicVector3D< T > & rotate(T a, const BasicVector3D< T > &v)
BasicVector3D< T > & operator=(const BasicVector3D< T > &v)
BasicVector3D< float > operator+(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< float > operator/(const BasicVector3D< float > &v, double a)
T angle(const BasicVector3D< T > &v) const
BasicVector3D< T > & operator*=(double a)
BasicVector3D< double > operator+(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
bool operator==(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< float > operator-(const BasicVector3D< float > &v)
bool operator==(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< double > operator+(const BasicVector3D< double > &v)
BasicVector3D< double > operator-(const BasicVector3D< double > &v)
BasicVector3D< T > & rotateY(T a)
BasicVector3D< double > operator/(const BasicVector3D< double > &v, double a)
BasicVector3D< double > operator-(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
bool operator!=(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< T > unit() const
BasicVector3D< float > operator*(double a, const BasicVector3D< float > &v)
BasicVector3D< double > operator*(double a, const BasicVector3D< double > &v)
BasicVector3D< T > & operator+=(const BasicVector3D< T > &v)
BasicVector3D< T > & operator-=(const BasicVector3D< T > &v)
double operator*(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
T perp2(const BasicVector3D< T > &v) const
BasicVector3D< T > orthogonal() const
T perp(const BasicVector3D< T > &v) const
BasicVector3D< float > operator+(const BasicVector3D< float > &v)
T dot(const BasicVector3D< T > &v) const
std::istream & operator>>(std::istream &is, BasicVector3D< float > &a)
std::ostream & operator<<(std::ostream &os, const BasicVector3D< float > &a)
@ b
@ a