xAOD::BPhysHypoHelper Class Reference

#include <BPhysHypoHelper.h>

Inheritance diagram for xAOD::BPhysHypoHelper:

Collaboration diagram for xAOD::BPhysHypoHelper:

Public Types
enum	pv_type { PV_MAX_SUM_PT2 , PV_MIN_A0 , PV_MIN_Z0 , PV_MIN_Z0_BA }
	: Enum type of the PV More...

Public Member Functions
	BPhysHypoHelper (const std::string &hypo, const xAOD::Vertex *b, SG::auxid_set_t *decors=nullptr)
	: Main constructor
const xAOD::Vertex *	vtx () const
	Getter method for the cached xAOD::Vertex.
const TMatrixTSym< double > &	covariance ()
	: Returns full covariance matrix
float	mass () const
	Get invariant mass and its error.
float	massErr () const
	invariant mass error
bool	setMass (const float val)
	Set given invariant mass and its error.
bool	setMassErr (const float val)
	invariant mass error
bool	setMass (std::span< const double > trkMasses)
	Set invariant mass for given track mass hypotheses.
bool	pass () const
	get the pass flag for this hypothesis
bool	setPass (bool passVal)
	get the pass flag for this hypothesis
int	nRefTrks ()
	Returns number of stored refitted track momenta.
TVector3	refTrk (const size_t index)
	Returns i-th refitted track 3-momentum.
TLorentzVector	refTrk (const size_t index, const float mass)
	Returns i-th refitted track as a 4-vector given the mass hypothesis.
const std::vector< TVector3 > &	refTrks ()
	Returns refitted track momenta.
const xAOD::IParticle *	refTrkOrigin (const size_t index) const
	: Returns the original track (charged or neutral) corresponding to the i-th refitted track
TVector3	refTrkOriginP (const size_t index) const
	Returns perigee 3-momentum of the original track corresponding i-th refitted track.
TLorentzVector	refTrkOriginP (const size_t index, const float mass) const
	: Returns lorentz vector build from the original track perigee momentum and given mass hypothesis
float	refTrkCharge (const size_t index) const
	Returns charge of the i-th track.
bool	setRefTrks (std::vector< float > px, std::vector< float > py, std::vector< float > pz)
	Sets refitted track momenta.
bool	setRefTrks (const std::vector< TVector3 > &refTrks)
	Sets refitted track momenta.
bool	setRefTrks ()
	: Sets refitted track momenta
TVector3	totalP ()
	: Returns total 3-momentum calculated from the refitted tracks
TLorentzVector	totalP (std::span< const double > masses)
	Returns total 4-momentum calculated from the refitted tracks given mass hypotheses for individual tracks.
float	ptErr ()
	Returns pT error.
bool	setPtErr (const float val)
	Set pT error.
int	nMuons ()
	: Methods providing access to the linked muons
int	nElectrons ()
const xAOD::Muon *	muon (const size_t index)
	Returns pointer to the i-th linked muon.
const xAOD::Electron *	electron (const size_t index)
const std::vector< const xAOD::Muon * > &	muons ()
	Returns linked muons.
const std::vector< const xAOD::Electron * > &	electrons ()
bool	setMuons (const std::vector< const xAOD::Muon * > &muons, const xAOD::MuonContainer *muonContainer)
	Set links to muons.
bool	setElectrons (const std::vector< const xAOD::Electron * > &electrons, const xAOD::ElectronContainer *electronContainer)
int	nPrecedingVertices ()
	: Links to preceding vertices
const xAOD::Vertex *	precedingVertex (const size_t index)
	Returns pointer to a preceding vertex.
const std::vector< const xAOD::Vertex * > &	precedingVertices ()
	Returns vector of pointers to preceding vertices.
bool	setPrecedingVertices (const std::vector< const xAOD::Vertex * > &vertices, const xAOD::VertexContainer *vertexContainer)
	Sets links to preceding vertices.
int	nCascadeVertices ()
	: Links to cascade vertices
const xAOD::Vertex *	cascadeVertex (const size_t index)
	Returns pointer to a cascade vertex.
const std::vector< const xAOD::Vertex * > &	cascadeVertices ()
	Returns vector of pointers to cascade vertices.
bool	setCascadeVertices (const std::vector< const xAOD::Vertex * > &vertices, const xAOD::VertexContainer *vertexContainer)
	Sets links to cascade vertices.
int	nRefTrksCascade ()
	Returns number of stored refitted tracks INCLUDING those from the linked cascade vertices.
