CLHEP 2.4.7.1
C++ Class Library for High Energy Physics
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 <type_traits>
17#include "CLHEP/Geometry/defs.h"
19
20namespace HepGeom {
29 template<class T> class BasicVector3D {
30 protected:
31 T v_[3];
32
37 BasicVector3D() { v_[0] = 0; v_[1] = 0; v_[2] = 0; }
38
39 public:
43 enum {
44 X = 0,
45 Y = 1,
46 Z = 2,
49 };
50
53 BasicVector3D(T x1, T y1, T z1) { v_[0] = x1; v_[1] = y1; v_[2] = z1; }
54
57 BasicVector3D(const BasicVector3D<T> &) = default;
58
61 template<typename U = T,
62 typename = typename std::enable_if<!std::is_same<U,float>::value >::type>
64 v_[0] = v.x(); v_[1] = v.y(); v_[2] = v.z();
65 }
66
70
73 virtual ~BasicVector3D() = default;
74
75 // -------------------------
76 // Interface to "good old C"
77 // -------------------------
78
81 operator T * () { return v_; }
82
85 operator const T * () const { return v_; }
86
92 operator CLHEP::Hep3Vector () const { return CLHEP::Hep3Vector(x(),y(),z()); }
93
94 // -----------------------------
95 // General arithmetic operations
96 // -----------------------------
97
107 v_[0] += v.v_[0]; v_[1] += v.v_[1]; v_[2] += v.v_[2]; return *this;
108 }
109
112 v_[0] -= v.v_[0]; v_[1] -= v.v_[1]; v_[2] -= v.v_[2]; return *this;
113 }
114
117 v_[0] *= a; v_[1] *= a; v_[2] *= a; return *this;
118 }
119
122 v_[0] /= a; v_[1] /= a; v_[2] /= a; return *this;
123 }
124
125 // ------------
126 // Subscripting
127 // ------------
128
131 T operator()(int i) const { return v_[i]; }
134 T operator[](int i) const { return v_[i]; }
135
138 T & operator()(int i) { return v_[i]; }
141 T & operator[](int i) { return v_[i]; }
142
143 // ------------------------------------
144 // Cartesian coordinate system: x, y, z
145 // ------------------------------------
146
149 T x() const { return v_[0]; }
152 T y() const { return v_[1]; }
155 T z() const { return v_[2]; }
156
159 void setX(T a) { v_[0] = a; }
162 void setY(T a) { v_[1] = a; }
165 void setZ(T a) { v_[2] = a; }
166
169 void set(T x1, T y1, T z1) { v_[0] = x1; v_[1] = y1; v_[2] = z1; }
170
171 // ------------------------------------------
172 // Cylindrical coordinate system: rho, phi, z
173 // ------------------------------------------
174
177 T perp2() const { return x()*x()+y()*y(); }
180 T perp() const { return std::sqrt(perp2()); }
183 T rho() const { return perp(); }
184
187 void setPerp(T rh) {
188 T factor = perp();
189 if (factor > 0) {
190 factor = rh/factor; v_[0] *= factor; v_[1] *= factor;
191 }
192 }
193
194 // ------------------------------------------
195 // Spherical coordinate system: r, phi, theta
196 // ------------------------------------------
197
200 T mag2() const { return x()*x()+y()*y()+z()*z(); }
203 T mag() const { return std::sqrt(mag2()); }
206 T r() const { return mag(); }
209 T phi() const {
210 return x() == 0 && y() == 0 ? 0 : std::atan2(y(),x());
211 }
212
214 T theta() const {
215 return x() == 0 && y() == 0 && z() == 0 ? 0 : std::atan2(perp(),z());
216 }
217
219 T cosTheta() const { T ma = mag(); return ma == 0 ? 1 : z()/ma; }
220
223 T getR() const { return r(); }
226 T getPhi() const { return phi(); }
229 T getTheta() const { return theta(); }
230
233 void setMag(T ma) {
234 T factor = mag();
235 if (factor > 0) {
236 factor = ma/factor; v_[0] *= factor; v_[1] *= factor; v_[2] *= factor;
237 }
238 }
239
241 void setR(T ma) { setMag(ma); }
244 void setPhi(T ph) { T xy = perp(); setX(xy*std::cos(ph)); setY(xy*std::sin(ph)); }
247 void setTheta(T th) {
248 T ma = mag();
249 T ph = phi();
250 set(ma*std::sin(th)*std::cos(ph), ma*std::sin(th)*std::sin(ph), ma*std::cos(th));
251 }
252
253 // ---------------
254 // Pseudo rapidity
255 // ---------------
256
259 T pseudoRapidity() const;
262 T eta() const { return pseudoRapidity(); }
265 T getEta() const { return pseudoRapidity(); }
266
269 void setEta(T a);
270
271 // -------------------
272 // Combine two vectors
273 // -------------------
274
277 T dot(const BasicVector3D<T> & v) const {
278 return x()*v.x()+y()*v.y()+z()*v.z();
279 }
280
284 return BasicVector3D<T>(y()*v.z()-v.y()*z(),
285 z()*v.x()-v.z()*x(),
286 x()*v.y()-v.x()*y());
287 }
288
291 T perp2(const BasicVector3D<T> & v) const {
292 T tot = v.mag2(), s = dot(v);
293 return tot > 0 ? mag2()-s*s/tot : mag2();
294 }
295
298 T perp(const BasicVector3D<T> & v) const {
299 return std::sqrt(perp2(v));
300 }
301
304 T angle(const BasicVector3D<T> & v) const;
305
306 // ---------------
307 // Related vectors
308 // ---------------
309
313 T len = mag();
314 return (len > 0) ?
315 BasicVector3D<T>(x()/len, y()/len, z()/len) : BasicVector3D<T>();
316 }
317
321 T dx = x() < 0 ? -x() : x();
322 T dy = y() < 0 ? -y() : y();
323 T dz = z() < 0 ? -z() : z();
324 if (dx < dy) {
325 return dx < dz ?
326 BasicVector3D<T>(0,z(),-y()) : BasicVector3D<T>(y(),-x(),0);
327 }else{
328 return dy < dz ?
329 BasicVector3D<T>(-z(),0,x()) : BasicVector3D<T>(y(),-x(),0);
330 }
331 }
332
333 // ---------
334 // Rotations
335 // ---------
336
349 };
350
351 /*************************************************************************
352 * *
353 * Non-member functions for BasicVector3D<float> *
354 * *
355 *************************************************************************/
356
361 std::ostream &
362 operator<<(std::ostream &, const BasicVector3D<float> &);
363
368 std::istream &
370
376 operator+(const BasicVector3D<float> & v) { return v; }
377
384 return BasicVector3D<float>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
385 }
386
393 return BasicVector3D<float>(-v.x(), -v.y(), -v.z());
394 }
395
402 return BasicVector3D<float>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
403 }
404
410 operator*(const BasicVector3D<float> & v, double a) {
411 return BasicVector3D<float>(v.x()*static_cast<float>(a), v.y()*static_cast<float>(a), v.z()*static_cast<float>(a));
412 }
413
418 inline float
420 return a.dot(b);
421 }
422
428 operator*(double a, const BasicVector3D<float> & v) {
429 return BasicVector3D<float>(static_cast<float>(a)*v.x(), static_cast<float>(a)*v.y(), static_cast<float>(a)*v.z());
430 }
431
437 operator/(const BasicVector3D<float> & v, double a) {
438 return BasicVector3D<float>(v.x()/static_cast<float>(a), v.y()/static_cast<float>(a), v.z()/static_cast<float>(a));
439 }
440
445 inline bool
447 return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
448 }
449
454 inline bool
456 return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
457 }
458
459 /*************************************************************************
460 * *
461 * Non-member functions for BasicVector3D<double> *
462 * *
463 *************************************************************************/
464
469 std::ostream &
470 operator<<(std::ostream &, const BasicVector3D<double> &);
471
476 std::istream &
478
484 operator+(const BasicVector3D<double> & v) { return v; }
485
492 return BasicVector3D<double>(a.x()+b.x(), a.y()+b.y(), a.z()+b.z());
493 }
494
501 return BasicVector3D<double>(-v.x(), -v.y(), -v.z());
502 }
503
510 return BasicVector3D<double>(a.x()-b.x(), a.y()-b.y(), a.z()-b.z());
511 }
512
518 operator*(const BasicVector3D<double> & v, double a) {
519 return BasicVector3D<double>(v.x()*a, v.y()*a, v.z()*a);
520 }
521
526 inline double
528 return a.dot(b);
529 }
530
536 operator*(double a, const BasicVector3D<double> & v) {
537 return BasicVector3D<double>(a*v.x(), a*v.y(), a*v.z());
538 }
539
545 operator/(const BasicVector3D<double> & v, double a) {
546 return BasicVector3D<double>(v.x()/a, v.y()/a, v.z()/a);
547 }
548
553 inline bool
555 {
556 return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
557 }
558
563 inline bool
565 {
566 return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
567 }
568} /* namespace HepGeom */
569
570#ifdef ENABLE_BACKWARDS_COMPATIBILITY
571// backwards compatibility will be enabled ONLY in CLHEP 1.9
572using namespace HepGeom;
573#endif
574
575#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< 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< float > operator+(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< float > operator/(const BasicVector3D< float > &v, double a)
T operator[](int i) const
T angle(const BasicVector3D< T > &v) const
BasicVector3D< T > & operator*=(double a)
BasicVector3D< double > operator+(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
std::istream & operator>>(std::istream &, BasicVector3D< float > &)
bool operator==(const BasicVector3D< float > &a, const BasicVector3D< float > &b)
BasicVector3D< float > operator-(const BasicVector3D< float > &v)
virtual ~BasicVector3D()=default
bool operator==(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< double > operator+(const BasicVector3D< double > &v)
BasicVector3D(T x1, T y1, T z1)
BasicVector3D< double > operator-(const BasicVector3D< double > &v)
BasicVector3D< T > & rotateY(T a)
BasicVector3D(BasicVector3D< T > &&)=default
BasicVector3D< double > operator/(const BasicVector3D< double > &v, double a)
BasicVector3D< double > operator-(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D(const BasicVector3D< T > &)=default
bool operator!=(const BasicVector3D< double > &a, const BasicVector3D< double > &b)
BasicVector3D< T > unit() const
BasicVector3D< float > operator*(double a, const BasicVector3D< float > &v)
std::istream & operator>>(std::istream &, BasicVector3D< double > &)
BasicVector3D< double > operator*(double a, const BasicVector3D< double > &v)
std::ostream & operator<<(std::ostream &, const BasicVector3D< float > &)
BasicVector3D< T > & operator+=(const BasicVector3D< T > &v)
BasicVector3D(const BasicVector3D< float > &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 > & operator=(const BasicVector3D< T > &)=default
void set(T x1, T y1, T z1)
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
T operator()(int i) const