Vector3DBase.h

Go to the documentation of this file.

#ifndef GeometryVector_Vector3DBase_h
#define GeometryVector_Vector3DBase_h


#include "DataFormats/GeometryVector/interface/VectorTag.h"
#include "DataFormats/GeometryVector/interface/PV3DBase.h"

template <class T, class FrameTag> 
class Vector3DBase : public PV3DBase<T, VectorTag, FrameTag> {
public:

  typedef PV3DBase<T, VectorTag, FrameTag>    BaseClass;
  typedef Vector3DBase< T, FrameTag>          VectorType;
  typedef typename BaseClass::Cylindrical     Cylindrical;
  typedef typename BaseClass::Spherical       Spherical;
  typedef typename BaseClass::Polar           Polar;
  typedef typename BaseClass::BasicVectorType BasicVectorType;

  Vector3DBase() {}

  template <class U> 
  Vector3DBase( const Vector3DBase<U,FrameTag>& v) : BaseClass( v.basicVector()) {}

  Vector3DBase(const T& x, const T& y, const T& z) : BaseClass(x, y, z) {}

  explicit Vector3DBase( const Cylindrical& set) : BaseClass( set) {}

  explicit Vector3DBase( const Polar& set) : BaseClass( set) {}

  Vector3DBase(const Geom::Theta<T>& th, 
           const Geom::Phi<T>& ph, const T& r) : BaseClass(th,ph,r) {}

  template <class U>
  explicit Vector3DBase( const Basic3DVector<U>& v) : BaseClass(v) {}

  Vector3DBase unit() const { return Vector3DBase( this->basicVector().unit());}

  // equality
  bool operator==(const Vector3DBase & rh) const {
    return this->basicVector()==rh.basicVector();
  }


  template <class U> 
  Vector3DBase& operator+= ( const Vector3DBase< U, FrameTag>& v) {
    this->theVector += v.basicVector();
    return *this;
  } 
    
  template <class U> 
  Vector3DBase& operator-= ( const Vector3DBase< U, FrameTag>& v) {
    this->theVector -= v.basicVector();
    return *this;
  } 
    
  Vector3DBase operator-() const { return Vector3DBase(-this->basicVector());}


  Vector3DBase& operator*= ( const T& t) { 
    this->theVector *= t;
    return *this;
  } 

  Vector3DBase& operator/= ( const T& t) { 
    this->theVector /= t;
    return *this;
  } 

  template <class U> 
  typename PreciseFloatType<T,U>::Type 
  dot( const Vector3DBase< U, FrameTag>& v) const { 
    return this->theVector.dot( v.basicVector());
  }

  template <class U> 
  Vector3DBase< typename PreciseFloatType<T,U>::Type, FrameTag> 
  cross( const  Vector3DBase< U, FrameTag>& v) const {
    typedef Vector3DBase< typename PreciseFloatType<T,U>::Type, FrameTag> RT;
    return RT( this->theVector.cross( v.basicVector()));
  }

};

template <class T, class U, class FrameTag>
inline Vector3DBase<typename PreciseFloatType<T,U>::Type, FrameTag>
operator+( const Vector3DBase<T, FrameTag>& v1, const Vector3DBase<U, FrameTag>& v2) {
  typedef Vector3DBase<typename PreciseFloatType<T,U>::Type, FrameTag> RT;
  return RT(v1.basicVector() + v2.basicVector());
}

template <class T, class U, class FrameTag>
inline Vector3DBase<typename PreciseFloatType<T,U>::Type, FrameTag>
operator-( const Vector3DBase<T, FrameTag>& v1, const Vector3DBase<U, FrameTag>& v2) {
  typedef Vector3DBase<typename PreciseFloatType<T,U>::Type, FrameTag> RT;
  return RT(v1.basicVector() - v2.basicVector());
}

template <class T, class U, class FrameTag>
inline typename PreciseFloatType<T,U>::Type
operator*( const Vector3DBase<T, FrameTag>& v1, const Vector3DBase<U, FrameTag>& v2) {
  return v1.basicVector() * v2.basicVector();
}

template <class T, class FrameTag, class Scalar>
inline Vector3DBase<T, FrameTag> 
operator*( const Vector3DBase<T, FrameTag>& v, const Scalar& s) {
  return Vector3DBase<T, FrameTag>( v.basicVector() * s);
}

template <class T, class FrameTag, class Scalar>
inline Vector3DBase<T, FrameTag> 
operator*( const Scalar& s, const Vector3DBase<T, FrameTag>& v) {
  return Vector3DBase<T, FrameTag>( v.basicVector() * s);
}

template <class T, class FrameTag, class Scalar>
inline Vector3DBase<T, FrameTag> 
operator/( const Vector3DBase<T, FrameTag>& v, const Scalar& s) {
  return Vector3DBase<T, FrameTag>( v.basicVector() / s);
}

#endif // GeometryVector_Vector3DBase_h