const xAOD::Vertex *	pv (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Get the refitted collision vertex of type pv_type.
const xAOD::Vertex *	origPv (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	original PV
bool	setOrigPv (const xAOD::Vertex *pv, const xAOD::VertexContainer *vertexContainer, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Set the original collision vertex of type pv_type.
bool	setPv (const xAOD::Vertex *pv, const xAOD::VertexContainer *vertexContainer, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Set the refitted collision vertex of type pv_type.
bool	setRefitPVStatus (int code, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Set the exitCode of the refitter for vertex of type pv_type.
int	RefitPVStatus (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Get the exitCode of the refitter for vertex of type pv_type.
float	lxy (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Get the transverse decay distance and its error measured between the refitted primary vertex of type pv_type and the B vertex.
float	lxyErr (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	its error
bool	setLxy (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Set the transverse decay distance and its error measured between the refitted primary vertex of type pv_type and the B vertex.
bool	setLxyErr (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	its error
float	lxyz (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	decay distance
float	lxyzErr (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	its error
bool	setLxyz (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	decay distance
bool	setLxyzErr (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	its error
float	a0 (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Get the 3D, transverse, and longitudinal impact parameters and their error.
float	a0Err (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	3D impact parameter error
float	a0xy (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	transverse impact parameter
float	a0xyErr (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	rtansverse impact parameter error
float	z0 (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	longitudinal impact parameter
float	z0Err (const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	longitudinal impact parameter error
float	setA0 (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	Set the 3D and transverse impact parameters and their error.
float	setA0Err (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	3D impact parameter error
float	setA0xy (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	transverse impact parameter
float	setA0xyErr (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	transverse impact parameter error
float	setZ0 (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	longitudinal impact parameter
float	setZ0Err (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0)
	longitudinal impact parameter error

Static Public Attributes
static const std::string	pv_type_str []
static const unsigned int	n_pv_types = 4

Protected Member Functions
bool	cacheCov ()
	: Cache covariance matrix
bool	cacheRefTracks ()
	: Cache refitted tracks
bool	cacheMuons ()
	: Cache linked muons
bool	cacheElectrons ()
bool	cachePrecedingVertices ()
	: Cache preceding vertices
bool	cacheCascadeVertices ()
	: Cache cascade vertices

Protected Attributes
const xAOD::Vertex *	m_b
	Cached B decay xAOD vertex.
std::string	m_hypo
	name of the mass hypothesis
SG::auxid_set_t *	m_decors
	set of decorations that we're written
bool	m_covCached
TMatrixTSym< double >	m_cachedCov
bool	m_refTracksCached
std::vector< TVector3 >	m_cachedRefTracks
bool	m_muonsCached
bool	m_electronsCached
std::vector< const xAOD::Muon * >	m_cachedMuons
std::vector< const xAOD::Electron * >	m_cachedElectrons
bool	m_precedingVerticesCached
std::vector< const xAOD::Vertex * >	m_cachedPrecedingVertices
bool	m_cascadeVerticesCached
std::vector< const xAOD::Vertex * >	m_cachedCascadeVertices

Static Protected Attributes
static const std::vector< TVector3 >	s_emptyVectorOfTVector3
static const std::vector< const xAOD::Muon * >	s_emptyVectorOfMuons
static const std::vector< const xAOD::Electron * >	s_emptyVectorOfElectrons
static const TMatrixTSym< double >	s_emptyMatrix
static const std::vector< const xAOD::Vertex * >	s_emptyVectorOfVertices

Private Member Functions
float	get_float (const std::string &name) const
bool	set_float (const std::string &name, float val)
enum	tau_type { TAU_CONST_MASS , TAU_INV_MASS }
	: Enum type the proper decay time calculationTAU_CONST_MASS the proper decay time calculated with the constant mass hypothesis TAU_INV_MASS the proper decay time calculated with the measured invariant mass More...
float	tau (const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	: Get the proper decay time and error.
float	tauErr (const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	proper decay time error
bool	setTau (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	: Set the proper decay time and error.
bool	setTauErr (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	proper decay time error
float	tau3d (const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	proper decay time
float	tau3dErr (const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	proper decay time error
bool	setTau3d (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	proper decay time
bool	setTau3dErr (const float val, const pv_type vertexType=BPhysHelper::PV_MIN_A0, const tau_type tauType=BPhysHypoHelper::TAU_CONST_MASS)
	proper decay time error

Detailed Description

Definition at line 73 of file BPhysHypoHelper.h.

Member Enumeration Documentation

pv_type

enum xAOD::BPhysHelper::pv_type

inherited

: Enum type of the PV

This enum type is used to identify type of the PV and quantities calculated using the PV. For instance, the transverse distance can be calculated wrt the default PV, the closest PV etc.

@value: PV_MAX_SUM_PT2 vertex with the largest sum Pt^2 (the default one) @value: PV_MIN_A0 collision vertex closest in 3D to the particle's trajectory, i.e. the vertex with the smalles 3D impact parameter a0 @value: PV_MIN_Z0 collision vertex closest in delta(z0) = pv_z - z0, where z0 is the z coordinate of the intesection of the particle's trajectory with the beam axis in the Z-rho plane. @value: PV_MIN_Z0_BA collision vertex closest in delta(z0) = pv_z - z0, where z0 is the z coordinate of the point of closest aproach (in 2D) to the particle's trajectory with the beam axis in the Z-rho plane.

Enumerator
PV_MAX_SUM_PT2
PV_MIN_A0
PV_MIN_Z0
PV_MIN_Z0_BA

Definition at line 475 of file BPhysHelper.h.

{PV_MAX_SUM_PT2, PV_MIN_A0, PV_MIN_Z0, PV_MIN_Z0_BA};

tau_type

enum xAOD::BPhysHypoHelper::tau_type

: Enum type the proper decay time calculationTAU_CONST_MASS the proper decay time calculated with the constant mass hypothesis TAU_INV_MASS the proper decay time calculated with the measured invariant mass

Methods for access to the proper decay time and its error

Enumerator
TAU_CONST_MASS
TAU_INV_MASS

Definition at line 140 of file BPhysHypoHelper.h.

{ TAU_CONST_MASS, TAU_INV_MASS };

Constructor & Destructor Documentation

BPhysHypoHelper()

xAOD::BPhysHypoHelper::BPhysHypoHelper ( const std::string & hypo, const xAOD::Vertex * b, SG::auxid_set_t * decors = nullptr )

inline

: Main constructor

The Main constructor. BPhysHypoHelper does NOT take ownership of the class "b"

Parameters

[in]	hypo	Name of the hypothesis
[in]	b	Pointer to the xAOD::Vertex
	decors	If provided, use this to keep track of produced decorations.

Definition at line 87 of file BPhysHypoHelper.h.

                                                       :
        BPhysHelper(b),
        m_hypo(hypo),
        m_decors(decors)
      {
        /* nothing here */
      }

Member Function Documentation

a0()

float xAOD::BPhysHelper::a0 ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Get the 3D, transverse, and longitudinal impact parameters and their error.

Impact parameters and their error

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Returns

: impact parameter or its error, -9999999. in case augmentation is not available 3D impact parameter

Definition at line 957 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("A0MaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("A0MinA0");
    case PV_MIN_Z0      : GET_FLOAT("A0MinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("A0MinZ0BA");
    default: return -9999999.;
  }
}

a0Err()

float xAOD::BPhysHelper::a0Err ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

3D impact parameter error

Definition at line 968 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("A0ErrMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("A0ErrMinA0");
    case PV_MIN_Z0      : GET_FLOAT("A0ErrMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("A0ErrMinZ0BA");
    default: return -9999999.;
  }
}

a0xy()

float xAOD::BPhysHelper::a0xy ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

transverse impact parameter

Definition at line 979 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("A0xyMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("A0xyMinA0");
    case PV_MIN_Z0      : GET_FLOAT("A0xyMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("A0xyMinZ0BA");
    default: return -9999999.;
  }  
}

a0xyErr()

float xAOD::BPhysHelper::a0xyErr ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

rtansverse impact parameter error

Definition at line 990 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("A0xyErrMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("A0xyErrMinA0");
    case PV_MIN_Z0      : GET_FLOAT("A0xyErrMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("A0xyErrMinZ0BA");
    default: return -9999999.;
  }    
}

cacheCascadeVertices()

bool xAOD::BPhysHelper::cacheCascadeVertices ( )

protectedinherited

: Cache cascade vertices

To speed up access to linked cascade vertices, m_cachedCascadeVertices vector is created first time linked cascade vertices accessor methods are called. In subsequent calls, cached vector is used.

Returns

: true on success

Definition at line 1316 of file BPhysHelper.cxx.

{
  // if linked cascade vertices are already cached do nothing and return true 
  if(m_cascadeVerticesCached && !m_cachedCascadeVertices.empty())
    return true;
  
  // if linked cascade vertices are cached but the cache is empty, return false (error)
  if(m_cascadeVerticesCached && m_cachedCascadeVertices.empty())
    return false;
  
  // Linked cascade vertices are not cached, yet. Retrieve them from the aux store:
  m_cascadeVerticesCached = true;
  m_cachedCascadeVertices.clear();
  
  // Create auxiliary branches accessors 
  static const SG::AuxElement::Accessor<VertexLinkVector> cascadeVertexLinksAcc("CascadeVertexLinks"); 
  
  // check if branch exists
  if(!cascadeVertexLinksAcc.isAvailable(*m_b)) {
    return false;
  }
  
  // retrieve the cascadeVertex links...
  const VertexLinkVector& cascadeVertexLinks = cascadeVertexLinksAcc(*m_b);
  
  // ... and check if they are all valid
  VertexLinkVector::const_iterator cascadeVertexLinksItr = cascadeVertexLinks.begin();
  for(; cascadeVertexLinksItr!=cascadeVertexLinks.end(); ++cascadeVertexLinksItr) {
    // check if links are valid
    if(!(*cascadeVertexLinksItr).isValid()) {
      return false;
    }
  }
  
  // all OK, cache the cascadeVertices
  cascadeVertexLinksItr = cascadeVertexLinks.begin();
  for(; cascadeVertexLinksItr!=cascadeVertexLinks.end(); ++cascadeVertexLinksItr) {
    m_cachedCascadeVertices.push_back(*(*cascadeVertexLinksItr));
  }
  
  return true;
  
}

cacheCov()

bool xAOD::BPhysHelper::cacheCov ( )

protectedinherited

: Cache covariance matrix

To speed up access to covariance matrix, m_cachedCov attribute is created first time covariance matrix accessor method is called. In subsequent calls, cached matrix is used.

Returns

: true on success

Definition at line 1089 of file BPhysHelper.cxx.

{
  // if cov matrix is already cached, do nothing and return true 
  if(m_covCached && m_cachedCov.GetNrows()!=0)
    return true;
 
  // if cov matrix is cached but the cache is empty, return false (error)
  if(m_covCached && m_cachedCov.GetNrows()==0)
    return false;
  
  // get number of tracks
  // if ref tracks are stripped from the vertex, this will not work and
  // error will be returned
  const int nTrk = nRefTrks();
  if(nTrk<0)
    return false;
  
  // Covariance matrix not cached, yet. Retrieve them from 
  // the vertex and convert:
  m_covCached = true;
    
  // retrieve native covariance matrix
  const std::vector<float>& cov = m_b->covariance();
  
  // convert covariance matrix
  if(int(cov.size())==(3*nTrk+3)*(3*nTrk+3+1)/2) {
    // this is a VKalVrtFitter covariance matrix
    m_cachedCov.ResizeTo(3+3*nTrk, 3+3*nTrk);
    
    long int ij=0;
    for(int i=0; i<(3+3*nTrk); i++) {
      for(int j=0; j<=i; j++) {
        m_cachedCov(i,j) = cov[ij];
        ij++;
      }
    }
    
    return true;
  }
  
  // FIXME: so far we can only conver VKalVrt cov matrix
 
  // error
  return false;
    
}

cacheElectrons()

bool xAOD::BPhysHelper::cacheElectrons ( )

protectedinherited

Definition at line 1226 of file BPhysHelper.cxx.

{
  // if linked electrons are already cached do nothing and return true 
  if(m_electronsCached && !m_cachedElectrons.empty())
    return true;
  
  // if linked electrons are cached but the cache is empty, return false (error)
  if(m_electronsCached && m_cachedElectrons.empty())
    return false;
  
  // Linked electrons are not cached, yet. Retrieve them from the aux store:
  m_electronsCached = true;
  m_cachedElectrons.clear();
  
  // Create auxiliary branches accessors 
  static const SG::AuxElement::Accessor<ElectronLinkVector> electronLinksAcc("ElectronLinks"); 
  
  // check if branch exists
  if(!electronLinksAcc.isAvailable(*m_b)) {
    return false;
  }
  
  // retrieve the electron links...
  const ElectronLinkVector& electronLinks = electronLinksAcc(*m_b);
  
  // ... and check if they are all valid
  ElectronLinkVector::const_iterator electronLinksItr = electronLinks.begin();
  for(; electronLinksItr!=electronLinks.end(); ++electronLinksItr) {
    // check if links are valid
    if(!(*electronLinksItr).isValid()) {
      return false;
    }
  }
  
  // all OK, cache the electrons
  electronLinksItr = electronLinks.begin();
  for(; electronLinksItr!=electronLinks.end(); ++electronLinksItr) {
    m_cachedElectrons.push_back(*(*electronLinksItr));
  }
  
  return true;
  
}

cacheMuons()

bool xAOD::BPhysHelper::cacheMuons ( )

protectedinherited

: Cache linked muons

To speed up access to linked muons, m_cachedMuons vector is created first time linked muon accessor methods are called. In subsequent calls, cached vector is used.

Returns

: true on success

Definition at line 1181 of file BPhysHelper.cxx.

{
  // if linked muons are already cached do nothing and return true 
  if(m_muonsCached && !m_cachedMuons.empty())
    return true;
  
  // if linked muons are cached but the cache is empty, return false (error)
  if(m_muonsCached && m_cachedMuons.empty())
    return false;
  
  // Linked muons are not cached, yet. Retrieve them from the aux store:
  m_muonsCached = true;
  m_cachedMuons.clear();
  
  // Create auxiliary branches accessors 
  static const SG::AuxElement::Accessor<MuonLinkVector> muonLinksAcc("MuonLinks"); 
  
  // check if branch exists
  if(!muonLinksAcc.isAvailable(*m_b)) {
    return false;
  }
  
  // retrieve the muon links...
  const MuonLinkVector& muonLinks = muonLinksAcc(*m_b);
  
  // ... and check if they are all valid
  MuonLinkVector::const_iterator muonLinksItr = muonLinks.begin();
  for(; muonLinksItr!=muonLinks.end(); ++muonLinksItr) {
    // check if links are valid
    if(!(*muonLinksItr).isValid()) {
      return false;
    }
  }
  
  // all OK, cache the muons
  muonLinksItr = muonLinks.begin();
  for(; muonLinksItr!=muonLinks.end(); ++muonLinksItr) {
    m_cachedMuons.push_back(*(*muonLinksItr));
  }
  
  return true;
  
}

cachePrecedingVertices()

bool xAOD::BPhysHelper::cachePrecedingVertices ( )

protectedinherited

: Cache preceding vertices

To speed up access to linked preceding vertices, m_cachedPrecedingVertices vector is created first time linked preceding vertices accessor methods are called. In subsequent calls, cached vector is used.

Returns

: true on success

Definition at line 1271 of file BPhysHelper.cxx.

{
  // if linked preceding vertices are already cached do nothing and return true 
  if(m_precedingVerticesCached && !m_cachedPrecedingVertices.empty())
    return true;
  
  // if linked preceding vertices are cached but the cache is empty, return false (error)
  if(m_precedingVerticesCached && m_cachedPrecedingVertices.empty())
    return false;
  
  // Linked preceding vertices are not cached, yet. Retrieve them from the aux store:
  m_precedingVerticesCached = true;
  m_cachedPrecedingVertices.clear();
  
  // Create auxiliary branches accessors 
  static const SG::AuxElement::Accessor<VertexLinkVector> precedingVertexLinksAcc("PrecedingVertexLinks"); 
  
  // check if branch exists
  if(!precedingVertexLinksAcc.isAvailable(*m_b)) {
    return false;
  }
  
  // retrieve the precedingVertex links...
  const VertexLinkVector& precedingVertexLinks = precedingVertexLinksAcc(*m_b);
  
  // ... and check if they are all valid
  VertexLinkVector::const_iterator precedingVertexLinksItr = precedingVertexLinks.begin();
  for(; precedingVertexLinksItr!=precedingVertexLinks.end(); ++precedingVertexLinksItr) {
    // check if links are valid
    if(!(*precedingVertexLinksItr).isValid()) {
      return false;
    }
  }
  
  // all OK, cache the precedingVertices
  precedingVertexLinksItr = precedingVertexLinks.begin();
  for(; precedingVertexLinksItr!=precedingVertexLinks.end(); ++precedingVertexLinksItr) {
    m_cachedPrecedingVertices.push_back(*(*precedingVertexLinksItr));
  }
  
  return true;
  
}

cacheRefTracks()

bool xAOD::BPhysHelper::cacheRefTracks ( )

protectedinherited

: Cache refitted tracks

To speed up access to refitted track momenta, m_cachedRefTracks vector is created first time refitted track accessor methods are called. In subsequent calls, cached vector is used.

Returns

: true on success

Definition at line 1137 of file BPhysHelper.cxx.

{
  // if refitted tracks are already cached, do nothing and return true 
  if(m_refTracksCached && !m_cachedRefTracks.empty())
    return true;
  
  // if refitted tracks are cached but the cache is empty, return false (error)
  if(m_refTracksCached && m_cachedRefTracks.empty())
    return false;
  
  // Refitted tracks are not cached, yet. Retrieve them from the aux store:
  m_refTracksCached = true;
  m_cachedRefTracks.clear();
  
  // Create auxiliary branches accessors 
  static const SG::AuxElement::Accessor< std::vector<float> > refTrackPxAcc("RefTrackPx");
  static const SG::AuxElement::Accessor< std::vector<float> > refTrackPyAcc("RefTrackPy");
  static const SG::AuxElement::Accessor< std::vector<float> > refTrackPzAcc("RefTrackPz");
  
  // check if branches are available:
  if(!refTrackPxAcc.isAvailable(*m_b) || 
     !refTrackPyAcc.isAvailable(*m_b) ||
     !refTrackPzAcc.isAvailable(*m_b) )
    return false;
  
  // retrieve branches:
  const std::vector<float>& refTrackPx = refTrackPxAcc(*m_b);
  const std::vector<float>& refTrackPy = refTrackPyAcc(*m_b);
  const std::vector<float>& refTrackPz = refTrackPzAcc(*m_b);
  
  // all must have the same lenght
  if(refTrackPx.size()!=refTrackPy.size() || refTrackPx.size()!=refTrackPz.size())
    return false;
  
  // all OK: store refitted tracks in the cache
  for(uint i=0; i<refTrackPx.size(); ++i) {
    m_cachedRefTracks.emplace_back(refTrackPx[i], refTrackPy[i], refTrackPz[i] );
  }
  
  return true;
  
}

cascadeVertex()

const xAOD::Vertex * xAOD::BPhysHelper::cascadeVertex ( const size_t index )

inherited

Returns pointer to a cascade vertex.

Parameters

[in]

index

index of the cascade vertex

Returns

: pointer to the vertex, 0 on error

Definition at line 694 of file BPhysHelper.cxx.

{
  // cache linked cascadeVertices
  if(!cacheCascadeVertices())
    return nullptr;
  
  // range check
  if(index>=m_cachedCascadeVertices.size())
    return nullptr;
  
  // all OK:
  return m_cachedCascadeVertices[index];
  
}

cascadeVertices()

const std::vector< const xAOD::Vertex * > & xAOD::BPhysHelper::cascadeVertices ( )

inherited

Returns vector of pointers to cascade vertices.

Returns

: vector of pointers to vertices, empty vector on error

Definition at line 710 of file BPhysHelper.cxx.

{
  // cache linked cascadeVertices
  if(!cacheCascadeVertices())
    return xAOD::BPhysHelper::s_emptyVectorOfVertices;
  
  // all OK:
  return m_cachedCascadeVertices;  
  
}

covariance()

const TMatrixTSym< double > & xAOD::BPhysHelper::covariance ( )

inherited

: Returns full covariance matrix

Converts native covariance matrix stored as a std::vector<float> into a symmetric matrix-form represented by TMatrixTSym<double> class.

Note

This method needs to know the number of tracks. If refitted tracks are stripped from the verrtex, this method will no longer work.

Returns

: covariance matrix, 0x0 matrix in case of an error

Definition at line 103 of file BPhysHelper.cxx.

{
  
  // cache covariance matrix
  if(!cacheCov())
    return xAOD::BPhysHelper::s_emptyMatrix;
  
  // all OK:
  return m_cachedCov;    
}

electron()

const xAOD::Electron * xAOD::BPhysHelper::electron ( const size_t index )

inherited

Definition at line 532 of file BPhysHelper.cxx.

{
  // cache linked electrons
  if(!cacheElectrons())
    return nullptr;
  
  // range check
  if(index>=m_cachedElectrons.size())
    return nullptr;
  
  // all OK:
  return m_cachedElectrons[index];
  
}

electrons()

const std::vector< const xAOD::Electron * > & xAOD::BPhysHelper::electrons ( )

inherited

Definition at line 548 of file BPhysHelper.cxx.

{
  // cache linked electrons
  if(!cacheElectrons())
    return xAOD::BPhysHelper::s_emptyVectorOfElectrons;
  
  // all OK:
  return m_cachedElectrons;  
}

get_float()

float xAOD::BPhysHypoHelper::get_float ( const std::string & name ) const

private

Some useful functions

Definition at line 21 of file BPhysHypoHelper.cxx.

{
  SG::ConstAccessor<float> floatAcc(name);
  if(!floatAcc.isAvailable(*m_b)) return -9999999.;
  return floatAcc(*m_b);
}

lxy()

float xAOD::BPhysHelper::lxy ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Get the transverse decay distance and its error measured between the refitted primary vertex of type pv_type and the B vertex.

Transverse decay distance and its error

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Returns

: lxy, -9999999. in case augmentation is not available decay distance

Definition at line 866 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("LxyMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("LxyMinA0");
    case PV_MIN_Z0      : GET_FLOAT("LxyMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("LxyMinZ0BA");
    default: return -9999999.;
  }
}

lxyErr()

float xAOD::BPhysHelper::lxyErr ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

its error

Definition at line 877 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("LxyErrMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("LxyErrMinA0");
    case PV_MIN_Z0      : GET_FLOAT("LxyErrMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("LxyErrMinZ0BA");
    default: return -9999999.;
  }
}

lxyz()

float xAOD::BPhysHelper::lxyz ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

decay distance

Definition at line 912 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("LxyzMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("LxyzMinA0");
    case PV_MIN_Z0      : GET_FLOAT("LxyzMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("LxyzMinZ0BA");
    default: return -9999999.;
  }
}

lxyzErr()

float xAOD::BPhysHelper::lxyzErr ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

its error

Definition at line 923 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("LxyzErrMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("LxyzErrMinA0");
    case PV_MIN_Z0      : GET_FLOAT("LxyzErrMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("LxyzErrMinZ0BA");
    default: return -9999999.;
  }
}

mass()

float xAOD::BPhysHypoHelper::mass

(

)

const

Get invariant mass and its error.

Methods for access to the invariant mass hypothesis and its error

Returns

: mass or error, -9999999. in case the augmentation doesn't exist invariant mass

Definition at line 42 of file BPhysHypoHelper.cxx.

{
  return get_float( m_hypo+"_mass" );
}

massErr()

float xAOD::BPhysHypoHelper::massErr

(

)

const

invariant mass error

Definition at line 47 of file BPhysHypoHelper.cxx.

{
  return get_float( m_hypo+"_massErr" );  
}

muon()

const xAOD::Muon * xAOD::BPhysHelper::muon ( const size_t index )

inherited

Returns pointer to the i-th linked muon.

Parameters

[in]

index

index of the linked muon

Returns

: Pointer to the muon, 0 in case of an error

Definition at line 452 of file BPhysHelper.cxx.

{
  // cache linked muons
  if(!cacheMuons())
    return nullptr;
  
  // range check
  if(index>=m_cachedMuons.size())
    return nullptr;
  
  // all OK:
  return m_cachedMuons[index];
  
}

muons()

const std::vector< const xAOD::Muon * > & xAOD::BPhysHelper::muons ( )

inherited

Returns linked muons.

Returns

: linked muons, empty vector in case of an error

Definition at line 468 of file BPhysHelper.cxx.

{
  // cache linked muons
  if(!cacheMuons())
    return xAOD::BPhysHelper::s_emptyVectorOfMuons;
  
  // all OK:
  return m_cachedMuons;  
}

nCascadeVertices()

int xAOD::BPhysHelper::nCascadeVertices ( )

inherited

: Links to cascade vertices

Cascade decays, e.g. Bd->Jpsi(mumu)+Ks(pipi), consist of more than one reconstructed vertex. for instance in case of the Bd decay, 2 vertices are required. Cascade vertices links are used to store relations between mother and daughter vertices in the cascade decays. Returns number of cascade vertices

Returns

: number of cascade vertices, -1 on error

Definition at line 682 of file BPhysHelper.cxx.

{
  // cache linked cascade vertices
  if(!cacheCascadeVertices())
    return -1;
  
  // all OK:
  return m_cachedCascadeVertices.size();
   
}

nElectrons()

int xAOD::BPhysHelper::nElectrons ( )

inherited

Definition at line 521 of file BPhysHelper.cxx.

{
  // cache linked electrons
  if(!cacheElectrons())
    return -1;
  
  // all OK:
  return m_cachedElectrons.size();
}

nMuons()

int xAOD::BPhysHelper::nMuons ( )

inherited

: Methods providing access to the linked muons

By default, xAOD::Vertex provides only links to the TrackParticles used to build the vertex. Links to muons (e.g. for Jpsi->mu+mu) are stored using auxiliary branches. Returns number of stored muon links

Returns

: number of muons, -1 in case of an error

Definition at line 441 of file BPhysHelper.cxx.

{
  // cache linked muons
  if(!cacheMuons())
    return -1;
  
  // all OK:
  return m_cachedMuons.size();
}

nPrecedingVertices()

int xAOD::BPhysHelper::nPrecedingVertices ( )

inherited

: Links to preceding vertices

The B vertices are often build from tracks that have already been pre-selected by requirements based on some preceding vertex fit. For instance, B --> J/psi(mumu)+K vertex is only build using muon tracks that have been successfully refitted in a J/psi->mumu vertex.

The following methods enable to retrieve/store links to the vertices that were preceded this one in the reconstruction flow. Returns number of preceding vertices

Returns

: number of preceding vertices, -1 on error

Definition at line 601 of file BPhysHelper.cxx.

{
  // cache linked preceding vertices
  if(!cachePrecedingVertices())
    return -1;
  
  // all OK:
  return m_cachedPrecedingVertices.size();
   
}

nRefTrks()

int xAOD::BPhysHelper::nRefTrks ( )

inherited

Returns number of stored refitted track momenta.

Methods providing access to the refitted tracks momenta and related quantities:

Returns

: number of refitted tracks, -1 in case of an error

Definition at line 115 of file BPhysHelper.cxx.

{
  // cache refitted tracks
  if( !cacheRefTracks() ) return -1;
  
  // all OK:
  return m_cachedRefTracks.size();
  
}

nRefTrksCascade()

int xAOD::BPhysHelper::nRefTrksCascade ( )

inherited

Returns number of stored refitted tracks INCLUDING those from the linked cascade vertices.

Returns

: number of refitted tracks, -1 in case of an error

Definition at line 764 of file BPhysHelper.cxx.

{
  // get number of refitted tracks in this vertex
  int n = nRefTrks();
  
  // check for errors. If there are cascade vertices stored in this vertex, 
  // it is possible there are no refitted tracks, so report error only in case 
  // when this veretx has no cascade vertices and no refitted tracks:
  if(n<0 && nCascadeVertices()<=0) {
    return -1;
  } else if(n<0 && nCascadeVertices()>0) {
    n = 0;
  }
  
  // loop over cascade vertices, if they exist:
  for(int i=0; i<nCascadeVertices(); ++i) {
    // create helper class for the daughter vertex
    xAOD::BPhysHelper daughterVtx(cascadeVertex(i));
    
    // check for errors
    if(daughterVtx.nRefTrksCascade()<0)
      return -1;
    
    // OK, add the numbers
    n += daughterVtx.nRefTrksCascade();
  }
  
  
  // all OK, return the number of tracks
  return n;
}

origPv()

const xAOD::Vertex * xAOD::BPhysHelper::origPv ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

original PV

Definition at line 807 of file BPhysHelper.cxx.

{        
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_PV("OrigPvMaxSumPt2Link");
    case PV_MIN_A0      : GET_PV("OrigPvMinA0Link");
    case PV_MIN_Z0      : GET_PV("OrigPvMinZ0Link");
    case PV_MIN_Z0_BA   : GET_PV("OrigPvMinZ0BALink");
    default: return nullptr;
  } 
}

pass()

bool xAOD::BPhysHypoHelper::pass

(

)

const

get the pass flag for this hypothesis

Methods for access to the pass flags

Returns

: true, if the candidate passed selection for this hypothesis

Definition at line 361 of file BPhysHypoHelper.cxx.

{
  SG::ConstAccessor<Char_t> flagAcc("passed_"+m_hypo);
  return flagAcc.isAvailable(*m_b) && flagAcc(*m_b) != 0;
}

precedingVertex()

const xAOD::Vertex * xAOD::BPhysHelper::precedingVertex ( const size_t index )

inherited

Returns pointer to a preceding vertex.

Parameters

[in]

index

index of the preceding vertex

Returns

: pointer to the vertex, 0 on error

Definition at line 613 of file BPhysHelper.cxx.

{
  // cache linked precedingVertices
  if(!cachePrecedingVertices())
    return nullptr;
  
  // range check
  if(index>=m_cachedPrecedingVertices.size())
    return nullptr;
  
  // all OK:
  return m_cachedPrecedingVertices[index];
  
}

precedingVertices()

const std::vector< const xAOD::Vertex * > & xAOD::BPhysHelper::precedingVertices ( )

inherited

Returns vector of pointers to preceding vertices.

Returns

: vector of pointers to vertices, empty vector on error

Definition at line 629 of file BPhysHelper.cxx.

{
  // cache linked precedingVertices
  if(!cachePrecedingVertices())
    return xAOD::BPhysHelper::s_emptyVectorOfVertices;
  
  // all OK:
  return m_cachedPrecedingVertices;  
  
}

ptErr()

float xAOD::BPhysHelper::ptErr ( )

inherited

Returns pT error.

Returns

: pT error, -9999999. if augmentation is not available

Definition at line 431 of file BPhysHelper.cxx.

{
  GET_FLOAT("PtErr");
}

pv()

const xAOD::Vertex * xAOD::BPhysHelper::pv ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Get the refitted collision vertex of type pv_type.

Links to the refitted primary vertices

Todo

: In case the refitted vertices are augmented with links to the original primary vertices, method origPv will resolve the links and return the original PVs.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Returns

: pointer to the PV, 0 if not stored refitted PV

Definition at line 796 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_PV("PvMaxSumPt2Link");
    case PV_MIN_A0      : GET_PV("PvMinA0Link");
    case PV_MIN_Z0      : GET_PV("PvMinZ0Link");
    case PV_MIN_Z0_BA   : GET_PV("PvMinZ0BALink");
    default: return nullptr;
  }      
}        

RefitPVStatus()

int xAOD::BPhysHelper::RefitPVStatus ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Get the exitCode of the refitter for vertex of type pv_type.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Returns

: the code 0=refit not request, 1=completed sucessfully, >1 not refitted for good reasons, <0 not refitted for bad reasons (see PrimaryVertexRefitter.cxx for more details)

Definition at line 855 of file BPhysHelper.cxx.

{        
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_INT("PvMaxSumPt2Status");
    case PV_MIN_A0      : GET_INT("PvMinA0Status"    );
    case PV_MIN_Z0      : GET_INT("PvMinZ0Status"    );
    case PV_MIN_Z0_BA   : GET_INT("PvMinZ0BAStatus"  );
    default: return -999999;
  }
}

refTrk() [1/2]

TVector3 xAOD::BPhysHelper::refTrk ( const size_t index )

inherited

Returns i-th refitted track 3-momentum.

Parameters

[in]

index

index of the refitted track

Returns

: refitted track momentum, (0,0,0) in case of an error

Definition at line 126 of file BPhysHelper.cxx.

{
  // cache refitted tracks
  if( !cacheRefTracks() ) return 
      TVector3(0,0,0);
 
  // range check:
  if(index>=m_cachedRefTracks.size())
    return TVector3(0,0,0);
  
  // all OK:
  return m_cachedRefTracks[index];
  
}

refTrk() [2/2]

TLorentzVector xAOD::BPhysHelper::refTrk ( const size_t index, const float mass )

inherited

Returns i-th refitted track as a 4-vector given the mass hypothesis.

Parameters

[in]	index	index of the refitted track
[in]	mass	mass hypothesis assigned to the refitted track

Returns

: refitted track 4-momentum, (0,0,0,0) in case of an error

Definition at line 153 of file BPhysHelper.cxx.

{
  // cache refitted tracks
  if( !cacheRefTracks() ) return 
      TLorentzVector(0,0,0,0);
 
  // range check:
  if(index>=m_cachedRefTracks.size())
    return TLorentzVector(0,0,0,0);
  
  // all OK, create the 4-momentum
  TLorentzVector mom;
  mom.SetVectM(m_cachedRefTracks[index], mass);
  return mom;
  
}

refTrkCharge()

float xAOD::BPhysHelper::refTrkCharge ( const size_t index ) const

inherited

Returns charge of the i-th track.

Note

This method needs access to original TrackParticles (and/or NeutralParticles). If the collection(s) of original tracks has(have) been stripped, this method will return the error value.

Parameters

[in]

index

index of the track

Returns

: 1. for positive track, -1. for negative, and -9999. on error

Definition at line 255 of file BPhysHelper.cxx.

{
  // range check:
  // FIXME: add neutral particles once they are available
  //if(index>=m_b->nTrackParticles()+m_b->nNeutralParticles())
  //  return 0;
  
  // FIXME:supports charged particles only for now  
  if(index>=m_b->nTrackParticles())
    return -9999.;
  
  if(index<m_b->nTrackParticles()) {
    // charged track
    const xAOD::TrackParticle* trk = dynamic_cast<const xAOD::TrackParticle*>(refTrkOrigin(index));
    
    // null-pointer protection
    if(!trk)
      return -9999.;
    
    // all OK
    return trk->charge();
    
  }else{
    // we do not need to do anything here, since we know this track must be neutral
    return 0.;
  }
    
  
}

refTrkOrigin()

const xAOD::IParticle * xAOD::BPhysHelper::refTrkOrigin ( const size_t index ) const

inherited

: Returns the original track (charged or neutral) corresponding to the i-th refitted track

In xAOD model, charged and neutral particles are represented by two distict classes: xAOD::TrackParticle and xAOD::NeutralParticle. Vertex fitters can use both as input and store charded tracks first (needs checking!!!) in the list of refitted momenta.

This method returns pointer to the original track corresponding to the i-th refitted track, i.e. either TrackParticle (if index<nTrackParticles) or NeutralParticle (if index>=nTrackParticles).

One has to dynamicly cast the returned value to either TrackParticle or NeutralParticle. One can use refTrkCharge to determine if the refitted track is charged or neutral.

Note

This method needs access to original TrackParticles (and/or NeutralParticles). If the collection(s) of original tracks has(have) been stripped, this method will return the error value.

Parameters

[in]

index

index of the refitted track

Returns

: pointer to the original TrackParticle (if index<nTrackParticles), pointer to the original NeutralParticle (if index>=nNeutralParticles), 0 in case of an error

Definition at line 171 of file BPhysHelper.cxx.

{
  // range check:
  // FIXME: add neutral particles once they are available
  //if(index>=m_b->nTrackParticles()+m_b->nNeutralParticles())
  //  return 0;
 
  // FIXME:supports charged particles only for now  
  if(index>=m_b->nTrackParticles())
    return nullptr;
  
  // charged tracks
  if(index<m_b->nTrackParticles()) {
    return m_b->trackParticle(index);
  } else  {
    // FIXME: add neutral particles once they are available
    //return m_b->neutralParticle(index - m_b->nNeutralParticles());
    return nullptr;
  }
    
}

refTrkOriginP() [1/2]

TVector3 xAOD::BPhysHelper::refTrkOriginP ( const size_t index ) const

inherited

Returns perigee 3-momentum of the original track corresponding i-th refitted track.

Note

This method needs access to original TrackParticles (and/or NeutralParticles). If the collection(s) of original tracks has(have) been stripped, this method will return the error value.

Parameters

[in]

index

index of the refitted track

Returns

: Original perigee momentum, (0,0,0) in case of an error

Definition at line 194 of file BPhysHelper.cxx.

{
  // range check:
  // FIXME: add neutral particles once they are available
  //if(index>=m_b->nTrackParticles()+m_b->nNeutralParticles())
  //  return TVector3(0,0,0);
  
  // FIXME:supports charged particles only for now  
  if(index>=m_b->nTrackParticles())
    return TVector3(0,0,0);
  
  if(index<m_b->nTrackParticles()) {
    // charged track
    const xAOD::TrackParticle* trk = dynamic_cast<const xAOD::TrackParticle*>(refTrkOrigin(index));
    
    // null-pointer protection
    if(!trk) return TVector3(0,0,0);
    
    // all OK
    TVector3 tmp;
    tmp.SetPtEtaPhi(trk->pt(), trk->eta(), trk->phi());
    return tmp;
    
  }else{
    // // neutral track
    // const xAOD::NeutralParticle* trk = dynamic_cast<const xAOD::NeutralParticle*>(refTrkOrigin(index));
       
    // // null-pointer protection
    // if(!trk) return TVector3(0,0,0);
       
    // // all OK
    // TVector3 tmp;
    // tmp.SetPtEtaPhi(trk->pt(), trk->eta(), trk->phi());
    // return tmp;
    
    // FIXME neutral tracks not implemented yet:
    return TVector3(0,0,0);
  }
  
}

refTrkOriginP() [2/2]

TLorentzVector xAOD::BPhysHelper::refTrkOriginP ( const size_t index, const float mass ) const

inherited

: Returns lorentz vector build from the original track perigee momentum and given mass hypothesis

The lorentz vector is created from the perigee parameters of the original track (neutral or charged) which corresponds to the i-th refitted track and a given mass hypothesis

Note

This method needs access to original TrackParticles (and/or NeutralParticles). If the collection(s) of original tracks has(have) been stripped, this method will return the error value.

Parameters

[in]	index	index of the refitted track
[in]	mass	mass hypothesis of the track

Returns

: Original perigee momentum, (0,0,0,0) in case of an error

Definition at line 236 of file BPhysHelper.cxx.

{
  // range check:
  // FIXME: add neutral particles once they are available
  //if(index>=m_b->nTrackParticles()+m_b->nNeutralParticles())
  //  return TVector3(0,0,0);
  
  // FIXME:supports charged particles only for now  
  if(index>=m_b->nTrackParticles())
    return TLorentzVector(0,0,0,0);
  
  // create TLorentzVector
  TLorentzVector tmp;
  tmp.SetVectM(refTrkOriginP(index), mass);
  return tmp;
  
}

refTrks()

const std::vector< TVector3 > & xAOD::BPhysHelper::refTrks ( )

inherited

Returns refitted track momenta.

Note

The std::vector is returned as a reference! It will cease to exist when BPhysHelper class is destroyed.

Returns

: refitted track, empty vector in case of an error

Definition at line 142 of file BPhysHelper.cxx.

{
  // cache refitted tracks
  if( !cacheRefTracks() ) 
    return xAOD::BPhysHelper::s_emptyVectorOfTVector3;
 
  // return
  return m_cachedRefTracks;  
}

set_float()

bool xAOD::BPhysHypoHelper::set_float ( const std::string & name, float val )

private

Definition at line 28 of file BPhysHypoHelper.cxx.

{
  SG::Decorator<float> floatDec(name);
  floatDec(*m_b) = val;
  if (m_decors) {
    m_decors->insert (floatDec.auxid());
  }
  return true;
}

setA0()

float xAOD::BPhysHelper::setA0 ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Set the 3D and transverse impact parameters and their error.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Parameters

[in]

val

input value

Returns

: true on success 3D impact parameter

Definition at line 1023 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("A0MaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("A0MinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("A0MinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("A0MinZ0BA"  , val);
    default: return false;
  }  
}

setA0Err()

float xAOD::BPhysHelper::setA0Err ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

3D impact parameter error

Definition at line 1034 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("A0ErrMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("A0ErrMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("A0ErrMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("A0ErrMinZ0BA"  , val);
    default: return false;
  }    
}

setA0xy()

float xAOD::BPhysHelper::setA0xy ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

transverse impact parameter

Definition at line 1045 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("A0xyMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("A0xyMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("A0xyMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("A0xyMinZ0BA"  , val);
    default: return false;
  }    
}

setA0xyErr()

float xAOD::BPhysHelper::setA0xyErr ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

transverse impact parameter error

Definition at line 1056 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("A0xyErrMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("A0xyErrMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("A0xyErrMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("A0xyErrMinZ0BA"  , val);
    default: return false;
  }    
}

setCascadeVertices()

bool xAOD::BPhysHelper::setCascadeVertices ( const std::vector< const xAOD::Vertex * > & vertices, const xAOD::VertexContainer * vertexContainer )

inherited

Sets links to cascade vertices.

Parameters

[in]

index

index of the cascade vertex

Returns

: pointer to the vertex, 0 on error

Definition at line 722 of file BPhysHelper.cxx.

{
  // erase cascadeVertex cache to preserve consistency
  m_cascadeVerticesCached = false;
  m_cachedCascadeVertices.clear();
  
  // Create cascade vertex links decorator 
  static const SG::AuxElement::Decorator<VertexLinkVector> cascadeVertexLinksDecor("CascadeVertexLinks"); 
  
  // create tmp vector of cascade vertex links
  VertexLinkVector cascadeVertexLinks;
 
  // loop over input cascadeVertices  
  std::vector<const xAOD::Vertex*>::const_iterator cascadeVerticesItr = vertices.begin();
  for(; cascadeVerticesItr!=vertices.end(); ++cascadeVerticesItr) {
    // sanity check 1: protect against null pointers
    if( !(*cascadeVerticesItr) )
      return false;
    
    // create element link
    VertexLink vertexLink;
    vertexLink.setElement(*cascadeVerticesItr);
    vertexLink.setStorableObject(*vertexContainer);
    
    // sanity check 2: is the link valid?
    if( !vertexLink.isValid() )
      return false;
    
    // link is OK, store it in the tmp vector
    cascadeVertexLinks.push_back( vertexLink );
    
  } // end of loop over cascade vertices
  
  // all OK: store cascade vertex links in the aux store
  cascadeVertexLinksDecor(*m_b) = std::move(cascadeVertexLinks);
  
  return true;
  
}

setElectrons()

bool xAOD::BPhysHelper::setElectrons ( const std::vector< const xAOD::Electron * > & electrons, const xAOD::ElectronContainer * electronContainer )

inherited

Definition at line 559 of file BPhysHelper.cxx.

{
  // erase electron cache to preserve cosistency
  m_electronsCached = false;
  m_cachedElectrons.clear();
  
  // Create electron links decorator 
  static const SG::AuxElement::Decorator<ElectronLinkVector> electronLinksDecor("ElectronLinks"); 
  
  // create tmp vector of electron links
  ElectronLinkVector electronLinks;
 
  // loop over input electrons  
  std::vector<const xAOD::Electron*>::const_iterator electronsItr = electrons.begin();
  for(; electronsItr!=electrons.end(); ++electronsItr) {
    // sanity check 1: protect against null pointers
    if( !(*electronsItr) )
      return false;
    
    // create element link
    ElementLink<xAOD::ElectronContainer> elLink;
    elLink.setElement(*electronsItr);
    elLink.setStorableObject(*electronContainer);
    
    // sanity check 2: is the link valid?
    if( !elLink.isValid() )
      return false;
    
    // link is OK, store it in the tmp vector
    electronLinks.push_back( elLink );
    
  } // end of loop over electrons
  
  // all OK: store electron links in the aux store
  electronLinksDecor(*m_b) = std::move(electronLinks);
  
  return true;
  
}

setLxy()

bool xAOD::BPhysHelper::setLxy ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Set the transverse decay distance and its error measured between the refitted primary vertex of type pv_type and the B vertex.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Parameters

[in]

val

input value

Returns

: true on success decay distance

Definition at line 888 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("LxyMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("LxyMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("LxyMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("LxyMinZ0BA"  , val);
    default: return false;
  }
}

setLxyErr()

bool xAOD::BPhysHelper::setLxyErr ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

its error

Definition at line 899 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("LxyErrMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("LxyErrMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("LxyErrMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("LxyErrMinZ0BA"  , val);
    default: return false;
  }
}

setLxyz()

bool xAOD::BPhysHelper::setLxyz ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

decay distance

Definition at line 934 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("LxyzMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("LxyzMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("LxyzMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("LxyzMinZ0BA"  , val);
    default: return false;
  }
}

setLxyzErr()

bool xAOD::BPhysHelper::setLxyzErr ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

its error

Definition at line 945 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("LxyzErrMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("LxyzErrMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("LxyzErrMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("LxyzErrMinZ0BA"  , val);
    default: return false;
  }
}

setMass() [1/2]

bool xAOD::BPhysHypoHelper::setMass

(

const float

val

)

Set given invariant mass and its error.

Parameters

[in]

val

invariant mass or error calculated externally

Returns

: true on success invariant mass

Definition at line 52 of file BPhysHypoHelper.cxx.

{
  return set_float( m_hypo+"_mass", val );
}

setMass() [2/2]

bool xAOD::BPhysHypoHelper::setMass

(

std::span< const double >

trkMasses

)

Set invariant mass for given track mass hypotheses.

The number of mass hyotheses must be equal to the number of refitted tracks!

Parameters

[in]

trkMasses

masses of the tracks.

Returns

: true on success

Definition at line 62 of file BPhysHypoHelper.cxx.

{
  // get 4-vector
  TLorentzVector P = totalP(trkMasses);
  if( P == TLorentzVector(0,0,0,0) )
    return false;
  
  // set mass:
  return setMass(P.M());  
}

setMassErr()

bool xAOD::BPhysHypoHelper::setMassErr

(

const float

val

)

invariant mass error

Definition at line 57 of file BPhysHypoHelper.cxx.

{
  return set_float( m_hypo+"_massErr", val );  
}

setMuons()

bool xAOD::BPhysHelper::setMuons ( const std::vector< const xAOD::Muon * > & muons, const xAOD::MuonContainer * muonContainer )

inherited

Set links to muons.

Parameters

[in]	muons	std::vector of muons to be linked to this vertex
[in]	muonContainer	collection these muons belong to

Returns

: true on success

Definition at line 479 of file BPhysHelper.cxx.

{
  // erase muon cache to preserve cosistency
  m_muonsCached = false;
  m_cachedMuons.clear();
  
  // Create muon links decorator 
  static const SG::AuxElement::Decorator<MuonLinkVector> muonLinksDecor("MuonLinks"); 
  
  // create tmp vector of muon links
  MuonLinkVector muonLinks;
 
  // loop over input muons  
  std::vector<const xAOD::Muon*>::const_iterator muonsItr = muons.begin();
  for(; muonsItr!=muons.end(); ++muonsItr) {
    // sanity check 1: protect against null pointers
    if( !(*muonsItr) )
      return false;
    
    // create element link
    ElementLink<xAOD::MuonContainer> muLink;
    muLink.setElement(*muonsItr);
    muLink.setStorableObject(*muonContainer);
    
    // sanity check 2: is the link valid?
    if( !muLink.isValid() )
      return false;
    
    // link is OK, store it in the tmp vector
    muonLinks.push_back( muLink );
    
  } // end of loop over muons
  
  // all OK: store muon links in the aux store
  muonLinksDecor(*m_b) = std::move(muonLinks);
  
  return true;
  
}

setOrigPv()

bool xAOD::BPhysHelper::setOrigPv ( const xAOD::Vertex * pv, const xAOD::VertexContainer * vertexContainer, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Set the original collision vertex of type pv_type.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Parameters

[in]	pv	pointer to the PV
[in]	vertexContainer	collection in which the PV is stored

Returns

: true on success, false on failure

Definition at line 818 of file BPhysHelper.cxx.

{        
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_PV("OrigPvMaxSumPt2Link", pv, vertexContainer);
    case PV_MIN_A0      : SET_PV("OrigPvMinA0Link"    , pv, vertexContainer);
    case PV_MIN_Z0      : SET_PV("OrigPvMinZ0Link"    , pv, vertexContainer);
    case PV_MIN_Z0_BA   : SET_PV("OrigPvMinZ0BALink"  , pv, vertexContainer);
    default: return 0;
  } 
}

setPass()

bool xAOD::BPhysHypoHelper::setPass

(

bool

passVal

)

get the pass flag for this hypothesis

Parameters

[in]

input

value. Will be converted to Char_t

Returns

: true on success

Definition at line 367 of file BPhysHypoHelper.cxx.

{
  SG::Decorator<Char_t> flagDec("passed_"+m_hypo);
  flagDec(*m_b) = passVal;
  if (m_decors) {
    m_decors->insert(flagDec.auxid());
  }
  return true;
}

setPrecedingVertices()

bool xAOD::BPhysHelper::setPrecedingVertices ( const std::vector< const xAOD::Vertex * > & vertices, const xAOD::VertexContainer * vertexContainer )

inherited

Sets links to preceding vertices.

Parameters

[in]

index

index of the preceding vertex

Returns

: pointer to the vertex, 0 on error

Definition at line 641 of file BPhysHelper.cxx.

{
  // erase precedingVertex cache to preserve consistency
  m_precedingVerticesCached = false;
  m_cachedPrecedingVertices.clear();
  
  // Create preceding vertex links decorator 
  static const SG::AuxElement::Decorator<VertexLinkVector> precedingVertexLinksDecor("PrecedingVertexLinks"); 
  
  // create tmp vector of preceding vertex links
  VertexLinkVector precedingVertexLinks;
 
  // loop over input precedingVertices  
  std::vector<const xAOD::Vertex*>::const_iterator precedingVerticesItr = vertices.begin();
  for(; precedingVerticesItr!=vertices.end(); ++precedingVerticesItr) {
    // sanity check 1: protect against null pointers
    if( !(*precedingVerticesItr) )
      return false;
    
    // create element link
    VertexLink vertexLink;
    vertexLink.setElement(*precedingVerticesItr);
    vertexLink.setStorableObject(*vertexContainer);
    
    // sanity check 2: is the link valid?
    if( !vertexLink.isValid() )
      return false;
    
    // link is OK, store it in the tmp vector
    precedingVertexLinks.push_back( vertexLink );
    
  } // end of loop over preceding vertices
  
  // all OK: store preceding vertex links in the aux store
  precedingVertexLinksDecor(*m_b) = std::move(precedingVertexLinks);
  
  return true;
  
}

setPtErr()

bool xAOD::BPhysHelper::setPtErr ( const float val )

inherited

Set pT error.

Parameters

[in]

input

value

Returns

: true on success

Definition at line 436 of file BPhysHelper.cxx.

{
  SET_FLOAT("PtErr", val);
}

setPv()

bool xAOD::BPhysHelper::setPv ( const xAOD::Vertex * pv, const xAOD::VertexContainer * vertexContainer, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Set the refitted collision vertex of type pv_type.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Parameters

[in]	pv	pointer to the PV
[in]	vertexContainer	collection in which the PV is stored

Returns

: true on success, false on failure

Definition at line 831 of file BPhysHelper.cxx.

{        
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_PV("PvMaxSumPt2Link", pv, vertexContainer);
    case PV_MIN_A0      : SET_PV("PvMinA0Link"    , pv, vertexContainer);
    case PV_MIN_Z0      : SET_PV("PvMinZ0Link"    , pv, vertexContainer);
    case PV_MIN_Z0_BA   : SET_PV("PvMinZ0BALink"  , pv, vertexContainer);
    default: return false;
  }
}

setRefitPVStatus()

bool xAOD::BPhysHelper::setRefitPVStatus ( int code, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

Set the exitCode of the refitter for vertex of type pv_type.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: pv_type)

Parameters

[in]

code

int containing the code

Returns

: true on success, false on failure

Definition at line 844 of file BPhysHelper.cxx.

{        
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_INT("PvMaxSumPt2Status", code);
    case PV_MIN_A0      : SET_INT("PvMinA0Status"    , code);
    case PV_MIN_Z0      : SET_INT("PvMinZ0Status"    , code);
    case PV_MIN_Z0_BA   : SET_INT("PvMinZ0BAStatus"  , code);
    default: return 0;
  } 
}

setRefTrks() [1/3]

bool xAOD::BPhysHelper::setRefTrks ( )

inherited

: Sets refitted track momenta

This method uses as input the tracks-at-vertex branch (std::vector< Trk::VxTrackAtVertex >) in xAOD::Vertex. This method only works in ATHENA and only for transient xAOD::Vertex instances, which still hold the refitted tracks as vxTrackAtVertex branch. Once the vertex class is stored in the xAOD file, the vxTrackAtVertex branch is lost.

This method is meant to be called by the vertex fitters immediately after the vertex is created to convert vxTrackAtVertex branch into the persistifiable form.

Returns

: true on success

Definition at line 341 of file BPhysHelper.cxx.

{
  // refitted momenta
  std::vector<float> px;
  std::vector<float> py;
  std::vector<float> pz;
  const auto N = vtx()->vxTrackAtVertex().size();
  px.reserve(N);
  py.reserve(N);
  pz.reserve(N);
  // loop over refitted tracks at vertex
  for(uint i=0; i<N; ++i) {
    const Trk::TrackParameters* aPerigee = vtx()->vxTrackAtVertex()[i].perigeeAtVertex();
    //sanity check
    if(!aPerigee) 
      return false;
    
    // store individual momentum components
    px.push_back( aPerigee->momentum()[Trk::px] );
    py.push_back( aPerigee->momentum()[Trk::py] );
    pz.push_back( aPerigee->momentum()[Trk::pz] );
  }
  
  // store as augmentation:
  setRefTrks(std::move(px), std::move(py), std::move(pz));
  
  // all OK
  return true;
  
}

setRefTrks() [2/3]

bool xAOD::BPhysHelper::setRefTrks ( const std::vector< TVector3 > & refTrks )

inherited

Sets refitted track momenta.

Parameters

[in]

refTrks

std::vector of refitted momenta as TVector3

Returns

: true on success

Definition at line 312 of file BPhysHelper.cxx.

{
  // sanity check
  if(refTrks.empty())
    return false;
  
  // tmp vectors of px,py,pz components:
  std::vector<float> px;  
  std::vector<float> py;  
  std::vector<float> pz;
  px.reserve(refTrks.size());
  py.reserve(refTrks.size());
  pz.reserve(refTrks.size());
  // loop over refitted track momenta and store the components
  std::vector<TVector3>::const_iterator refTrksItr = refTrks.begin();
  for(; refTrksItr!=refTrks.end(); ++refTrksItr) {
    px.push_back( refTrksItr->Px() );
    py.push_back( refTrksItr->Py() );
    pz.push_back( refTrksItr->Pz() );
  }
  
  // call overloaded method:
  return setRefTrks(std::move(px),std::move(py),std::move(pz));
 
}

setRefTrks() [3/3]

bool xAOD::BPhysHelper::setRefTrks ( std::vector< float > px, std::vector< float > py, std::vector< float > pz )

inherited

Sets refitted track momenta.

Parameters

[in]

px,py,pz

components of the refitted momenta

Returns

: true on success

Definition at line 286 of file BPhysHelper.cxx.

{
  // sanity check:
  if(px.size()!=py.size() || px.size()!=pz.size())
    return false;
  
  // erase refitted track cache to preserve consistency
  m_refTracksCached = false;
  m_cachedRefTracks.clear();
  
  // create decorators
  static const SG::AuxElement::Decorator< std::vector<float> > refTrackPxDeco("RefTrackPx");
  static const SG::AuxElement::Decorator< std::vector<float> > refTrackPyDeco("RefTrackPy");
  static const SG::AuxElement::Decorator< std::vector<float> > refTrackPzDeco("RefTrackPz");
  
  // store the elements:
  refTrackPxDeco(*m_b) = std::move(px);
  refTrackPyDeco(*m_b) = std::move(py);
  refTrackPzDeco(*m_b) = std::move(pz);
  
  return true;
}

setTau()

bool xAOD::BPhysHypoHelper::setTau	(	const float	val,
		const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

: Set the proper decay time and error.

Parameters

[in]	val	input value
[in]	vertexType	type (selection) of the PV (

See also

: BPhysHelper::pv_type)

Parameters

[in]

tauType

specify which value of particle's mass was used (

See also

: tau_type)

Returns

: true on success proper decay time

Definition at line 143 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauConstMassPVMaxSumPt2", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauInvMassPVMaxSumPt2", val);
        default: return false;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauConstMassPVMinA0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauInvMassPVMinA0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauConstMassPVMinZ0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauInvMassPVMinZ0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauConstMassPVMinZ0BA", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauInvMassPVMinZ0BA", val);
        default: return false;
      }
    }
    default: return false;
  }  
  
}

setTau3d()

bool xAOD::BPhysHypoHelper::setTau3d	(	const float	val,
		const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

proper decay time

Definition at line 286 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
      case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dConstMassPVMaxSumPt2", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dInvMassPVMaxSumPt2", val);
        default: return false;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dConstMassPVMinA0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dInvMassPVMinA0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dConstMassPVMinZ0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dInvMassPVMinZ0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dConstMassPVMinZ0BA", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dInvMassPVMinZ0BA", val);
        default: return false;
      }
    }
    default: return false;
  }  
  
}

setTau3dErr()

bool xAOD::BPhysHypoHelper::setTau3dErr	(	const float	val,
		const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

proper decay time error

Definition at line 322 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dErrConstMassPVMaxSumPt2", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dErrInvMassPVMaxSumPt2", val);
        default: return false;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dErrConstMassPVMinA0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dErrInvMassPVMinA0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dErrConstMassPVMinZ0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dErrInvMassPVMinZ0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_Tau3dErrConstMassPVMinZ0BA", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_Tau3dErrInvMassPVMinZ0BA", val);
        default: return false;
      }
    }
    default: return false;
  }    
}

setTauErr()

bool xAOD::BPhysHypoHelper::setTauErr	(	const float	val,
		const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

proper decay time error

Definition at line 179 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauErrConstMassPVMaxSumPt2", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauErrInvMassPVMaxSumPt2", val);
        default: return false;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauErrConstMassPVMinA0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauErrInvMassPVMinA0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauErrConstMassPVMinZ0", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauErrInvMassPVMinZ0", val);
        default: return false;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return set_float(m_hypo+"_TauErrConstMassPVMinZ0BA", val);
        case TAU_INV_MASS   : return set_float(m_hypo+"_TauErrInvMassPVMinZ0BA", val);
        default: return false;
      }
    }
    default: return false;
  }    
}

setZ0()

float xAOD::BPhysHelper::setZ0 ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

longitudinal impact parameter

Definition at line 1067 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("Z0MaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("Z0MinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("Z0MinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("Z0MinZ0BA"  , val);
    default: return false;
  }  
}

setZ0Err()

float xAOD::BPhysHelper::setZ0Err ( const float val, const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

longitudinal impact parameter error

Definition at line 1078 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : SET_FLOAT("Z0ErrMaxSumPt2", val);
    case PV_MIN_A0      : SET_FLOAT("Z0ErrMinA0"    , val);
    case PV_MIN_Z0      : SET_FLOAT("Z0ErrMinZ0"    , val);
    case PV_MIN_Z0_BA   : SET_FLOAT("Z0ErrMinZ0BA"  , val);
    default: return false;
  }    
}

tau()

float xAOD::BPhysHypoHelper::tau	(	const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

: Get the proper decay time and error.

The proper decay time is calculated using formula c*tau = Lxy * M / pT. The Lxy can be calculated wrt different choice of the PV. Use parameter vertexType to specify which PV was used. The particle's mass M can be either taken as a constant or as measured invariant mass. Use parameter tauType to specify which value should be used.

Parameters

[in]

vertexType

type (selection) of the PV (

See also

: BPhysHelper::pv_type)

Parameters

[in]

tauType

specify which value of particle's mass was used (

See also

: tau_type)

Returns

: proper decay time, -9999999. on error proper decay time

Definition at line 73 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauConstMassPVMaxSumPt2");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauInvMassPVMaxSumPt2");
        default: return -9999999.;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauConstMassPVMinA0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauInvMassPVMinA0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauConstMassPVMinZ0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauInvMassPVMinZ0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauConstMassPVMinZ0BA");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauInvMassPVMinZ0BA");
        default: return -9999999.;
      }
    }
    default: return -9999999.;
  }  
}

