/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_14/src/DataFormats/GeometryVector/interface/Basic3DVectorLD.h

Go to the documentation of this file.

#ifndef GeometryVector_Basic3DVectorLD_h
#define GeometryVector_Basic3DVectorLD_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) {}

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


#ifndef __REFLEX__
  // 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  

  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;


#endif // GeometryVector_Basic3DVectorLD_h