P4ImplIPtCotThPhiM.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef FOURMOM_P4IMPLIPTCOTTHPHIM_H
#define FOURMOM_P4IMPLIPTCOTTHPHIM_H
 
// STL includes
#include <cmath>
 
// CLHEP includes
#include "CLHEP/Vector/LorentzVector.h"
#include "CLHEP/Units/SystemOfUnits.h"
 
// EventKernel includes
#include "EventKernel/I4Momentum.h"
 
// FourMom includes
#include "FourMom/Lib/P4BaseIPtCotThPhiM.h"
#include "FourMom/FourMomentumError.h"
 
#include <memory>
// forward declare
class P4ImplIPtCotThPhiMCnv_p1; // for persistency

 
class P4ImplIPtCotThPhiM : public P4BaseIPtCotThPhiM
{
  friend class P4ImplIPtCotThPhiMCnv_p1;
 public:
 
  typedef FourMomentumError< P4ImplIPtCotThPhiM>  ErrorType;

  P4ImplIPtCotThPhiM();

  explicit P4ImplIPtCotThPhiM( const P4ImplIPtCotThPhiM& rhs );

  P4ImplIPtCotThPhiM& operator=( const P4ImplIPtCotThPhiM& rhs );

  P4ImplIPtCotThPhiM( const double iPt, const double cotTh, 
              const double phi, const double m );

  explicit P4ImplIPtCotThPhiM( const CLHEP::HepLorentzVector& hlv );

  explicit P4ImplIPtCotThPhiM( const I4Momentum& theI4M );

  explicit P4ImplIPtCotThPhiM( const I4Momentum* const theI4M );

  virtual ~P4ImplIPtCotThPhiM();

  // Const methods: 

 
  double m() const;
  double phi() const;
  double iPt() const;
  double cotTh() const;
 
  virtual const I4MomentumError* errors() const;
 
  I4Momentum::Kind kind() const { return I4Momentum::P4IPTCOTTHPHIM; };


  // Non-const methods: 

  virtual void setIPt( const double theIPt );
  virtual void setCotTh( const double theCotTh );
  virtual void setPhi( const double thePhi );
  virtual void setM( const double theM );

  void setErrors( const ErrorMatrixPtCotThPhiM& err);

  virtual void set4Mom( const I4Momentum & theI4Mom );
  virtual void set4Mom( const I4Momentum * const theI4Mom );
  virtual void set4Mom( const CLHEP::HepLorentzVector & theHlv );

  // Private data: 
 private: 
  
  double m_iPt;

  double m_cotTh;

  double m_phi;

  double m_m;
  
  std::unique_ptr< ErrorType> m_error;
 
};
 
inline P4ImplIPtCotThPhiM::P4ImplIPtCotThPhiM() :
  P4BaseIPtCotThPhiM( ),
  m_iPt   ( 0./CLHEP::GeV ),
  m_cotTh ( 0. ),
  m_phi   ( 0. ),
  m_m     ( 0.*CLHEP::GeV ),
  m_error(nullptr)
{}
 
inline P4ImplIPtCotThPhiM::P4ImplIPtCotThPhiM( const P4ImplIPtCotThPhiM& rhs ):
  P4BaseIPtCotThPhiM( ),
  m_iPt   ( rhs.m_iPt   ),
  m_cotTh ( rhs.m_cotTh ),
  m_phi   ( rhs.m_phi   ),
  m_m     ( rhs.m_m     ),
  m_error(nullptr)
{}
 
inline P4ImplIPtCotThPhiM::P4ImplIPtCotThPhiM( const double iPt, 
                           const double cotTh,
                           const double phi,
                           const double m ) :
  P4BaseIPtCotThPhiM( ),
  m_iPt  ( std::fabs(iPt) ), //inverse Pt is unsigned. std::fabs for safety
  m_cotTh( cotTh ),
  m_phi  ( phi   ),
  m_m    ( m     ),
  m_error(nullptr)
{
  // could enforce phi range convention there
  // const double twopi =2.*M_PI;
  // const double threepi=3.*M_PI;
  // m_phi=fmod(phi+threepi,twopi)-M_PI;
}
 
inline P4ImplIPtCotThPhiM::P4ImplIPtCotThPhiM( const CLHEP::HepLorentzVector& hlv ) :
  P4BaseIPtCotThPhiM( ),
  m_iPt   ( 1./hlv.perp() ),
  m_cotTh ( hlv.pz() / hlv.perp() ),
  m_phi   ( hlv.phi() ),
  m_m     ( hlv.m() ),
  m_error(nullptr)
{}
 
inline P4ImplIPtCotThPhiM::P4ImplIPtCotThPhiM( const I4Momentum & p4 ) :
  P4BaseIPtCotThPhiM( ),
  m_iPt  ( p4.iPt()   ),
  m_cotTh( p4.cotTh() ),
  m_phi  ( p4.phi()   ),
  m_m    ( p4.m()     ),
  m_error(nullptr)
{}
 
inline P4ImplIPtCotThPhiM::P4ImplIPtCotThPhiM( const I4Momentum * const p4 ) :
  P4BaseIPtCotThPhiM( ),
  m_iPt  ( p4->iPt()   ),
  m_cotTh( p4->cotTh() ),
  m_phi  ( p4->phi()   ),
  m_m    ( p4->m()     ),
  m_error(nullptr)
{}
 
inline P4ImplIPtCotThPhiM::~P4ImplIPtCotThPhiM()
{}
 
inline double P4ImplIPtCotThPhiM::m() const
{ 
  return m_m;
}
 
inline double P4ImplIPtCotThPhiM::phi() const
{ 
  return m_phi;
}
 
inline double P4ImplIPtCotThPhiM::iPt() const
{ 
  return m_iPt;
}
 
inline double P4ImplIPtCotThPhiM::cotTh() const
{ 
  return m_cotTh;
}
 
inline const I4MomentumError* P4ImplIPtCotThPhiM::errors() const
{
  return m_error.get();
}
 
// setters
 
inline void P4ImplIPtCotThPhiM::setIPt( const double theIPt ) 
{ 
  m_iPt = theIPt;
}
 
inline void P4ImplIPtCotThPhiM::setCotTh( const double theCotTh )
{ 
  m_cotTh = theCotTh;
}
 
inline void P4ImplIPtCotThPhiM::setPhi( const double thePhi )
{ 
  m_phi = thePhi;
}
 
inline void P4ImplIPtCotThPhiM::setM( const double theM )
{ 
  m_m=theM;
}
 
inline void P4ImplIPtCotThPhiM::set4Mom( const I4Momentum & theI4Mom )
{
  m_iPt   = theI4Mom.iPt();
  m_cotTh = theI4Mom.cotTh();
  m_phi   = theI4Mom.phi();
  m_m     = theI4Mom.m();
}
 
inline void P4ImplIPtCotThPhiM::set4Mom( const I4Momentum * const theI4Mom )
{
  this->set4Mom(*theI4Mom);
}
 
inline void P4ImplIPtCotThPhiM::set4Mom( const CLHEP::HepLorentzVector & hlv )
{
  m_iPt   = 1./hlv.perp();
  m_cotTh = hlv.pz()*m_iPt;
  m_phi   = hlv.phi();
  m_m     = hlv.m();
}
 
inline void P4ImplIPtCotThPhiM::setErrors( const ErrorMatrixPtCotThPhiM& err)
{
  m_error = std::make_unique< ErrorType>(err, *this);
}
 
 
#endif // FOURMOM_P4IMPLIPTCOTTHPHIM_H