tau3d()

float xAOD::BPhysHypoHelper::tau3d	(	const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

proper decay time

Definition at line 216 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dConstMassPVMaxSumPt2");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dInvMassPVMaxSumPt2");
        default: return -9999999.;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dConstMassPVMinA0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dInvMassPVMinA0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dConstMassPVMinZ0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dInvMassPVMinZ0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dConstMassPVMinZ0BA");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dInvMassPVMinZ0BA");
        default: return -9999999.;
      }
    }
    default: return -9999999.;
  }  
}

tau3dErr()

float xAOD::BPhysHypoHelper::tau3dErr	(	const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

proper decay time error

Definition at line 251 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dErrConstMassPVMaxSumPt2");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dErrInvMassPVMaxSumPt2");
        default: return -9999999.;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dErrConstMassPVMinA0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dErrInvMassPVMinA0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dErrConstMassPVMinZ0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dErrInvMassPVMinZ0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_Tau3dErrConstMassPVMinZ0BA");
        case TAU_INV_MASS   : return get_float(m_hypo+"_Tau3dErrInvMassPVMinZ0BA");
        default: return -9999999.;
      }
    }
    default: return -9999999.;
  }    
}

tauErr()

float xAOD::BPhysHypoHelper::tauErr	(	const pv_type	vertexType = BPhysHelper::PV_MIN_A0,
		const tau_type	tauType = BPhysHypoHelper::TAU_CONST_MASS )

