xAOD::TrackingHelpers Namespace Reference

Functions
void	checkTPAndDefiningParamCov (const xAOD::TrackParticle *tp)
void	checkTPAndDefiningParamCovDiag (const xAOD::TrackParticle *tp)
double	d0significance (const xAOD::TrackParticle *tp, double d0_uncert_beam_spot_2)
double	sqr (double a)
	convenience method to calculate the square of a value. More...
double	d0significance (const xAOD::TrackParticle *tp)
	Get the impact parameter significance of a track particle in the r-phi plane. More...
double	d0significanceUnsafe (const xAOD::TrackParticle *tp)
	Unsafe version of d0significance. More...
double	d0UncertaintyBeamSpot2 (double track_phi0, double beam_sigma_x, double beam_sigma_y, double beam_sigma_xy)
	calculate the squared d0 uncertainty component due to the size of the beam spot. More...
double	d0significance (const xAOD::TrackParticle *tp, double beam_sigma_x, double beam_sigma_y, double beam_sigma_xy)
	Get the impact parameter significance of a track particle in the r-phi plane where the d0 uncertainty takes the finite beamspot width into account. More...
double	d0significanceUnsafe (const xAOD::TrackParticle *tp, double beam_sigma_x, double beam_sigma_y, double beam_sigma_xy)
	Unsafe version of d0significance with beam spot uncertainty. More...
double	z0significance (const xAOD::TrackParticle *tp, const xAOD::Vertex *vx=NULL)
	Get the impact parameter significance of a track particle in the z direction. More...
double	z0significanceUnsafe (const xAOD::TrackParticle *tp)
	Unsafe version of z0significance. More...
double	z0significanceUnsafe (const xAOD::TrackParticle *tp, const xAOD::Vertex *vx)
	Unsafe version of z0significance, which uses z0 relative to a given primary vertex. More...
bool	hasValidCov (const xAOD::TrackParticle *tp)
	Check whether the given track particle is valid and has a covariance matrix of the defining parameters. More...
bool	hasValidCovD0 (const xAOD::TrackParticle *tp)
	Check whether the given track particle is valid and has a valid d0 uncertainty. More...
bool	hasValidCovZ0 (const xAOD::TrackParticle *tp)
	Check whether the given track particle is valid and has a valid z0 uncertainty. More...
bool	hasValidCovD0andZ0 (const xAOD::TrackParticle *tp)
	Check whether the given track particle is valid and has a valid d0 and z0 uncertainty. More...
bool	checkPVReference (const xAOD::TrackParticle *tp, const xAOD::Vertex *vx, const double max_pv_dxy_sqr=0.5 *0.5)
	test whether the given primary vertex has a significant displacement in r-phi wrt. More...
bool	checkBeamSpotSigma (double beam_sigma_x, double beam_sigma_y, double beam_sigma_xy)
	check that the beamspot covariance matrix is valid More...
double	pTErr2 (const xAOD::TrackParticle *tp)
	compute the uncertainty of pt squared. More...
double	pTErr (const xAOD::TrackParticle *tp)
	compute the uncertainty of pt. More...
double	pTErr2Unsafe (const xAOD::TrackParticle *tp)
	compute the uncertainty of pt squared. More...
double	pTErrUnsafe (const xAOD::TrackParticle *tp)
	compute the uncertainty of pt. More...
bool	hasValidCovQoverP (const xAOD::TrackParticle *tp)
	return true if the covariance matrix of the defining parameters is set, has enough elements and the q/p is valid More...

Function Documentation

checkBeamSpotSigma()

bool xAOD::TrackingHelpers::checkBeamSpotSigma ( double  beam_sigma_x, double  beam_sigma_y, double  beam_sigma_xy  )

inline

check that the beamspot covariance matrix is valid

Parameters

beam_sigma_x	the width of the beamspot in the x-direction e.g. IBeamCondSvc:: beamSigma(0).
beam_sigma_y	the width of the beamspot in the y-direction e.g. IBeamCondSvc:: beamSigma(1).
beam_sigma_xy	the beamspot xy correlation e.g. IBeamCondSvc:: beamSigmaXY.

