GeoVector.h

Go to the documentation of this file.

#ifndef BASICTOOL_GEOVECTOR_H
#define BASICTOOL_GEOVECTOR_H

#include "GeoAlgoConstants.h"
#include "GeoAlgoException.h"
#include <TVector3.h>
#include <TLorentzVector.h>

namespace geoalgo {

  // Forward declaration (don't worry)
  class Trajectory;
  class LineSegment;
  class HalfLine;
  class Sphere;
  class GeoAlgo;

  class Vector : public std::vector<double> {
    friend class Trajectory;
    friend class HalfLine;
    friend class LineSegment;
    friend class Sphere;
    friend class GeoAlgo;
  public:
    Vector() : std::vector<double>()
    {}

    Vector(size_t n) : std::vector<double>(n,kINVALID_DOUBLE)
    {}

    Vector(const std::vector<double> &obj) : std::vector<double>(obj)
    {}


    Vector(const double x, const double y);                 
    Vector(const double x, const double y, const double z); 
    Vector(const TVector3 &pt);                             
    Vector(const TLorentzVector &pt);                       
    
    virtual ~Vector(){} 

    void   Normalize(); 
    
    bool   IsValid () const; 
    double SqLength() const; 
    double Length  () const; 
    Vector Dir     () const; 
    double Phi     () const; 
    double Theta   () const; 

    double SqDist(const Vector &obj) const; 
    double Dist  (const Vector& obj) const; 
    double Dot   (const Vector &obj) const; 
    Vector Cross (const Vector &obj) const; 
    double Angle (const Vector &obj) const; 

    TLorentzVector ToTLorentzVector() const; 

    void compat(const Vector& obj) const;

    void RotateX(const double& theta);
    void RotateY(const double& theta);
    void RotateZ(const double& theta);

  protected:

    double _SqDist_(const Vector& obj) const;
    double _Dist_(const Vector& obj) const;
    double _Dot_(const Vector& obj) const;
    Vector _Cross_(const Vector& obj) const;
    double _Angle_(const Vector& obj) const;

  public:
    //
    // binary/uniry operators
    //
    inline Vector& operator+=(const Vector& rhs) { 
      for(size_t i=0; i<size(); ++i) (*this)[i] += rhs[i];
      return *this;
    }

    inline Vector& operator-=(const Vector& rhs) {
      for(size_t i=0; i<size(); ++i) (*this)[i] -= rhs[i];
      return *this;
    }

    inline Vector& operator*=(const double rhs) {
      for(auto &v : *this) v *= rhs;
      return *this;
    }

    inline Vector& operator/=(const double rhs) {
      for(auto &v : *this) v /= rhs;
      return *this;
    }

    inline Vector& operator=(const Vector& rhs) {
      this->resize(rhs.size());
      for(size_t i=0; i<rhs.size(); ++i) (*this)[i]=rhs[i];
      return (*this);
    }

    inline Vector operator+(const Vector& rhs) const
    { 
      Vector res((*this));
      res+=rhs;
      return res;
    }

    inline Vector operator-(const Vector& rhs) const
    { 
      Vector res((*this));
      res-=rhs;
      return res;
    }

    inline double operator*(const Vector& rhs) const
    { 
      double res=0;
      for(size_t i=0; i<size(); ++i) res += (*this)[i] * rhs[i];
      return res;
    }

    inline Vector operator*(const double& rhs) const
    {
      Vector res((*this));
      res *= rhs;
      return res;
    }

    inline Vector operator/(const double& rhs) const
    {
      Vector res((*this));
      res /= rhs;
      return res;
    }

    inline bool operator< ( const Vector& rhs ) const 
    { 
      compat(rhs);
      for(size_t i=0; i<size(); ++i)
        if((*this)[i] < rhs[i]) return true;
      return false;
    }

    inline bool operator< ( const double& rhs) const 
    { return Length() < rhs; }

    inline bool operator== ( const Vector& rhs) const
    { 
      compat(rhs); 
      for(size_t i=0; i<size(); ++i) 
        if((*this)[i] != rhs[i]) return false;
      return true;
    }

    inline bool operator!= ( const Vector& rhs) const
    { return !(*this == rhs); }

    #ifndef __CINT__
    friend std::ostream& operator << (std::ostream &o, ::geoalgo::Vector const& a)
    { o << "Vector ("; for(auto const& v : a) o << v << " ";
      o << ")";
      return o;
    }
    #endif

  };

  typedef Vector Vector_t;
  typedef Vector Point_t;
}

// Define a pointer comparison                                                                                                                     
#ifndef __GCCXML__
namespace std {
  template <>
  class less<geoalgo::Vector*>
  {
  public:
    bool operator()( const geoalgo::Vector* lhs, const geoalgo::Vector* rhs )
    { return (*lhs) < (*rhs); }
  };
}
#endif

#endif
 // end of doxygen group