proper decay time error

Definition at line 108 of file BPhysHypoHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauErrConstMassPVMaxSumPt2");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauErrInvMassPVMaxSumPt2");
        default: return -9999999.;
      }
    }
    case PV_MIN_A0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauErrConstMassPVMinA0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauErrInvMassPVMinA0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauErrConstMassPVMinZ0");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauErrInvMassPVMinZ0");
        default: return -9999999.;
      }
    }
    case PV_MIN_Z0_BA: {
      switch(tauType) {
        case TAU_CONST_MASS : return get_float(m_hypo+"_TauErrConstMassPVMinZ0BA");
        case TAU_INV_MASS   : return get_float(m_hypo+"_TauErrInvMassPVMinZ0BA");
        default: return -9999999.;
      }
    }
    default: return -9999999.;
  }    
}

totalP() [1/2]

TVector3 xAOD::BPhysHelper::totalP ( )

inherited

: Returns total 3-momentum calculated from the refitted tracks

Total momentum calculated from refitted tracks

Returns total 3-momentum calculated from the refitted tracks.

Note

In case that this vertex has some linked cascade vertices, it adds the total momentum in the cascade vertices.

Returns

: Total momentum, (0,0,0) on error

Definition at line 374 of file BPhysHelper.cxx.

{
  // cache refitted tracks
  if( !cacheRefTracks() && nCascadeVertices()<=0) {
    // In case of cascade decays, vector with no refitted tracks can still be correct.
    // Therefore, return error only is this is not the case
    return TVector3(0,0,0);
  }
  
  // sum the momenta
  TVector3 sum(0,0,0);
  int n = nRefTrks();
  for(int i=0; i<n; ++i) {
    sum += refTrk(i);
  }
  
  // treat cascade vertices, if they exist
  if(nCascadeVertices()>0) {
    for(int i=0; i<nCascadeVertices(); ++i) {
      // create helper class for the daughter vertex
      xAOD::BPhysHelper daughterVtx( cascadeVertex(i) );
      TVector3 daughterP = daughterVtx.totalP();
      
      // check that the daughter total momentum was retrieved correctly
      if(daughterP==TVector3(0,0,0))
        return TVector3(0,0,0);
      
      //OK, sum the momenta
      sum += daughterP;
    }
  }
  
  return sum;
}

