xAOD::BPhysHelper Class Reference

#include <BPhysHelper.h>

Inheritance diagram for xAOD::BPhysHelper:

Collaboration diagram for xAOD::BPhysHelper:

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
	BPhysHelper (const xAOD::Vertex *b)
	: Main constructor More...
const xAOD::Vertex *	vtx () const
	Getter method for the cached xAOD::Vertex. More...
const TMatrixTSym< double > &	covariance ()
	: Returns full covariance matrix More...

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

Protected Attributes
const xAOD::Vertex *	m_b
	Cached B decay xAOD vertex. More...

Detailed Description

Definition at line 71 of file BPhysHelper.h.

Member Enumeration Documentation

pv_type

enum xAOD::BPhysHelper::pv_type

: 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};

Constructor & Destructor Documentation

BPhysHelper()

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

inline

: Main constructor

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

Parameters

[in]

b

Pointer to the xAOD::Vertex

Definition at line 85 of file BPhysHelper.h.

                                       :
        m_b(b),
        m_covCached(false),
        m_cachedCov(0),
        m_refTracksCached(false),
        m_cachedRefTracks(0),
        m_muonsCached(false),
        m_electronsCached(false),
        m_cachedMuons(0),
        m_cachedElectrons(0),
        m_precedingVerticesCached(false),
        m_cachedPrecedingVertices(0),
        m_cascadeVerticesCached(false),
        m_cachedCascadeVertices(0)
      { 
        assert(m_b!=0); // sanity check: m_b must not be null
      }

Member Function Documentation

a0()

float xAOD::BPhysHelper::a0

(

const pv_type

vertexType = BPhysHelper::PV_MIN_A0

)

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

)

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

)

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

)

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 ( )

protected

: 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 ( )

protected

: 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 ( )

protected

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 ( )

protected

: 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 ( )

protected

: 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 ( )

protected

: 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

)

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

(

)

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

(

)

: 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

)

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

(

)

Definition at line 548 of file BPhysHelper.cxx.

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

lxy()

float xAOD::BPhysHelper::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.

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

)

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

)

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

)

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.;
  }
}

muon()

const xAOD::Muon * xAOD::BPhysHelper::muon

(

const size_t

index

)

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

(

)

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

(

)

: 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

(

)

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

(

)

: 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

(

)

: 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

(

)

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

(

)

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

)

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;
  } 
}

precedingVertex()

const xAOD::Vertex * xAOD::BPhysHelper::precedingVertex

(

const size_t

index

)

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

(

)

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

(

)

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

)

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

)

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

)

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
	)

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

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

: 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

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

: 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

(

)

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;  
}

setA0()

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

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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
	)

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;
  }
}

setMuons()

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

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
	)

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;
  } 
}

setPrecedingVertices()

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

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

)

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
	)

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
	)

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

(

)

: 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

)

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
	)

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;
}

setZ0()

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

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
	)

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;
  }    
}

totalP() [1/2]

TVector3 xAOD::BPhysHelper::totalP

(

)

: Returns total 3-momentum calculated from the refitted tracks

Total momentum calculated from refitted tracksReturns 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

)

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

inline

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

)

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

)

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

protected

Cached B decay xAOD vertex.

Definition at line 674 of file BPhysHelper.h.

m_cachedCascadeVertices

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

protected

Definition at line 716 of file BPhysHelper.h.

m_cachedCov

TMatrixTSym<double> xAOD::BPhysHelper::m_cachedCov

protected

Definition at line 682 of file BPhysHelper.h.

m_cachedElectrons

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

protected

Definition at line 704 of file BPhysHelper.h.

m_cachedMuons

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

protected

Definition at line 703 of file BPhysHelper.h.

m_cachedPrecedingVertices

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

protected

Definition at line 714 of file BPhysHelper.h.

m_cachedRefTracks

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

protected

Definition at line 692 of file BPhysHelper.h.

m_cascadeVerticesCached

bool xAOD::BPhysHelper::m_cascadeVerticesCached

protected

Definition at line 715 of file BPhysHelper.h.

m_covCached

bool xAOD::BPhysHelper::m_covCached

protected

cached covariance matrix

Definition at line 681 of file BPhysHelper.h.

m_electronsCached

bool xAOD::BPhysHelper::m_electronsCached

protected

Definition at line 702 of file BPhysHelper.h.

m_muonsCached

bool xAOD::BPhysHelper::m_muonsCached

protected

cached linked muons

Definition at line 701 of file BPhysHelper.h.

m_precedingVerticesCached

bool xAOD::BPhysHelper::m_precedingVerticesCached

protected

cached linked vertices

Definition at line 713 of file BPhysHelper.h.

m_refTracksCached

bool xAOD::BPhysHelper::m_refTracksCached

protected

cached refitted track momenta

Definition at line 691 of file BPhysHelper.h.

n_pv_types

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

static

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

static

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 605 of file BPhysHelper.h.

s_emptyMatrix

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

staticprotected

Definition at line 728 of file BPhysHelper.h.

s_emptyVectorOfElectrons

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

staticprotected

Definition at line 727 of file BPhysHelper.h.

s_emptyVectorOfMuons

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

staticprotected

Definition at line 726 of file BPhysHelper.h.

s_emptyVectorOfTVector3

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

staticprotected

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

staticprotected

Definition at line 729 of file BPhysHelper.h.

---

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

• BPhysHelper.h
• BPhysHelper.cxx