TPoint2D.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// $Id: TPoint2D.h,v 1.6 2010/03/31 09:58:59 liucy Exp $
//-----------------------------------------------------------------------------
// Filename : TPoint2D.h
// Section  : Tracking
// Owner    : Yoshi Iwasaki
// Email    : [email protected]
//-----------------------------------------------------------------------------
// Description : A class to represent a point in 2D.
//               See http://bsunsrv1.kek.jp/~yiwasaki/tracking/
//-----------------------------------------------------------------------------
 
#ifndef TPOINT2D_FLAG_
#define TPOINT2D_FLAG_
 
#ifdef TRKRECO_DEBUG_DETAIL
#ifndef TRKRECO_DEBUG
#define TRKRECO_DEBUG
#endif
#endif
#include <math.h>
#define HEP_SHORT_NAMES
#include "CLHEP/Geometry/Vector3D.h"
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
    typedef HepGeom::Vector3D<double> HepVector3D;
#endif
#ifndef CLHEP_POINT3D_H
#include "CLHEP/Geometry/Point3D.h"
#endif
#ifndef ENABLE_BACKWARDS_COMPATIBILITY
    typedef HepGeom::Point3D<double> HepPoint3D;
#endif
 
//class HepPoint3D;
 
/// A class to represent a point in 2D.
class TPoint2D {
 
  public:
    /// Constructors
    TPoint2D();
    TPoint2D(double, double);
    TPoint2D(const HepPoint3D &);
    TPoint2D(const HepVector3D &);
 
    /// Destructor
    virtual ~TPoint2D();
 
  public:// Selectors
    double x(void) const;
    double y(void) const;
    double mag(void) const;
    double mag2(void) const;
    double phi(void) const;
 
  public:// Modifiers
    double x(double);
    double y(double);
 
  public:// Operators
    double dot(const TPoint2D &) const;
    double cross(const TPoint2D &) const;
    TPoint2D unit(void) const;
    TPoint2D operator + (const TPoint2D &) const;
    TPoint2D operator - (const TPoint2D &) const;
    TPoint2D operator - () const;
    bool operator == (const TPoint2D &) const;
 
  private:
    double _p[2];
};
 
std::ostream &
operator << (std::ostream &, const TPoint2D &);
 
//-----------------------------------------------------------------------------
 
#ifdef TPOINT2D_NO_INLINE
#define inline
#else
#undef inline
#define TPOINT2D_INLINE_DEFINE_HERE
#endif
#ifdef TPOINT2D_INLINE_DEFINE_HERE
 
inline
double
TPoint2D::x(void) const {
    return _p[0];
}
 
inline
double
TPoint2D::y(void) const {
    return _p[1];
}
 
inline
double
TPoint2D::x(double a) {
    return _p[0] = a;
}
 
inline
double
TPoint2D::y(double a) {
    return _p[1] = a;
}
 
inline
double
TPoint2D::mag(void) const {
    return sqrt(_p[0] * _p[0] + _p[1] * _p[1]);
}
 
inline
double
TPoint2D::mag2(void) const {
    return _p[0] * _p[0] + _p[1] * _p[1];
}
 
inline
double
TPoint2D::phi(void) const {
    if (_p[0] == 0.0 && _p[1] == 0.0) return 0.;
    double a = atan2(_p[1], _p[0]);
    if (a > 0) return a;
    return a + 2. * M_PI;
}
 
inline
double
TPoint2D::dot(const TPoint2D & a) const {
    return _p[0] * a.x() + _p[1] * a.y();
}
 
inline
double
TPoint2D::cross(const TPoint2D & a) const {
    return _p[0] * a.y() - a.x() * _p[1];
}
 
inline
TPoint2D
TPoint2D::operator + (const TPoint2D & a) const {
    return TPoint2D(_p[0] + a.x(), _p[1] + a.y());
}
 
inline
TPoint2D
TPoint2D::operator - (const TPoint2D & a) const {
    return TPoint2D(_p[0] - a.x(), _p[1] - a.y());
}
 
inline
TPoint2D
TPoint2D::operator - () const {
    return TPoint2D(- _p[0], - _p[1]);
}
 
inline
bool
TPoint2D::operator == (const TPoint2D & a) const {
    if (a.x() == _p[0] && a.y() == _p[1]) return true;
    return false;
}
 
inline
TPoint2D
TPoint2D::unit(void) const {
    double sum2 = _p[0] * _p[0] + _p[1] * _p[1];
    if (sum2 == 0.) return TPoint2D(0., 0.);
    double sum = sqrt(sum2);
    return TPoint2D(_p[0] / sum, _p[1] / sum);
}
 
#endif
#undef inline
 
#endif /* TPOINT2D_FLAG_ */