totalP() [2/2]

TLorentzVector xAOD::BPhysHelper::totalP ( std::span< const double > masses )

inherited

Returns total 4-momentum calculated from the refitted tracks given mass hypotheses for individual tracks.

Parameters

[in]

masses

invariant mass hypotheses

Returns

: Total 4-momentum, (0,0,0,0) on error

Definition at line 410 of file BPhysHelper.cxx.

{
  // cache refitted tracks
  if( !cacheRefTracks() ) 
    return TLorentzVector(0,0,0,0);
  int n = nRefTrks();
  // input check
  if(int(masses.size()) != n)
    return TLorentzVector(0,0,0,0);
  
  // sum the 4-momenta
  TLorentzVector sum;
  for(int i=0; i<n; ++i) {
    sum += refTrk(i, masses[i]);
  }
  
  return sum;
   
}

vtx()

const xAOD::Vertex * xAOD::BPhysHelper::vtx ( ) const

inlineinherited

Getter method for the cached xAOD::Vertex.

Returns

: cached xAOD::Vertex

Definition at line 108 of file BPhysHelper.h.

{ return m_b; }

z0()

float xAOD::BPhysHelper::z0 ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

longitudinal impact parameter

Definition at line 1001 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("Z0MaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("Z0MinA0");
    case PV_MIN_Z0      : GET_FLOAT("Z0MinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("Z0MinZ0BA");
    default: return -9999999.;
  }
}

