Basic3DVectorLD.h

Go to the documentation of this file.

#ifndef GeometryVector_Basic3DVectorLD_h
#define GeometryVector_Basic3DVectorLD_h

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "extBasic3DVector.h"
// long double specialization
template <>
class Basic3DVector<long double> {
public:
  typedef long double T;
  typedef T ScalarType;
  typedef Geom::Cylindrical2Cartesian<T> Cylindrical;
  typedef Geom::Spherical2Cartesian<T> Spherical;
  typedef Spherical Polar;  // synonym

  typedef Basic3DVector<T> MathVector;

  Basic3DVector() : theX(0), theY(0), theZ(0), theW(0) {}

  Basic3DVector(const Basic3DVector& p) : theX(p.x()), theY(p.y()), theZ(p.z()), theW(0) {}

  template <class U>
  Basic3DVector(const Basic3DVector<U>& p) : theX(p.x()), theY(p.y()), theZ(p.z()), theW(0) {}

  Basic3DVector(const Basic2DVector<T>& p) : theX(p.x()), theY(p.y()), theZ(0), theW(0) {}

  Basic3DVector& operator=(const Basic3DVector&) = default;

  template <class OtherPoint>
  explicit Basic3DVector(const OtherPoint& p) : theX(p.x()), theY(p.y()), theZ(p.z()), theW(0) {}

#ifdef USE_SSEVECT
  // constructor from Vec4
  template <typename U>
  Basic3DVector(mathSSE::Vec4<U> const& iv) : theX(iv.arr[0]), theY(iv.arr[1]), theZ(iv.arr[2]), theW(0) {}
#endif
#ifdef USE_EXTVECT
  // constructor from Vec4
  template <typename U>
  Basic3DVector(Vec4<U> const& iv) : theX(iv[0]), theY(iv[1]), theZ(iv[2]), theW(0) {}
#endif

  Basic3DVector(const T& x, const T& y, const T& z) : theX(x), theY(y), theZ(z), theW(0) {}

  template <typename U>
  Basic3DVector(const Geom::Theta<U>& theta, const Geom::Phi<U>& phi, const T& r) {
    Polar p(theta.value(), phi.value(), r);
    theX = p.x();
    theY = p.y();
    theZ = p.z();
  }

  T x() const { return theX; }

  T y() const { return theY; }

  T z() const { return theZ; }

  Basic2DVector<T> xy() const { return Basic2DVector<T>(theX, theY); }

  // equality
  bool operator==(const Basic3DVector& rh) const { return x() == rh.x() && y() == rh.y() && z() == rh.z(); }

  T mag2() const { return x() * x() + y() * y() + z() * z(); }

  T mag() const { return std::sqrt(mag2()); }

  T perp2() const { return x() * x() + y() * y(); }

  T perp() const { return std::sqrt(perp2()); }

  T transverse() const { return perp(); }

  T barePhi() const { return std::atan2(y(), x()); }
  Geom::Phi<T> phi() const { return Geom::Phi<T>(barePhi()); }

  T bareTheta() const { return std::atan2(perp(), z()); }
  Geom::Theta<T> theta() const { return Geom::Theta<T>(std::atan2(perp(), z())); }

  // T eta() const { return -log( tan( theta()/2.));}
  T eta() const { return detailsBasic3DVector::eta(x(), y(), z()); }  // correct

  Basic3DVector unit() const {
    T my_mag = mag2();
    if (my_mag == 0)
      return *this;
    my_mag = T(1) / std::sqrt(my_mag);
    Basic3DVector ret(*this);
    return ret *= my_mag;
  }

  template <class U>
  Basic3DVector& operator+=(const Basic3DVector<U>& p) {
    theX += p.x();
    theY += p.y();
    theZ += p.z();
    return *this;
  }

  template <class U>
  Basic3DVector& operator-=(const Basic3DVector<U>& p) {
    theX -= p.x();
    theY -= p.y();
    theZ -= p.z();
    return *this;
  }

  Basic3DVector operator-() const { return Basic3DVector(-x(), -y(), -z()); }

  Basic3DVector& operator*=(T t) {
    theX *= t;
    theY *= t;
    theZ *= t;
    return *this;
  }

  Basic3DVector& operator/=(T t) {
    t = T(1) / t;
    theX *= t;
    theY *= t;
    theZ *= t;
    return *this;
  }

  T dot(const Basic3DVector& v) const { return x() * v.x() + y() * v.y() + z() * v.z(); }

