GeoVector.h

Go to the documentation of this file.

#ifndef BASICTOOL_GEOVECTOR_H
#define BASICTOOL_GEOVECTOR_H

#include "larcorealg/GeoAlgo/GeoAlgoConstants.h"

#include "TLorentzVector.h"
#include "TVector3.h"

#include <functional>
#include <ostream>
#include <stddef.h>
#include <vector>

namespace 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);                       

    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
namespace std {
  template <>
  class less<geoalgo::Vector*> {
  public:
    bool operator()(const geoalgo::Vector* lhs, const geoalgo::Vector* rhs)
    {
      return (*lhs) < (*rhs);
    }
  };
}

#endif
 // end of doxygen group