z0Err()

float xAOD::BPhysHelper::z0Err ( const pv_type vertexType = BPhysHelper::PV_MIN_A0 )

inherited

longitudinal impact parameter error

Definition at line 1012 of file BPhysHelper.cxx.

{
  switch(vertexType) {
    case PV_MAX_SUM_PT2 : GET_FLOAT("Z0ErrMaxSumPt2");
    case PV_MIN_A0      : GET_FLOAT("Z0ErrMinA0");
    case PV_MIN_Z0      : GET_FLOAT("Z0ErrMinZ0");
    case PV_MIN_Z0_BA   : GET_FLOAT("Z0ErrMinZ0BA");
    default: return -9999999.;
  }
}

Member Data Documentation

m_b

const xAOD::Vertex* xAOD::BPhysHelper::m_b

protectedinherited

Cached B decay xAOD vertex.

Definition at line 674 of file BPhysHelper.h.

m_cachedCascadeVertices

std::vector<const xAOD::Vertex*> xAOD::BPhysHelper::m_cachedCascadeVertices

protectedinherited

Definition at line 716 of file BPhysHelper.h.

m_cachedCov

TMatrixTSym<double> xAOD::BPhysHelper::m_cachedCov

protectedinherited

Definition at line 682 of file BPhysHelper.h.

