CLHEP/Geometry/BasicVector3D.h

00001 // -*- C++ -*-
00002 // $Id: BasicVector3D.h,v 1.7 2002/04/19 16:33:38 evc Exp $
00003 // ---------------------------------------------------------------------------
00004 //
00005 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
00006 //
00007 // History:
00008 // 12.06.01 Evgeni Chernyaev - CLHEP-1.7: initial version
00009 //
00010 
00011 #ifndef BASIC_VECTOR3D_H
00012 #define BASIC_VECTOR3D_H
00013 
00014 #include "CLHEP/config/CLHEP.h"
00015 #include "CLHEP/config/iostream.h"
00016 #include "CLHEP/Vector/ThreeVector.h"
00017 
00027 class BasicVector3D {
00028 protected:
00029   Hep3Vector v_;
00030 
00031   // Default constructor. This class should not be instantiated directly.
00032   inline BasicVector3D() : v_(0,0,0) {}
00033 
00034   // Constructor from Hep3Vector.
00035   inline explicit BasicVector3D(const Hep3Vector & v) : v_(v) {}
00036 
00037 public:
00039   enum {
00040     X = 0,                      
00041     Y = 1,                      
00042     Z = 2,                      
00043     NUM_COORDINATES = 3,        
00044     SIZE = NUM_COORDINATES      
00045   };
00046 
00048   ~BasicVector3D() {}
00049 
00051   inline BasicVector3D(const BasicVector3D & v) : v_(v.v_) {}
00052 
00054   inline BasicVector3D(double x, double y, double z) : v_(x,y,z) {}
00055 
00061   inline operator Hep3Vector () const { return v_; }
00062 
00064   inline BasicVector3D &
00065   operator= (const BasicVector3D & v) { v_ = v.v_; return *this; }
00067   inline BasicVector3D &
00068   operator+=(const BasicVector3D & v) { v_ += v.v_; return *this; }
00070   inline BasicVector3D &
00071   operator-=(const BasicVector3D & v) { v_ -= v.v_; return *this; }
00073   inline BasicVector3D & operator*=(double a) { v_ *= a; return *this; }
00075   inline BasicVector3D & operator/=(double a) { v_ /= a; return *this; }
00076 
00078   inline double operator () (int i) const { return v_(i); }
00080   inline double operator [] (int i) const { return v_[i]; }
00081 
00083   inline double & operator () (int i) { return v_(i); }
00085   inline double & operator [] (int i) { return v_[i]; }
00086 
00088   inline double x() const { return v_.x(); }
00090   inline double y() const { return v_.y(); }
00092   inline double z() const { return v_.z(); }
00093 
00095   inline void setX(double a) { v_.setX(a); }
00097   inline void setY(double a) { v_.setY(a); }
00099   inline void setZ(double a) { v_.setZ(a); }
00101   inline void set(double x, double y, double z) { v_.set(x,y,z); }
00102 
00104   inline double phi()      const { return v_.phi(); }
00106   inline double theta()    const { return v_.theta(); }
00108   inline double cosTheta() const { return v_.cosTheta(); }
00110   inline double mag2()     const { return v_.mag2(); }
00112   inline double mag()      const { return v_.mag(); }
00114   inline double r()        const { return v_.r(); }
00116   inline double getR()     const { return v_.getR(); }
00118   inline double getTheta() const { return v_.getTheta(); }
00120   inline double getPhi()   const { return v_.getPhi(); }
00121 
00123   inline void setPhi  (double a) { v_.setPhi(a); }
00125   inline void setTheta(double a) { v_.setTheta(a); }
00127   inline void setMag  (double a) { v_.setMag(a); }
00129   inline void setR    (double a) { v_.setR(a); }
00130 
00132   inline double perp2()  const { return v_.perp2(); }
00134   inline double perp()   const { return v_.perp(); }
00135 
00137   inline double eta()    const { return v_.eta(); }
00139   inline double getEta() const { return v_.getEta(); }
00140 
00142   inline void setPerp(double a) { v_.setPerp(a); }
00143 
00145   inline void setEta(double a) { v_.setEta(a); }
00146 
00148   inline double perp2(const BasicVector3D & v) const { return v_.perp2(v); }
00150   inline double perp(const BasicVector3D & v)  const { return v_.perp(v); }
00151 
00153   inline BasicVector3D unit() const { return BasicVector3D(v_.unit()); } 
00154 
00156   inline BasicVector3D orthogonal() const {
00157     return BasicVector3D(v_.orthogonal());
00158   }
00159 
00161   inline double dot(const BasicVector3D & v) const { return v_.dot(v.v_); }
00162 
00163   // Returns cross product with another 3-vector.
00164   inline BasicVector3D cross(const BasicVector3D & v) const {
00165     return BasicVector3D(v_.cross(v.v_));
00166   }
00167 
00169   inline double angle(const BasicVector3D & v) const {
00170     return v_.angle(v.v_);
00171   }
00172 
00174   inline double pseudoRapidity() const { return v_.pseudoRapidity(); }
00175   
00177   inline BasicVector3D & rotateX(double a) { v_.rotateX(a); return *this; }
00179   inline BasicVector3D & rotateY(double a) { v_.rotateY(a); return *this; }
00181   inline BasicVector3D & rotateZ(double a) { v_.rotateZ(a); return *this; }
00182 
00184   inline BasicVector3D & rotate(double a, const BasicVector3D & v) {
00185     v_.rotate(a,v.v_); return *this;
00186   }
00187 };
00188 
00193 inline HepStd::ostream &
00194 operator<<(HepStd::ostream & os, const BasicVector3D & v) {
00195   return (os << (const Hep3Vector &)(v));
00196 }
00197 
00202 inline HepStd::istream &
00203 operator>>(HepStd::istream & is, BasicVector3D & v) {
00204   Hep3Vector w(v); is >> w; v.set(w.x(),w.y(),w.z()); return is;
00205 }
00206 
00211 inline BasicVector3D
00212 operator+(const BasicVector3D & v) {
00213   return v;
00214 }
00215 
00220 inline BasicVector3D
00221 operator+(const BasicVector3D & a, const BasicVector3D & b) {
00222   return BasicVector3D(a.x()+b.x(),a.y()+b.y(),a.z()+b.z());
00223 }
00224 
00229 inline BasicVector3D
00230 operator-(const BasicVector3D & v) {
00231   return BasicVector3D(-v.x(),-v.y(),-v.z());
00232 }
00233 
00238 inline BasicVector3D
00239 operator-(const BasicVector3D & a, const BasicVector3D & b) {
00240   return BasicVector3D(a.x()-b.x(),a.y()-b.y(),a.z()-b.z());
00241 }
00242 
00247 inline BasicVector3D
00248 operator*(const BasicVector3D & v, double a) {
00249   return BasicVector3D(v.x()*a,v.y()*a,v.z()*a);
00250 }
00251 
00256 inline double
00257 operator*(const BasicVector3D & a, const BasicVector3D & b) {
00258   return a.dot(b);
00259 }
00260 
00265 inline BasicVector3D
00266 operator*(double a, const BasicVector3D & v) {
00267   return BasicVector3D(a*v.x(),a*v.y(),a*v.z());
00268 }
00269 
00274 inline BasicVector3D
00275 operator/(const BasicVector3D & v, double a) {
00276   Hep3Vector w = Hep3Vector(v)/a;
00277   return BasicVector3D(w.x(),w.y(),w.z());
00278 }
00279 
00284 inline bool
00285 operator==(const BasicVector3D & a, const BasicVector3D & b) {
00286   return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
00287 }
00288 
00293 inline bool
00294 operator!=(const BasicVector3D & a, const BasicVector3D & b) {
00295   return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
00296 }
00297 
00298 #endif /* BASIC_VECTOR3D_H */

Class Library for High Energy Physics (version 1.8)