Returns

true if the beamspot covariance matrix is valid.

Definition at line 189 of file TrackParticlexAODHelpers.h.

                                                                                           {
      return sqr(beam_sigma_x)+sqr(beam_sigma_y)>=2*std::abs(beam_sigma_xy);
    }

checkPVReference()

bool xAOD::TrackingHelpers::checkPVReference ( const xAOD::TrackParticle *  tp, const xAOD::Vertex *  vx, const double  max_pv_dxy_sqr = 0.5*0.5  )

inline

test whether the given primary vertex has a significant displacement in r-phi wrt.

d0 uncertainty.

Parameters

tp	pointer to a track particle.
vx	pointer to a vertex.
max_pv_dxy_sqr	maximum deviation of the primary vertex in units of the d0 uncertainty squared.

Returns

true if the given primary vertex has no significant displacement in r-phi wrt. d0 uncertainty. The method will also return false if the track particle or vertex are invalid or if the track particle does not have a valid d0 uncertainty.

Definition at line 176 of file TrackParticlexAODHelpers.h.

                                                                                                                  {
        if (hasValidCovD0(tp) && vx) {
         return std::abs( sqr(vx->x())+ sqr(vx->y())) <  max_pv_dxy_sqr * tp->definingParametersCovMatrixDiagVec()[0];
        }
        return false;
    }

checkTPAndDefiningParamCov()

void xAOD::TrackingHelpers::checkTPAndDefiningParamCov

(

const xAOD::TrackParticle *

tp

)

Definition at line 13 of file TrackParticlexAODHelpers.cxx.

                                                               {
    if (!tp) {
      throw std::runtime_error("Invalid TrackParticle pointer.");
    }
    SG::AuxElement::ConstAccessor< std::vector<float> > accDiag( "definingParametersCovMatrixDiag" );
    SG::AuxElement::ConstAccessor< std::vector<float> > accOffDiag( "definingParametersCovMatrixOffDiag" );
    if( !(accDiag.isAvailable( *tp ) && accOffDiag.isAvailable( *tp )) ) {
      throw std::runtime_error("TrackParticle without covariance matrix for the defining parameters.");
    }
  }

checkTPAndDefiningParamCovDiag()

void xAOD::TrackingHelpers::checkTPAndDefiningParamCovDiag

(

const xAOD::TrackParticle *

tp

)

Definition at line 24 of file TrackParticlexAODHelpers.cxx.

                                                                   {
    if (!tp) {
      throw std::runtime_error("Invalid TrackParticle pointer.");
    }
    SG::AuxElement::ConstAccessor< std::vector<float> > accDiag( "definingParametersCovMatrixDiag" );
    if( !(accDiag.isAvailable( *tp )) ) {
      throw std::runtime_error("TrackParticle without diagonal covariance matrix elements for the defining parameters.");
    }
  }

d0significance() [1/3]

double xAOD::TrackingHelpers::d0significance

(

const xAOD::TrackParticle *

tp

)

Get the impact parameter significance of a track particle in the r-phi plane.

Returns

the impact parameter significance of the track particle.

Exceptions

this	method may throw an exception in case the uncertainty is zero or the covariance matrix does not exist. The impact parameter and uncertainty are those stored in the track particle. Will perform input (tp, cov) validity checks.

Definition at line 54 of file TrackParticlexAODHelpers.cxx.

                                                                    {
    return d0significance(tp,0.);
  }

d0significance() [2/3]

double xAOD::TrackingHelpers::d0significance	(	const xAOD::TrackParticle *	tp,
		double	beam_sigma_x,
		double	beam_sigma_y,
		double	beam_sigma_xy
	)

Get the impact parameter significance of a track particle in the r-phi plane where the d0 uncertainty takes the finite beamspot width into account.

Parameters

beam_sigma_x	the width of the beamspot in the x-direction e.g. IBeamCondSvc:: beamSigma(0).
beam_sigma_y	the width of the beamspot in the y-direction e.g. IBeamCondSvc:: beamSigma(1).
beam_sigma_xy	the beamspot xy correlation e.g. IBeamCondSvc:: beamSigmaXY.

