SimpleVector.h

Go to the documentation of this file.

// SimpleVector.h
#ifndef  HEPMC_SIMPLEVECTOR_H
#define  HEPMC_SIMPLEVECTOR_H

// garren@fnal.gov, July 2006
//
// This header provides a place to hold the doubles which are part of one of 
// three types of physics vectors:
//    momentum 4 vector 
//    position or displacement 4 vector
//    position or displacement 3 vector
//
// For compatibility with existing code, 
// the basic expected geometrical access methods are povided 
// Also, both FourVector and ThreeVector have a templated constructor that will 
// take another vector (HepLorentzVector, GenVector, ...)
//    --> this vector must have the following methods: x(), y(), z()
//    -->  FourVector also requires the t() method
//


#include "HepMC/enable_if.h"
#include "HepMC/is_arithmetic.h"


namespace HepMC {


class FourVector {

public:

  FourVector( double xin, double yin, double zin, double tin=0) 
  : m_x(xin), m_y(yin), m_z(zin), m_t(tin) {}

  FourVector(double t)
  : m_x(0), m_y(0), m_z(0), m_t(t) {}

  FourVector() 
  : m_x(0), m_y(0), m_z(0), m_t(0) {}

  template <class T >
  FourVector( const T& v,
         typename detail::disable_if< detail::is_arithmetic<T>::value, void >::type * = 0 )
  : m_x(v.x()), m_y(v.y()), m_z(v.z()), m_t(v.t()) {}

  FourVector(const FourVector & v)
  : m_x(v.x()), m_y(v.y()), m_z(v.z()), m_t(v.t()) {}

  void swap( FourVector & other );  

  double px() const { return m_x; }  
  double py() const { return m_y; }  
  double pz() const { return m_z; }  
  double e()  const { return m_t; }  

  double x() const { return m_x; }  
  double y() const { return m_y; }  
  double z() const { return m_z; }  
  double t() const { return m_t; }  

  double m2() const;  
  double m() const;   

  double perp2() const;  
  double perp() const;   
  double mag() const;    

  // Get spatial vector components in spherical coordinate system.
  double theta() const;  
  double phi() const;  
  double rho() const;  

  FourVector & operator = (const FourVector &); 

  bool operator == (const FourVector &) const; 
  bool operator != (const FourVector &) const; 

  double pseudoRapidity() const;  
  double eta() const;             

  void set        (double x, double y, double z, double  t);

  void setX(double x) { m_x=x; }  
  void setY(double y) { m_y=y; }  
  void setZ(double z) { m_z=z; }  
  void setT(double t) { m_t=t; }  

  void setPx(double x) { m_x=x; }  
  void setPy(double y) { m_y=y; }  
  void setPz(double z) { m_z=z; }  
  void setE(double t)  { m_t=t; }  

private:

  double m_x;
  double m_y;
  double m_z;
  double m_t;
  
};


class ThreeVector {

public:

  ThreeVector( double xin, double yin =0, double zin =0 ) 
  : m_x(xin), m_y(yin), m_z(zin) {}

  ThreeVector( ) 
  : m_x(0), m_y(0), m_z(0) {}
  
  template <class T >
  ThreeVector( const T& v,
         typename detail::disable_if< detail::is_arithmetic<T>::value, void >::type * = 0 )
  : m_x(v.x()), m_y(v.y()), m_z(v.z()) {}

  ThreeVector(const ThreeVector & v)
  : m_x(v.x()), m_y(v.y()), m_z(v.z()) {}

  void swap( ThreeVector & other );  

  double x() const { return m_x; }  
  double y() const { return m_y; }  
  double z() const { return m_z; }  

  void setX(double x) { m_x=x; }  
  void setY(double y) { m_y=y; }  
  void setZ(double z) { m_z=z; }  
  void set( double x, double y, double z);   

  double phi()   const;  
  double theta() const;  
  double r()     const;  

  double mag() const;  

  void setPhi(double);  
  void setTheta(double);  

  double perp2() const;  
  double perp() const;  

  ThreeVector & operator = (const ThreeVector &); 

  bool operator == (const ThreeVector &) const; 
  bool operator != (const ThreeVector &) const; 

private:

  double m_x;
  double m_y;
  double m_z;

};  


} // HepMC

#include "HepMC/SimpleVector.icc"

#endif  // HEPMC_SIMPLEVECTOR_H