CLHEP/Vector/ThreeVector.icc

0001 // -*- C++ -*-
0002 // ---------------------------------------------------------------------------
0003 //
0004 // This file is a part of the CLHEP - a Class Library for High Energy Physics.
0005 //
0006 // This is the definitions of the inline member functions of the
0007 // Hep3Vector class.
0008 //
0009
0010 #include <cmath>
0011
0012 namespace CLHEP {
0013
0014 // ------------------
0015 // Access to elements
0016 // ------------------
0017
0018 // x, y, z
0019
0020 inline double & Hep3Vector::operator[] (int i)       { return data[i]; }
0021 inline double   Hep3Vector::operator[] (int i) const { return data[i]; }
0022
0023 inline double Hep3Vector::x() const { return (*this)[X]; }
0024 inline double Hep3Vector::y() const { return (*this)[Y]; }
0025 inline double Hep3Vector::z() const { return (*this)[Z]; }
0026
0027 inline double Hep3Vector::getX() const { return (*this)[X]; }
0028 inline double Hep3Vector::getY() const { return (*this)[Y]; }
0029 inline double Hep3Vector::getZ() const { return (*this)[Z]; }
0030
0031 inline void Hep3Vector::setX(double x) { (*this)[X] = x; }
0032 inline void Hep3Vector::setY(double y) { (*this)[Y] = y; }
0033 inline void Hep3Vector::setZ(double z) { (*this)[Z] = z; }
0034
0035 inline void Hep3Vector::set(double x, double y, double z) {
0036   (*this)[X] = x;
0037   (*this)[Y] = y;
0038   (*this)[Z] = z;
0039 }
0040
0041 inline double Hep3Vector::operator () (int i) const {
0042   return data[i];
0043 }
0044
0045 inline double & Hep3Vector::operator () (int i) {
0046   return data[i];
0047 }
0048
0049 // --------------
0050 // Global methods
0051 // --------------
0052
0053 inline Hep3Vector operator + (const Hep3Vector & a, const Hep3Vector & b) {
0054   return Hep3Vector(a.x() + b.x(), a.y() + b.y(), a.z() + b.z());
0055 }
0056
0057 inline Hep3Vector operator - (const Hep3Vector & a, const Hep3Vector & b) {
0058   return Hep3Vector(a.x() - b.x(), a.y() - b.y(), a.z() - b.z());
0059 }
0060
0061 inline Hep3Vector operator * (const Hep3Vector & p, double a) {
0062   return Hep3Vector(a*p.x(), a*p.y(), a*p.z());
0063 }
0064
0065 inline Hep3Vector operator * (double a, const Hep3Vector & p) {
0066   return Hep3Vector(a*p.x(), a*p.y(), a*p.z());
0067 }
0068
0069 inline double operator * (const Hep3Vector & a, const Hep3Vector & b) {
0070   return a.dot(b);
0071 }
0072
0073 // --------------------------
0074 // Set in various coordinates
0075 // --------------------------
0076
0077 inline void Hep3Vector::setRThetaPhi
0078           ( double r1, double theta1, double phi1 ) {
0079   setSpherical (r1, theta1, phi1);
0080 }
0081
0082 inline void Hep3Vector::setREtaPhi
0083           ( double r1, double eta1,  double phi1 ) {
0084   setSpherical (r1, 2*std::atan(std::exp(-eta1)), phi1);
0085 }
0086
0087 inline void Hep3Vector::setRhoPhiZ
0088           ( double rho1, double phi1, double z1) {
0089   setCylindrical (rho1, phi1, z1);
0090 }
0091
0092 // ------------
0093 // Constructors
0094 // ------------
0095
0096 inline Hep3Vector::Hep3Vector()
0097   : data{0.0, 0.0, 0.0} {}
0098 inline Hep3Vector::Hep3Vector(double x)
0099   : data{ x , 0.0, 0.0} {}
0100 inline Hep3Vector::Hep3Vector(double x, double y)
0101   : data{ x ,  y , 0.0} {}
0102 inline Hep3Vector::Hep3Vector(double x, double y, double z)
0103   : data{ x ,  y ,  z } {}
0104
0105 inline Hep3Vector::Hep3Vector(const Hep3Vector & p)
0106   : data{p.x(), p.y(), p.z()} {}
0107
0108 inline Hep3Vector::~Hep3Vector() {}
0109
0110 inline Hep3Vector & Hep3Vector::operator = (const Hep3Vector & p) {
0111   set(p.x(), p.y(), p.z());
0112   return *this;
0113 }
0114
0115 // ------------------
0116 // Access to elements
0117 // ------------------
0118
0119 // r, theta, phi
0120
0121 inline double Hep3Vector::mag2() const { return x()*x() + y()*y() + z()*z(); }
0122 inline double Hep3Vector::mag()  const { return std::sqrt(mag2()); }
0123 inline double Hep3Vector::r()    const { return mag(); }
0124
0125 inline double Hep3Vector::theta()   const {
0126   return x() == 0.0 && y() == 0.0 && z() == 0.0 ? 0.0 : std::atan2(perp(),z());
0127 }
0128 inline double Hep3Vector::phi() const {
0129   return x() == 0.0 && y() == 0.0 ? 0.0 : std::atan2(y(),x());
0130 }
0131
0132 inline double Hep3Vector::getR()     const { return mag();   }
0133 inline double Hep3Vector::getTheta() const { return theta(); }
0134 inline double Hep3Vector::getPhi()   const { return phi();   }
0135 inline double Hep3Vector::angle()    const { return theta(); }
0136
0137 inline double Hep3Vector::cosTheta() const {
0138   double ptot = mag();
0139   return ptot == 0.0 ? 1.0 : z()/ptot;
0140 }
0141
0142 inline double Hep3Vector::cos2Theta() const {
0143   double ptot2 = mag2();
0144   return ptot2 == 0.0 ? 1.0 : z()*z()/ptot2;
0145 }
0146
0147 inline void Hep3Vector::setR(double r1) { setMag(r1); }
0148
0149 inline void Hep3Vector::setTheta(double th) {
0150   double ma   = mag();
0151   double ph   = phi();
0152   setX(ma*std::sin(th)*std::cos(ph));
0153   setY(ma*std::sin(th)*std::sin(ph));
0154   setZ(ma*std::cos(th));
0155 }
0156
0157 inline void Hep3Vector::setPhi(double ph) {
0158   double xy   = perp();
0159   setX(xy*std::cos(ph));
0160   setY(xy*std::sin(ph));
0161 }
0162
0163 // perp, eta,
0164
0165 inline double Hep3Vector::perp2()  const { return x()*x() + y()*y(); }
0166 inline double Hep3Vector::perp()   const { return std::sqrt(perp2()); }
0167 inline double Hep3Vector::rho()    const { return perp();  }
0168 inline double Hep3Vector::eta()    const { return pseudoRapidity();}
0169
0170 inline double Hep3Vector::getRho() const { return perp();  }
0171 inline double Hep3Vector::getEta() const { return pseudoRapidity();}
0172
0173 inline void Hep3Vector::setPerp(double r1) {
0174   double p = perp();
0175   if (p != 0.0) {
0176     (*this)[X] *= r1/p;
0177     (*this)[Y] *= r1/p;
0178   }
0179 }
0180 inline void Hep3Vector::setRho(double rho1) { setPerp (rho1); }
0181
0182 // ----------
0183 // Comparison
0184 // ----------
0185
0186 inline bool Hep3Vector::operator == (const Hep3Vector& v) const {
0187   return (v.x()==x() && v.y()==y() && v.z()==z()) ? true : false;
0188 }
0189
0190 inline bool Hep3Vector::operator != (const Hep3Vector& v) const {
0191   return (v.x()!=x() || v.y()!=y() || v.z()!=z()) ? true : false;
0192 }
0193
0194 inline double Hep3Vector::getTolerance () {
0195   return tolerance;
0196 }
0197
0198 // ----------
0199 // Arithmetic
0200 // ----------
0201
0202 inline Hep3Vector& Hep3Vector::operator += (const Hep3Vector & p) {
0203   (*this)[X] += p.x();
0204   (*this)[Y] += p.y();
0205   (*this)[Z] += p.z();
0206   return *this;
0207 }
0208
0209 inline Hep3Vector& Hep3Vector::operator -= (const Hep3Vector & p) {
0210   (*this)[X] -= p.x();
0211   (*this)[Y] -= p.y();
0212   (*this)[Z] -= p.z();
0213   return *this;
0214 }
0215
0216 inline Hep3Vector Hep3Vector::operator - () const {
0217   return Hep3Vector(-x(), -y(), -z());
0218 }
0219
0220 inline Hep3Vector& Hep3Vector::operator *= (double a) {
0221   (*this)[X] *= a;
0222   (*this)[Y] *= a;
0223   (*this)[Z] *= a;
0224   return *this;
0225 }
0226
0227 // -------------------
0228 // Combine two Vectors
0229 // -------------------
0230
0231 inline double Hep3Vector::diff2(const Hep3Vector & p) const {
0232   return (*this-p).mag2();
0233 }
0234
0235 inline double Hep3Vector::dot(const Hep3Vector & p) const {
0236   return x()*p.x() + y()*p.y() + z()*p.z();
0237 }
0238
0239 inline Hep3Vector Hep3Vector::cross(const Hep3Vector & p) const {
0240   return Hep3Vector(y()*p.z()-p.y()*z(), z()*p.x()-p.z()*x(), x()*p.y()-p.x()*y());
0241 }
0242
0243 inline double Hep3Vector::perp2(const Hep3Vector & p)  const {
0244   double tot = p.mag2();
0245   double ss  = dot(p);
0246   return tot > 0.0 ? mag2()-ss*ss/tot : mag2();
0247 }
0248
0249 inline double Hep3Vector::perp(const Hep3Vector & p) const {
0250   return std::sqrt(perp2(p));
0251 }
0252
0253 inline Hep3Vector Hep3Vector::perpPart () const {
0254   return Hep3Vector (x(), y(), 0);
0255 }
0256 inline Hep3Vector Hep3Vector::project () const {
0257   return Hep3Vector (0, 0, z());
0258 }
0259
0260 inline Hep3Vector Hep3Vector::perpPart (const Hep3Vector & v2) const {
0261   return ( *this - project(v2) );
0262 }
0263
0264 inline double Hep3Vector::angle(const Hep3Vector & q) const {
0265   return std::acos(cosTheta(q));
0266 }
0267
0268 inline double Hep3Vector::theta(const Hep3Vector & q) const {
0269   return angle(q);
0270 }
0271
0272 inline double Hep3Vector::azimAngle(const Hep3Vector & v2) const {
0273   return deltaPhi(v2);
0274 }
0275
0276 // ----------
0277 // Properties
0278 // ----------
0279
0280 inline Hep3Vector Hep3Vector::unit() const {
0281   double  tot = mag2();
0282   Hep3Vector p(x(),y(),z());
0283   return tot > 0.0 ? p *= (1.0/std::sqrt(tot)) : p;
0284 }
0285
0286 inline Hep3Vector Hep3Vector::orthogonal() const {
0287   double xx = x() < 0.0 ? -x() : x();
0288   double yy = y() < 0.0 ? -y() : y();
0289   double zz = z() < 0.0 ? -z() : z();
0290   if (xx < yy) {
0291     return xx < zz ? Hep3Vector(0,z(),-y()) : Hep3Vector(y(),-x(),0);
0292   }else{
0293     return yy < zz ? Hep3Vector(-z(),0,x()) : Hep3Vector(y(),-x(),0);
0294   }
0295 }
0296
0297 }  // namespace CLHEP