Returns

the impact parameter significance of the track particle where the d0 uncertainty takes the finite beamspot width into account.

Exceptions

this	method may throw an exception in case the uncertainty is zero or the covariance matrix does not exist or the beamspot covariance matrix is invalid. The impact parameter and uncertainty are those stored in the track particle. Will perform input (tp, cov) validity checks.

Definition at line 58 of file TrackParticlexAODHelpers.cxx.

                                                                                                                                    {
    if (!checkBeamSpotSigma(beam_sigma_x, beam_sigma_y, beam_sigma_xy)) {
      throw std::runtime_error("Beamspot covariance matrix is invalid.");
    }
    return d0significance(tp,d0UncertaintyBeamSpot2(tp->phi(),beam_sigma_x, beam_sigma_y, beam_sigma_xy));
  }

d0significance() [3/3]

double xAOD::TrackingHelpers::d0significance ( const xAOD::TrackParticle *  tp, double  d0_uncert_beam_spot_2  )

inline

Definition at line 42 of file TrackParticlexAODHelpers.cxx.

                                                                                            {
      checkTPAndDefiningParamCovDiag(tp);
      double d0 = tp->d0();
      // elements in definingParametersCovMatrixDiagVec should be : sigma_d0^2, sigma_z0^2
      double sigma_d0 = tp->definingParametersCovMatrixDiagVec().at(0);
      if (sigma_d0<=0.) {
        throw std::runtime_error("TrackParticle with zero or negative d0 uncertainty.");
      }
      return d0/sqrt(sigma_d0+d0_uncert_beam_spot_2);
    }

d0significanceUnsafe() [1/2]

double xAOD::TrackingHelpers::d0significanceUnsafe ( const xAOD::TrackParticle *  tp )

inline

Unsafe version of d0significance.

Returns

the impact parameter significance of the track particle or an undefined value In case the covariance matrix does not exist or the uncertainty is zero, this method will return an undefined value. In case the track particle does not exist the behaviour is undefined (segmentation fault or random return value). To validated the inputs use hasValidCovD0, hasValidCovD0andZ0, or checkPVReference.

Definition at line 35 of file TrackParticlexAODHelpers.h.

                                                             {
      double d0 = tp->d0();
      // elements in definingParametersCovMatrixDiagVec should be : sigma_d0^2, sigma_z0^2
      double sigma_d0 = std::sqrt( tp->definingParametersCovMatrixDiagVec()[0] );
      return d0/sigma_d0;
    }

d0significanceUnsafe() [2/2]

double xAOD::TrackingHelpers::d0significanceUnsafe ( const xAOD::TrackParticle *  tp, double  beam_sigma_x, double  beam_sigma_y, double  beam_sigma_xy  )

inline

Unsafe version of d0significance with beam spot uncertainty.

Parameters

tp	pointer to a track particle.
beam_sigma_x	the width of the beamspot in the x-direction e.g. IBeamCondSvc:: beamSigma(0).
beam_sigma_y	the width of the beamspot in the y-direction e.g. IBeamCondSvc:: beamSigma(1).
beam_sigma_xy	the beamspot xy correlation e.g. IBeamCondSvc:: beamSigmaXY.

Returns

the impact parameter significance of the track particle where the d0 uncertainty takes the finite beamspot width into account, or an undefined value In case the covariance matrix does not exist or the uncertainty is zero, this method will return an undefined value. In case the track particle does not exist the behaviour is undefined (segmentation fault or random return value). To validated the inputs use hasValidCovD0, hasValidCovD0andZ0, or checkPVReference or checkBeamSpotSigma.

Definition at line 80 of file TrackParticlexAODHelpers.h.

                                                                                                                            {
      double d0 = tp->d0();
      double sigma_d0 = std::sqrt( tp->definingParametersCovMatrixDiagVec()[0] + d0UncertaintyBeamSpot2(tp->phi(),beam_sigma_x, beam_sigma_y, beam_sigma_xy) );
      return d0/sigma_d0;
    }