m_cachedElectrons

std::vector<const xAOD::Electron*> xAOD::BPhysHelper::m_cachedElectrons

protectedinherited

Definition at line 704 of file BPhysHelper.h.

m_cachedMuons

std::vector<const xAOD::Muon*> xAOD::BPhysHelper::m_cachedMuons

protectedinherited

Definition at line 703 of file BPhysHelper.h.

m_cachedPrecedingVertices

std::vector<const xAOD::Vertex*> xAOD::BPhysHelper::m_cachedPrecedingVertices

protectedinherited

Definition at line 714 of file BPhysHelper.h.

m_cachedRefTracks

std::vector<TVector3> xAOD::BPhysHelper::m_cachedRefTracks

protectedinherited

Definition at line 692 of file BPhysHelper.h.

m_cascadeVerticesCached

bool xAOD::BPhysHelper::m_cascadeVerticesCached

protectedinherited

Definition at line 715 of file BPhysHelper.h.

m_covCached

bool xAOD::BPhysHelper::m_covCached

protectedinherited

cached covariance matrix

Definition at line 681 of file BPhysHelper.h.

m_decors

SG::auxid_set_t* xAOD::BPhysHypoHelper::m_decors

protected

set of decorations that we're written

Definition at line 220 of file BPhysHypoHelper.h.