  template <class U>
  typename PreciseFloatType<T, U>::Type dot(const Basic3DVector<U>& v) const {
    return x() * v.x() + y() * v.y() + z() * v.z();
  }

  Basic3DVector cross(const Basic3DVector& v) const {
    return Basic3DVector(y() * v.z() - v.y() * z(), z() * v.x() - v.z() * x(), x() * v.y() - v.x() * y());
  }

  template <class U>
  Basic3DVector<typename PreciseFloatType<T, U>::Type> cross(const Basic3DVector<U>& v) const {
    return Basic3DVector<typename PreciseFloatType<T, U>::Type>(
        y() * v.z() - v.y() * z(), z() * v.x() - v.z() * x(), x() * v.y() - v.x() * y());
  }

private:
  T theX;
  T theY;
  T theZ;
  T theW;
}
#ifndef __CINT__
__attribute__((aligned(16)))
#endif
;

inline Basic3DVector<long double> operator+(const Basic3DVector<long double>& a, const Basic3DVector<long double>& b) {
  typedef Basic3DVector<long double> RT;
  return RT(a.x() + b.x(), a.y() + b.y(), a.z() + b.z());
}
inline Basic3DVector<long double> operator-(const Basic3DVector<long double>& a, const Basic3DVector<long double>& b) {
  typedef Basic3DVector<long double> RT;
  return RT(a.x() - b.x(), a.y() - b.y(), a.z() - b.z());
}

template <class U>
inline Basic3DVector<typename PreciseFloatType<long double, U>::Type> operator+(const Basic3DVector<long double>& a,
                                                                                const Basic3DVector<U>& b) {
  typedef Basic3DVector<typename PreciseFloatType<long double, U>::Type> RT;
  return RT(a.x() + b.x(), a.y() + b.y(), a.z() + b.z());
}

template <class U>
inline Basic3DVector<typename PreciseFloatType<long double, U>::Type> operator+(const Basic3DVector<U>& a,
                                                                                const Basic3DVector<long double>& b) {
  typedef Basic3DVector<typename PreciseFloatType<long double, U>::Type> RT;
  return RT(a.x() + b.x(), a.y() + b.y(), a.z() + b.z());
}

template <class U>
inline Basic3DVector<typename PreciseFloatType<long double, U>::Type> operator-(const Basic3DVector<long double>& a,
                                                                                const Basic3DVector<U>& b) {
  typedef Basic3DVector<typename PreciseFloatType<long double, U>::Type> RT;
  return RT(a.x() - b.x(), a.y() - b.y(), a.z() - b.z());
}

template <class U>
inline Basic3DVector<typename PreciseFloatType<long double, U>::Type> operator-(const Basic3DVector<U>& a,
                                                                                const Basic3DVector<long double>& b) {
  typedef Basic3DVector<typename PreciseFloatType<long double, U>::Type> RT;
  return RT(a.x() - b.x(), a.y() - b.y(), a.z() - b.z());
}

// template <>
inline long double operator*(const Basic3DVector<long double>& v1, const Basic3DVector<long double>& v2) {
  return v1.dot(v2);
}

template <class U>
inline typename PreciseFloatType<long double, U>::Type operator*(const Basic3DVector<long double>& v1,
                                                                 const Basic3DVector<U>& v2) {
  return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
}

template <class U>
inline typename PreciseFloatType<long double, U>::Type operator*(const Basic3DVector<U>& v1,
                                                                 const Basic3DVector<long double>& v2) {
  return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
}

//template <>
inline Basic3DVector<long double> operator*(const Basic3DVector<long double>& v, long double t) {
  return Basic3DVector<long double>(v.x() * t, v.y() * t, v.z() * t);
}

// template <>
inline Basic3DVector<long double> operator*(long double t, const Basic3DVector<long double>& v) {
  return Basic3DVector<long double>(v.x() * t, v.y() * t, v.z() * t);
}

template <typename S>
inline Basic3DVector<long double> operator*(S t, const Basic3DVector<long double>& v) {
  return static_cast<long double>(t) * v;
}

template <typename S>
inline Basic3DVector<long double> operator*(const Basic3DVector<long double>& v, S t) {
  return static_cast<long double>(t) * v;
}

template <typename S>
inline Basic3DVector<long double> operator/(const Basic3DVector<long double>& v, S s) {
  long double t = 1 / s;
  return v * t;
}

typedef Basic3DVector<long double> Basic3DVectorLD;

#ifdef __clang__
#pragma clang diagnostic pop
#endif

#endif  // GeometryVector_Basic3DVectorLD_h