d0UncertaintyBeamSpot2()

double xAOD::TrackingHelpers::d0UncertaintyBeamSpot2 ( double  track_phi0, double  beam_sigma_x, double  beam_sigma_y, double  beam_sigma_xy  )

inline

calculate the squared d0 uncertainty component due to the size of the beam spot.

Parameters

track_phi0	the phi angle of the track particle at the perigee wrt. the average beamspot position.
beam_sigma_x	the width of the beamspot in the x-direction e.g. IBeamCondSvc:: beamSigma(0).
beam_sigma_y	the width of the beamspot in the y-direction e.g. IBeamCondSvc:: beamSigma(1).
beam_sigma_xy	the beamspot xy correlation e.g. IBeamCondSvc:: beamSigmaXY.

Returns

the squared d0 uncertainty component due to the size of the beam spot.

Definition at line 49 of file TrackParticlexAODHelpers.h.

                                                                                                                     {
      double sin_phi = sin(track_phi0);
      double cos_phi = cos(track_phi0);
      double d0_uncert2= sin_phi * ( sin_phi * sqr(beam_sigma_x)
                                    -cos_phi * beam_sigma_xy)
                        +cos_phi * ( cos_phi * sqr(beam_sigma_y)
                                    -sin_phi * beam_sigma_xy);
      return d0_uncert2;
    }

hasValidCov()

bool xAOD::TrackingHelpers::hasValidCov

(

const xAOD::TrackParticle *

tp

)

Check whether the given track particle is valid and has a covariance matrix of the defining parameters.

Returns

true if the track particle is valid and has a covariance matrix of the defining parameters.

Definition at line 35 of file TrackParticlexAODHelpers.cxx.

                                                               {
    if (!tp) return false;
    if( tp->definingParametersCovMatrixFilled() != xAOD::FullCovMatrixAvailable ) return false;
    return true;
  }

hasValidCovD0()

bool xAOD::TrackingHelpers::hasValidCovD0 ( const xAOD::TrackParticle *  tp )

inline

Check whether the given track particle is valid and has a valid d0 uncertainty.

Returns

true if the track particle is valid, has a covariance matrix, and a valid d0 uncertainty.

Definition at line 133 of file TrackParticlexAODHelpers.h.

                                                     {
          if (hasValidCov(tp)) {
         if  (tp->definingParametersCovMatrixDiagVec()[0]>0.) {
                return true;
             }
          }
          return false;
    }

hasValidCovD0andZ0()

bool xAOD::TrackingHelpers::hasValidCovD0andZ0 ( const xAOD::TrackParticle *  tp )

inline

Check whether the given track particle is valid and has a valid d0 and z0 uncertainty.

Returns

true if the track particle is valid, has a covariance matrix, and a valid d0 and z0 uncertainty.

Definition at line 157 of file TrackParticlexAODHelpers.h.

                                                          {
          if (hasValidCov(tp)) {
             if  ( ( tp->definingParametersCovMatrixDiagVec()[0] > 0. )
                   && ( tp->definingParametersCovMatrixDiagVec()[1] > 0. ) ) {
                return true;
             }
          }
          return false;
    }

hasValidCovQoverP()

bool xAOD::TrackingHelpers::hasValidCovQoverP ( const xAOD::TrackParticle *  tp )

inline

return true if the covariance matrix of the defining parameters is set, has enough elements and the q/p is valid

Todo:

also check theta ?

Definition at line 262 of file TrackParticlexAODHelpers.h.

                                                         {
          if (hasValidCov(tp)) {
             if  (std::abs(tp->qOverP())>0.) {
                return true;
             }
          }
          return false;
    }

hasValidCovZ0()

bool xAOD::TrackingHelpers::hasValidCovZ0 ( const xAOD::TrackParticle *  tp )

inline

Check whether the given track particle is valid and has a valid z0 uncertainty.

Returns

true if the track particle is valid, has a covariance matrix, and a valid z0 uncertainty.

