CLHEP/Geometry/BasicVector3D.h

// -*- C++ -*-
// $Id: BasicVector3D.h,v 1.1 2001/06/14 13:40:47 evc Exp $
// ---------------------------------------------------------------------------
//
// This file is a part of the CLHEP - a Class Library for High Energy Physics.
//
// BasicVector3D is a base class for HepPoint3D, HepVector3D and HepNormal3D.
// It was implemented to decouple the functionality of those classes from
// the functionality of Hep3Vector.
//
// Author: Evgeni Chernyaev <Evgueni.Tcherniaev@cern.ch>
//
// History:
// 12.06.01 E.Chernyaev - CLHEP-1.7: initial version
//

#ifndef BASIC_VECTOR3D_H
#define BASIC_VECTOR3D_H

#include "CLHEP/config/CLHEP.h"
#include "CLHEP/config/iostream.h"
#include "CLHEP/Vector/ThreeVector.h"

class BasicVector3D {
protected:
  Hep3Vector v_;

  // Default constructor. This class should not be instantiated directly.
  inline BasicVector3D() : v_(0,0,0) {}

public:
  // Safe indexing of the coordinates when using with matrices, arrays, etc.
  enum { X=0, Y=1, Z=2, NUM_COORDINATES=3, SIZE=NUM_COORDINATES };

  // Destructor.
  ~BasicVector3D() {}

  // Copy constructor.
  inline BasicVector3D(const BasicVector3D & v) : v_(v.v_) {}

  // Constructor from three doubles.
  inline BasicVector3D(double x, double y, double z) : v_(x,y,z) {}

  // Constructor from Hep3Vector.
  inline explicit BasicVector3D(const Hep3Vector & v) : v_(v) {}

  // Conversion (cast) to Hep3Vector.
  inline operator const Hep3Vector & () const { return v_; }
  inline operator Hep3Vector & () { return v_; }

  // Modify/assignment
  inline BasicVector3D &
  operator= (const BasicVector3D & v) { v_ = v.v_; return *this; }
  inline BasicVector3D &
  operator+=(const BasicVector3D & v) { v_ += v.v_; return *this; }
  inline BasicVector3D &
  operator-=(const BasicVector3D & v) { v_ -= v.v_; return *this; }
  inline BasicVector3D & operator*=(double a) { v_ *= a; return *this; }
  inline BasicVector3D & operator/=(double a) { v_ /= a; return *this; }

  // Get components by index.
  inline double operator () (int i) const { return v_(i); }
  inline double operator [] (int i) const { return v_[i]; }

  // Set components by index.
  inline double & operator () (int i) { return v_(i); }
  inline double & operator [] (int i) { return v_[i]; }

  // Get components in cartesian coordinate system.
  inline double x() const { return v_.x(); }
  inline double y() const { return v_.y(); }
  inline double z() const { return v_.z(); }

  // Set components in cartesian coordinate system.
  inline void setX(double a) { v_.setX(a); }
  inline void setY(double a) { v_.setY(a); }
  inline void setZ(double a) { v_.setZ(a); }
  inline void set(double x, double y, double z) { v_.set(x,y,z); }

  // Get component in spherical (polar) coordinate system.
  inline double phi()      const { return v_.phi(); }
  inline double theta()    const { return v_.theta(); }
  inline double cosTheta() const { return v_.cosTheta(); }
  inline double mag2()     const { return v_.mag2(); }
  inline double mag()      const { return v_.mag(); }

  // Set component in spherical (polar) coordinate system.
  inline void setPhi  (double a) { v_.setPhi(a); }
  inline void setTheta(double a) { v_.setTheta(a); }
  inline void setMag  (double a) { v_.setMag(a); }

  // Get transverse component squared (rho in cylindrical coordinate system).
  inline double perp2() const { return v_.perp2(); }
  inline double perp()  const { return v_.perp(); }

  // Set transverse component keeping phi and z constant.
  inline void setPerp(double a) { v_.setPerp(a); }

  // The transverse component w.r.t. given axis.
  inline double perp2(const BasicVector3D & v) const { return v_.perp2(v); }
  inline double perp(const BasicVector3D & v)  const { return v_.perp(v); }

  // Unit vector parallel to this.
  inline BasicVector3D unit() const { return BasicVector3D(v_.unit()); } 

  // Vector orthogonal to this.
  inline BasicVector3D orthogonal() const {
    return BasicVector3D(v_.orthogonal());
  }

  // Scalar product.
  inline double dot(const BasicVector3D & v) const { return v_.dot(v.v_); }

  // Cross product.
  inline BasicVector3D cross(const BasicVector3D & v) const {
    return BasicVector3D(v_.cross(v.v_));
  }

  // The angle w.r.t. another 3-vector.
  inline double angle(const BasicVector3D & v) const {
    return v_.angle(v.v_);
  }

  // Returns the pseudo-rapidity, i.e. -ln(tan(theta/2))
  inline double pseudoRapidity() const { return v_.pseudoRapidity(); }
  
  // Rotate around the axes.
  inline BasicVector3D & rotateX(double a) { v_.rotateX(a); return *this; }
  inline BasicVector3D & rotateY(double a) { v_.rotateY(a); return *this; }
  inline BasicVector3D & rotateZ(double a) { v_.rotateZ(a); return *this; }

  // Rotates around the axis specified by another BasicVector3D.
  inline BasicVector3D & rotate(double a, const BasicVector3D & v) {
    v_.rotate(a,v.v_); return *this;
  }
};

// Stream operators
inline HepStd::ostream &
operator<<(HepStd::ostream & os, const BasicVector3D & v) {
  return (os << (const Hep3Vector &)(v));
}
inline HepStd::istream &
operator>>(HepStd::istream & is, BasicVector3D & v) {
  return (is >> (Hep3Vector &)(v));
}

// Arithmetics
inline BasicVector3D
operator+(const BasicVector3D & v) {
  return v;
}
inline BasicVector3D
operator+(const BasicVector3D & a, const BasicVector3D & b) {
  return BasicVector3D(a.x()+b.x(),a.y()+b.y(),a.z()+b.z());
}
inline BasicVector3D
operator-(const BasicVector3D & v) {
  return BasicVector3D(-v.x(),-v.y(),-v.z());
}
inline BasicVector3D
operator-(const BasicVector3D & a, const BasicVector3D & b) {
  return BasicVector3D(a.x()-b.x(),a.y()-b.y(),a.z()-b.z());
}
inline BasicVector3D
operator*(const BasicVector3D & v, double a) {
  return BasicVector3D(v.x()*a,v.y()*a,v.z()*a);
}
inline double
operator*(const BasicVector3D & a, const BasicVector3D & b) {
  return a.dot(b);
}
inline BasicVector3D
operator*(double a, const BasicVector3D & v) {
  return BasicVector3D(a*v.x(),a*v.y(),a*v.z());
}
inline BasicVector3D
operator/(const BasicVector3D & v, double a) {
  return BasicVector3D((const Hep3Vector &)(v)/a);
}

// Comparisons
inline HepBoolean
operator==(const BasicVector3D & a, const BasicVector3D & b) {
  return (a.x()==b.x() && a.y()==b.y() && a.z()==b.z());
}
inline HepBoolean
operator!=(const BasicVector3D & a, const BasicVector3D & b) {
  return (a.x()!=b.x() || a.y()!=b.y() || a.z()!=b.z());
}

#endif /* BASIC_VECTOR3D_H */