m_electronsCached

bool xAOD::BPhysHelper::m_electronsCached

protectedinherited

Definition at line 702 of file BPhysHelper.h.

m_hypo

std::string xAOD::BPhysHypoHelper::m_hypo

protected

name of the mass hypothesis

Private attributes:

Definition at line 218 of file BPhysHypoHelper.h.

m_muonsCached

bool xAOD::BPhysHelper::m_muonsCached

protectedinherited

cached linked muons

Definition at line 701 of file BPhysHelper.h.

m_precedingVerticesCached

bool xAOD::BPhysHelper::m_precedingVerticesCached

protectedinherited

cached linked vertices

Definition at line 713 of file BPhysHelper.h.

m_refTracksCached

bool xAOD::BPhysHelper::m_refTracksCached

protectedinherited

cached refitted track momenta

Definition at line 691 of file BPhysHelper.h.

n_pv_types

const unsigned int xAOD::BPhysHelper::n_pv_types = 4

staticinherited

Return number of vertex association types (useful for loops).

Some useful static consts

Definition at line 613 of file BPhysHelper.h.

pv_type_str

const std::string xAOD::BPhysHelper::pv_type_str

staticinherited

Initial value:

= 
  {"PV_MAX_SUM_PT2", "PV_MIN_A0", "PV_MIN_Z0", "PV_MIN_Z0_BA"}

Return string names for vertex association types.

Definition at line 35 of file BPhysHelper.h.

                                       {

s_emptyMatrix

const TMatrixTSym< double > xAOD::BPhysHelper::s_emptyMatrix

staticprotectedinherited

Definition at line 728 of file BPhysHelper.h.

s_emptyVectorOfElectrons

const std::vector< const xAOD::Electron * > xAOD::BPhysHelper::s_emptyVectorOfElectrons

staticprotectedinherited

Definition at line 727 of file BPhysHelper.h.

s_emptyVectorOfMuons

const std::vector< const xAOD::Muon * > xAOD::BPhysHelper::s_emptyVectorOfMuons

staticprotectedinherited

Definition at line 726 of file BPhysHelper.h.

s_emptyVectorOfTVector3

const std::vector< TVector3 > xAOD::BPhysHelper::s_emptyVectorOfTVector3

staticprotectedinherited

Return error values for vector quantities:

Definition at line 725 of file BPhysHelper.h.

s_emptyVectorOfVertices

const std::vector< const xAOD::Vertex * > xAOD::BPhysHelper::s_emptyVectorOfVertices

staticprotectedinherited

Definition at line 729 of file BPhysHelper.h.

---

The documentation for this class was generated from the following files:

• BPhysHypoHelper.h
• BPhysHypoHelper.cxx