Definition at line 145 of file TrackParticlexAODHelpers.h.

                                                    {
          if (hasValidCov(tp)) {
             if  ( tp->definingParametersCovMatrixDiagVec()[1] > 0. ) {
                return true;
             }
          }
          return false;
    }

pTErr()

double xAOD::TrackingHelpers::pTErr ( const xAOD::TrackParticle *  tp )

inline

compute the uncertainty of pt.

Parameters

tp	a pointer to a track particle.

Exceptions

will	throw an exception if the track particle is not valid, no covariance matrix of the defining parameters is set or the covariance matrix has wrong dimension.

Definition at line 202 of file TrackParticlexAODHelpers.h.

                                              {
      return sqrt( pTErr2(tp) );
    }

pTErr2()

double xAOD::TrackingHelpers::pTErr2

(

const xAOD::TrackParticle *

tp

)

compute the uncertainty of pt squared.

Parameters

tp	a pointer to a track particle.

Exceptions

will	throw an exception if the track particle is not valid, no covariance matrix of the defining parameters is set or the covariance matrix has wrong dimension.

Definition at line 82 of file TrackParticlexAODHelpers.cxx.

                                                            {
    checkTPAndDefiningParamCov(tp);
    if (!hasValidCovQoverP(tp)) {
      throw std::runtime_error("TrackParticle without covariance matrix for defining parameters or the covariance matrix is wrong dimensionality.");
    }
    if (std::abs(tp->qOverP())<0) {
      throw std::runtime_error("q/p is zero");
    }
    return pTErr2Unsafe(tp);
  }

pTErr2Unsafe()

double xAOD::TrackingHelpers::pTErr2Unsafe ( const xAOD::TrackParticle *  tp )

inline

compute the uncertainty of pt squared.

Parameters

tp	a valid pointer to a track particle for which the defining parameters covariance matrix is set and valid undefined behaviour if tp is invalid or no valid covariance matrix is set for the defining parameters.

Definition at line 211 of file TrackParticlexAODHelpers.h.

                                                     {
 
      //            /   d                       \2    /   d                        \2          d       d
      // pt_err^2 =|  ------   (pt) *sigma_q/p  |  + | --------   pt * sigma_theta |    +    ----- pt ------- pt * sigma_theta_qp
      //            \  d q/p                    /     \ d theta                    /          d qp    d theta
 
      //                d             / d pt           2   d pt                     \   / d pt                  \2
      //          =   ------   (pt) * | ----- sigma_q/p  + ------- * sigma_theta_qp | + | ------- * sigma_theta |
      //               d q/p          \ d q/p              d theta                  /   \ d theta               /
 
      //   d                pt
      // ------ pt  =  - -------------
      //  d q/p          fabs(qOverP)
 
      //   d                pt
      //  ------- pt =   -----------
      //  d theta         tan(theta)
 
      double pt = tp->pt();
      double diff_qp =  - pt / std::abs(tp->qOverP());
 
      double diff_theta = pt / tan( tp->theta() );
 
      // since 1/tan (thata) defined for all floats 0..M_PI, don't have to protect :
      //
      // double diff_theta = ( std::abs(tp->theta()-M_PI_2) > std::numeric_limits<float>::epsilon() * 2
      //                      ? pt / tan( tp->theta() )
      //                      : 0 )
 
      auto cov = tp->definingParametersCovMatrix();
      // elements in definingParametersCovMatrix should be : 0: sigma_d0^2,
      //                                                     1: sigma_d0_z0,  sigma_z0^2,
      //                                                     3: sigma_d0_phi, sigma_z0_phi, sigma_phi^2
      //                                                     6: sigma_d0_th,  sigma_z0_th,  sigma_phi_th, sigma_th^2
      //                                                    10: sigma_d0_qp,  sigma_z0_qp,  sigma_phi_qp, sigma_th_qp, sigma_qp^2
 
      double pt_err2 = diff_qp * (diff_qp * cov(4, 4) + diff_theta * cov(3, 4) ) + sqr(diff_theta) * cov(3, 3);
      return pt_err2;
    }

pTErrUnsafe()

