TwoVector.h

Go to the documentation of this file.

// -*- C++ -*-
// CLASSDOC OFF
// ---------------------------------------------------------------------------
// CLASSDOC ON
//
// This file is a part of the CLHEP - a Class Library for High Energy Physics.
//
// Hep2Vector is a general 2-vector class defining vectors in two 
// dimension using double components.   It comes from the ZOOM
// PlaneVector class (the PhysicsVectors PlaneVector.h will typedef
// PlaneVector to Hep2Vector).
//
// .SS See Also
// ThreeVector.h
//
// .SS Authors
// John Marraffino and Mark Fischler
//
 
#ifndef HEP_TWOVECTOR_H
#define HEP_TWOVECTOR_H
 
#ifdef GNUPRAGMA
#pragma interface
#endif
 
#include <iostream>
 
#include "CLHEP/Vector/ThreeVector.h" 
 
namespace CLHEP {
 
// Declarations of classes and global methods
class Hep2Vector;
std::ostream & operator << (std::ostream &, const Hep2Vector &);
std::istream & operator >> (std::istream &, Hep2Vector &);
inline double operator * (const Hep2Vector & a,const Hep2Vector & b);
inline Hep2Vector operator * (const Hep2Vector & p, double a);
inline Hep2Vector operator * (double a, const Hep2Vector & p);
       Hep2Vector operator / (const Hep2Vector & p, double a);
inline Hep2Vector operator + (const Hep2Vector & a, const Hep2Vector & b);
inline Hep2Vector operator - (const Hep2Vector & a, const Hep2Vector & b);
 
/**
 * @author
 * @ingroup vector
 */
class Hep2Vector {
 
public:
 
  enum { X=0, Y=1, NUM_COORDINATES=2, SIZE=NUM_COORDINATES };
  // Safe indexing of the coordinates when using with matrices, arrays, etc.
 
  inline Hep2Vector( double x = 0.0, double y = 0.0 );
  // The constructor.
 
  inline Hep2Vector(const Hep2Vector & p);
  // The copy constructor.
 
  explicit Hep2Vector( const Hep3Vector & );
  // "demotion" constructor"
  // WARNING -- THIS IGNORES THE Z COMPONENT OF THE Hep3Vector.
  //        SO IN GENERAL, Hep2Vector(v)==v WILL NOT HOLD!
 
  inline ~Hep2Vector();
  // The destructor.
 
  inline double x() const;
  inline double y() const;
  // The components in cartesian coordinate system.
 
         double operator () (int i) const;
  inline double operator [] (int i) const;
  // Get components by index.  0-based.
 
         double & operator () (int i);
  inline double & operator [] (int i);
  // Set components by index.  0-based.
 
  inline void setX(double x);
  inline void setY(double y);
  inline void set (double x, double y);
  // Set the components in cartesian coordinate system.
 
  inline double phi() const;
  // The azimuth angle.
 
  inline double mag2() const;
  // The magnitude squared.
 
  inline double mag() const;
  // The magnitude.
 
  inline double r() const;
  // r in polar coordinates (r, phi):  equal to mag().
 
  inline void setPhi(double phi);
  // Set phi keeping mag constant.
 
  inline void setMag(double r);
  // Set magnitude keeping phi constant.
 
  inline void setR(double r);
  // Set R keeping phi constant.  Same as setMag.
 
  inline void setPolar(double r, double phi);
  // Set by polar coordinates.
 
  inline Hep2Vector & operator = (const Hep2Vector & p);
  // Assignment.
 
  inline bool operator == (const Hep2Vector & v) const;
  inline bool operator != (const Hep2Vector & v) const;
  // Comparisons.
 
  int compare (const Hep2Vector & v) const;
  bool operator > (const Hep2Vector & v) const;
  bool operator < (const Hep2Vector & v) const;
  bool operator>= (const Hep2Vector & v) const;
  bool operator<= (const Hep2Vector & v) const;
  // dictionary ordering according to y, then x component
 
  static inline double getTolerance();
  static double setTolerance(double tol);
 
  double howNear (const Hep2Vector &p) const;
  bool isNear  (const Hep2Vector & p, double epsilon=tolerance) const;
 
  double howParallel (const Hep2Vector &p) const;
  bool isParallel 
        (const Hep2Vector & p, double epsilon=tolerance) const;
 
  double howOrthogonal (const Hep2Vector &p) const;
  bool isOrthogonal
        (const Hep2Vector & p, double epsilon=tolerance) const;
 
  inline Hep2Vector & operator += (const Hep2Vector &p);
  // Addition.
 
  inline Hep2Vector & operator -= (const Hep2Vector &p);
  // Subtraction.
 
  inline Hep2Vector operator - () const;
  // Unary minus.
 
  inline Hep2Vector & operator *= (double a);
  // Scaling with real numbers.
 
  inline Hep2Vector unit() const;
  // Unit vector parallel to this.
 
  inline Hep2Vector orthogonal() const;
  // Vector orthogonal to this.
 
  inline double dot(const Hep2Vector &p) const;
  // Scalar product.
 
  inline double angle(const Hep2Vector &) const;
  // The angle w.r.t. another 2-vector.
 
  void rotate(double);
  // Rotates the Hep2Vector.
 
  operator Hep3Vector () const;
  // Cast a Hep2Vector as a Hep3Vector.
 
  // The remaining methods are friends, thus defined at global scope:
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
  friend std::ostream & operator<< (std::ostream &, const Hep2Vector &);
  // Output to a stream.
 
  inline friend double operator * (const Hep2Vector & a,
                   const Hep2Vector & b);
  // Scalar product.
 
  inline friend Hep2Vector operator * (const Hep2Vector & p, double a);
  // v*c
 
  inline friend Hep2Vector operator * (double a, const Hep2Vector & p);
  // c*v
 
         friend Hep2Vector operator / (const Hep2Vector & p, double a);
  // v/c
 
  inline friend Hep2Vector operator + (const Hep2Vector & a,
                       const Hep2Vector & b);
  // v1+v2
 
  inline friend Hep2Vector operator - (const Hep2Vector & a,
                        const Hep2Vector & b);
  // v1-v2
 
  enum { ZMpvToleranceTicks = 100 };
 
private:
 
  double dx;
  double dy;
  // The components.
 
  static double tolerance;
  // default tolerance criterion for isNear() to return true.
 
};  // Hep2Vector
 
static const Hep2Vector X_HAT2(1.0, 0.0);
static const Hep2Vector Y_HAT2(0.0, 1.0);
 
}  // namespace CLHEP
 
#include "CLHEP/Vector/TwoVector.icc"
 
#endif /* HEP_TWOVECTOR_H */