P4ImplPxPyPzE.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
// P4ImplPxPyPzE.h 
// Header file for class P4::Impl::PxPyPzE
// Author: S.Binet<binet@cern.ch>
#ifndef FOURMOM_P4IMPLPXPYPZE_H 
#define FOURMOM_P4IMPLPXPYPZE_H 
 
// STL includes
 
//  CLHEP includes
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Units/SystemOfUnits.h"
 
// EventKernel includes
#include "EventKernel/I4Momentum.h"
 
// FourMom includes
#include "FourMom/Lib/P4BasePxPyPzE.h"
#include "FourMom/FourMomentumError.h"
 
#include <memory>
// Forward declaration
class P4ImplPxPyPzECnv_p1; //> for persistency
 
class P4ImplPxPyPzE : public P4BasePxPyPzE
{ 
  // friends: 
  friend class P4ImplPxPyPzECnv_p1;
 
  // Public methods: 
 public: 
 
  typedef FourMomentumError< P4ImplPxPyPzE>  ErrorType;
 
  P4ImplPxPyPzE();
 
  P4ImplPxPyPzE( const P4ImplPxPyPzE& rhs );
 
  P4ImplPxPyPzE& operator=( const P4ImplPxPyPzE& rhs ); 
 
  P4ImplPxPyPzE( const double px, const  double py,
         const double pz, const  double e );
 
  P4ImplPxPyPzE( const CLHEP::HepLorentzVector& hlv);
 
  explicit P4ImplPxPyPzE( const I4Momentum& theI4M );
 
  explicit P4ImplPxPyPzE( const I4Momentum* const theI4M );
 
  virtual ~P4ImplPxPyPzE(); 
 
  // Const methods: 
 
  double px() const;
  double py() const;
  double pz() const;
  double e() const;
 
  virtual const I4MomentumError* errors() const;
 
  I4Momentum::Kind kind() const { return I4Momentum::P4PXPYPZE; };
 
  // Non-const methods: 
 
  void setPx(const double thePx );
 
  void setPy(const double thePy );
 
  void setPz(const double thePz );
 
  void setE(const double theE );
 
  void set4Mom (const I4Momentum & theI4Mom );
  void set4Mom (const I4Momentum * const theI4Mom );
  void set4Mom (const CLHEP::HepLorentzVector & theHlv );
  void setErrors( const ErrorMatrixPxPyPzE& err);
 
  // Protected data: 
 private: 
 
  double m_px;
  double m_py;
  double m_pz;
  double m_e;
  std::unique_ptr< ErrorType> m_error;
 
}; 
 
// Inline methods: 
 
inline P4ImplPxPyPzE::P4ImplPxPyPzE( ) :
  P4BasePxPyPzE( ),
  m_px ( 0.*CLHEP::GeV ),
  m_py ( 0.*CLHEP::GeV ),
  m_pz ( 0.*CLHEP::GeV ),
  m_e  ( 0.*CLHEP::GeV ),
  m_error(nullptr)
{}
 
inline P4ImplPxPyPzE::P4ImplPxPyPzE( const P4ImplPxPyPzE& rhs ) :
  P4BasePxPyPzE(  ),
  m_px ( rhs.m_px ),
  m_py ( rhs.m_py ),
  m_pz ( rhs.m_pz ),
  m_e  ( rhs.m_e  ),
  m_error(nullptr)
{}
 
inline P4ImplPxPyPzE::P4ImplPxPyPzE( const double px, 
                     const double py, 
                     const double pz, 
                     const double e ) :
  P4BasePxPyPzE( ),
  m_px( px ),
  m_py( py ),
  m_pz( pz ),
  m_e ( e  ),
  m_error(nullptr)
{}
 
inline P4ImplPxPyPzE::P4ImplPxPyPzE( const CLHEP::HepLorentzVector& hlv ) :
  P4BasePxPyPzE( ),
  m_px( hlv.px() ),
  m_py( hlv.py() ),
  m_pz( hlv.pz() ),
  m_e ( hlv.e()  ),
  m_error(nullptr)
{}
 
inline P4ImplPxPyPzE::P4ImplPxPyPzE( const I4Momentum& i4Mom ) :
  P4BasePxPyPzE( ),
  m_px ( i4Mom.px() ),
  m_py ( i4Mom.py() ),
  m_pz ( i4Mom.pz() ),
  m_e  ( i4Mom.e()  ),
  m_error(nullptr)
{}
 
inline P4ImplPxPyPzE::P4ImplPxPyPzE( const I4Momentum* const i4Mom ) :
  P4BasePxPyPzE( ),
  m_px ( i4Mom->px() ),
  m_py ( i4Mom->py() ),
  m_pz ( i4Mom->pz() ),
  m_e  ( i4Mom->e()  ),
  m_error(nullptr)
{}
 
inline P4ImplPxPyPzE::~P4ImplPxPyPzE()
{}
 
inline double P4ImplPxPyPzE::px() const 
{ 
  return m_px;
}
 
inline double P4ImplPxPyPzE::py() const
{ 
  return m_py;
}
 
inline double P4ImplPxPyPzE::pz() const
{ 
  return m_pz;
}
 
inline double P4ImplPxPyPzE::e() const
{ 
  return m_e;
}
 
inline const I4MomentumError* P4ImplPxPyPzE::errors() const
{
  // check if the pointer is empty before dereferencing
  return m_error.get();
}
 
inline void P4ImplPxPyPzE::setPx( const double px ) 
{ 
  m_px = px;
}
 
inline void P4ImplPxPyPzE::setPy( const double py ) 
{ 
  m_py = py;
}
 
inline void P4ImplPxPyPzE::setPz( const double pz ) 
{ 
  m_pz = pz;
}
 
inline void P4ImplPxPyPzE::setE( const double e ) 
{ 
  m_e = e;
}
 
inline void P4ImplPxPyPzE::set4Mom( const I4Momentum& i4Mom )
{
  m_px = i4Mom.px();
  m_py = i4Mom.py();
  m_pz = i4Mom.pz();
  m_e  = i4Mom.e();
}
 
inline void P4ImplPxPyPzE::set4Mom( const I4Momentum* const i4Mom )
{
  this->set4Mom(*i4Mom);
}
 
 
inline void P4ImplPxPyPzE::set4Mom( const CLHEP::HepLorentzVector& hlv )
{
  m_px = hlv.px();
  m_py = hlv.py();
  m_pz = hlv.pz();
  m_e  = hlv.e();
}
 
inline void P4ImplPxPyPzE::setErrors( const ErrorMatrixPxPyPzE& err)
{
  m_error = std::make_unique< ErrorType>( err, *this);
}
 
#endif //> FOURMOM_P4IMPLPXPYPZE_H