double xAOD::TrackingHelpers::pTErrUnsafe ( const xAOD::TrackParticle *  tp )

inline

compute the uncertainty of pt.

Parameters

tp	a valid pointer to a track particle for which the defining parameters covariance matrix is set and valid undefined behaviour if tp is invalid or no valid covariance matrix is set for the defining parameters.

Definition at line 255 of file TrackParticlexAODHelpers.h.

                                                    {
      return sqrt(pTErr2Unsafe(tp));
    }

sqr()

double xAOD::TrackingHelpers::sqr ( double  a )

inline

convenience method to calculate the square of a value.

Definition at line 21 of file TrackParticlexAODHelpers.h.

{ return a*a; }

z0significance()

double xAOD::TrackingHelpers::z0significance	(	const xAOD::TrackParticle *	tp,
		const xAOD::Vertex *	vx = NULL
	)

Get the impact parameter significance of a track particle in the z direction.

Parameters

tp	a pointer to a track particle.
vx	a pointer to a primary vertex with respect to which z0 is expressed or NULL.

Returns

the impact parameter significance of the track particle.

Exceptions

this

method may throw an exception in case the uncertainty is zero or the covariance matrix does not exist. The impact parameter and uncertainty are those stored in the track particle. Will perform input (tp, cov) validity checks. If the given vertex results from a fit which includes the track particle tp, then this z0 impact parameter significance will be biased.

Definition at line 65 of file TrackParticlexAODHelpers.cxx.

                                                                                          {
    checkTPAndDefiningParamCovDiag(tp);
    double z0 = tp->z0() + tp->vz();
    if (vx) {
        if (!checkPVReference(tp,vx)) {
           throw std::runtime_error("Given primary vertex does not fulfil the requirements i.e. does not exist, or is too far away from the beam axis.");
        }
        z0 -= vx->z();
    }
    // elements in definingParametersCovMatrixVec should be : sigma_d0^2, sigma_z0^2
    double sigma_z0 = tp->definingParametersCovMatrixDiagVec().at(1);
    if (sigma_z0<=0.) {
      throw std::runtime_error("TrackParticle with zero or negative z0 uncertainty.");
    }
    return z0/sqrt(sigma_z0);
  }

z0significanceUnsafe() [1/2]

double xAOD::TrackingHelpers::z0significanceUnsafe ( const xAOD::TrackParticle *  tp )

inline

Unsafe version of z0significance.

Returns

the impact parameter significance of the track particle or an undefined value In case the covariance matrix does not exist or the uncertainty is zero or smaller, this method will return an undefined value. In case the track particle does not exist the behaviour is undefined (segmentation fault or random return value).

Definition at line 101 of file TrackParticlexAODHelpers.h.

                                                             {
      double z0 = tp->z0() + tp->vz();
      double sigma_z0 = std::sqrt( tp->definingParametersCovMatrixDiagVec()[1] );
      return z0/sigma_z0;
    }

z0significanceUnsafe() [2/2]

double xAOD::TrackingHelpers::z0significanceUnsafe ( const xAOD::TrackParticle *  tp, const xAOD::Vertex *  vx  )

inline

Unsafe version of z0significance, which uses z0 relative to a given primary vertex.

Parameters

tp	a valid pointer to a track particle.
vx	a valid pointer to a primary vertex with respect to which z0 is expressed.

Returns

the impact parameter significance of the track particle or an undefined value In case the covariance matrix does not exist or the uncertainty is zero or smaller, this method will return an undefined value. In case the track particle or vertex does not exist the behaviour is undefined (segmentation fault or random return value). To validated the inputs use hasValidCovZ0 or hasValidCovD0andZ0, and checkPVReference. If the given vertex results from a fit which includes the track particle tp, this z0 impact parameter significance will be biased.

Definition at line 117 of file TrackParticlexAODHelpers.h.

                                                                                   {
      // use z0 relative to the given primary vertex.
      double z0 = tp->z0() + tp->vz() - vx->z();
 
      double sigma_z0 = std::sqrt( tp->definingParametersCovMatrixDiagVec()[1] );
      return z0/sigma_z0;
    }