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(double const x, double const y);                 
    Vector(double const x, double const y, double const z); 
    Vector(TVector3 const& pt);                             
    Vector(TLorentzVector const& pt);                       

    void Normalize(); 

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

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

    TLorentzVector ToTLorentzVector()
      const; 

    void compat(Vector const& obj) const;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    inline bool operator!=(Vector const& 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