#include <BPhysVertexTrackBase.h>

Inheritance diagram for DerivationFramework::BPhysVertexTrackBase:

Collaboration diagram for DerivationFramework::BPhysVertexTrackBase:

Classes
class	BaseItem

class	TrackTypeCounter

Public Types
enum	track_type { ASSOCPV, PVTYPE0, PVTYPE1, PVTYPE2, PVTYPE3, NONE, NULLVP, CAPVRFN3U0, CAPVNRN3U0, CAPVRF3DU0, CAPVNR3DU0, CAPVRFN3U1, CAPVNRN3U1, CAPVRF3DU1, CAPVNR3DU1, CAPVRFN3U2, CAPVNRN3U2, CAPVRF3DU2, CAPVNR3DU2, CAPVRFNNU3, CAPVNRNNU3, CAPVRFNNU4, CAPVNRNNU4, CAPVRFNNU5, CAPVNRNNU5, CAPVRFNNU6, CAPVNRNNU6, CAPVRFNNU7, CAPVNRNNU7, CAPVRFNNU8, CAPVNRNNU8, CAPVRFNNU9, CAPVNRNNU9 }

Public Member Functions
	BPhysVertexTrackBase (const std::string &t, const std::string &n, const IInterface *p)

virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

virtual StatusCode	addBranches () const override

Static Public Member Functions
static const std::string	tts (track_type type)

static uint64_t	ttb (track_type type)

static uint64_t	ttall ()

static uint64_t	ttallMin ()

static uint64_t	rttor (const std::vector< uint64_t > &vtypes)

static std::string	wrapLines (const std::string &lines, const std::string &prefix)

static std::string	trackToString (const xAOD::TrackParticle *track)

Static Public Attributes
static const int	n_track_types = 33

static const std::string	track_type_str []

static const uint64_t	track_type_bit []

Protected Types
typedef std::map< std::string, int >	StringIntMap_t

Protected Member Functions
virtual StatusCode	initializeHook ()

virtual StatusCode	finalizeHook ()

virtual StatusCode	addBranchesHook () const

virtual StatusCode	addBranchesVCSetupHook (size_t ivc) const

virtual StatusCode	addBranchesSVLoopHook (const xAOD::Vertex *vtx) const

virtual StatusCode	calcValuesHook (const xAOD::Vertex *vtx, const unsigned int ipv, const unsigned int its, const unsigned int itt) const

virtual bool	fastFillHook (const xAOD::Vertex *vtx, const int ipv) const

StatusCode	calculateValues (const xAOD::Vertex *vtx) const

virtual std::string	buildPvAssocCacheName (const xAOD::Vertex *vtx, const int ipv) const

virtual void	initPvAssocTypeVec ()

TrackBag	findAllTracksInDecay (xAOD::BPhysHelper &vtx) const

void	findAllTracksInDecay (xAOD::BPhysHelper &vtx, TrackBag &tracks) const

MuonBag	findAllMuonsInDecay (xAOD::BPhysHelper &vtx) const

void	findAllMuonsInDecay (xAOD::BPhysHelper &vtx, MuonBag &muons) const

TrackBag	findAllMuonIdTracksInDecay (xAOD::BPhysHelper &vtx, MuonBag &muons) const

std::vector< TVector3 >	findMuonRefTrackMomenta (xAOD::BPhysHelper &vtx, MuonBag &muons) const

TrackBag	selectTracks (const xAOD::TrackParticleContainer *inpTracks, xAOD::BPhysHelper &cand, const unsigned int ipv, const unsigned int its, const unsigned int itt) const

TrackBag	selectTracks (const xAOD::TrackParticleContainer *inpTracks, const TrackBag &exclTracks, xAOD::BPhysHelper &cand, const unsigned int ipv, const unsigned int its, const unsigned int itt) const

uint64_t	detTrackTypes (const xAOD::TrackParticle track, const xAOD::Vertex candPV, const xAOD::Vertex *candRefPV) const

double	getTrackCandPVLogChi2 (const xAOD::TrackParticle track, const xAOD::Vertex vtx, bool doDCAin3D=false, int chi2DefToUse=0) const

std::vector< double >	getTrackLogChi2DCA (const xAOD::TrackParticle track, const xAOD::Vertex vtx, bool doDCAin3D=false, int chi2DefToUse=0) const

std::string	buildBranchBaseName (unsigned int its, unsigned int ipv, unsigned int itt, const std::string &preSuffix="") const

std::pair< const xAOD::Vertex *, double >	findMinChi2PV (const xAOD::TrackParticle track, const xAOD::Vertex candPV, const xAOD::Vertex *candRefPV, const std::vector< uint64_t > &pvtypes, const int minNTracksInPV, const bool useRefittedPvs, const bool doDCAin3D, const int chi2DefToUse) const

const xAOD::Vertex *	findAssocPV (const xAOD::TrackParticle track, const xAOD::Vertex candPV, const xAOD::Vertex *candRefPV, const std::vector< uint64_t > &pvtypes, const int minNTracksInPV, const bool useRefittedPvs) const

Protected Attributes
std::vector< std::string >	m_branchPrefixes

std::string	m_branchBaseName

std::string	m_branchSuffix

std::vector< std::string >	m_vertexContainerNames

std::string	m_trackParticleContainerName

ToolHandleArray< TrkSelTool >	m_trackSelectionTools

ToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool

ToolHandle< CP::ITrackVertexAssociationTool >	m_tvaTool

std::string	m_pvContainerName

std::vector< std::string >	m_refPVContainerNames

int	m_doVertexType {}

std::vector< uint64_t >	m_useTrackTypes

bool	m_incPrecVerticesInDecay {}

int	m_minNTracksInPV {}

std::vector< uint64_t >	m_pvTypesToConsider

int	m_debugTrackTypes {}

std::vector< uint64_t >	m_debugTracksInEvents

bool	m_tvaToolHasWpLoose {}

const xAOD::TrackParticleContainer *	m_tracks {}

const xAOD::TrackParticleAuxContainer *	m_tracksAux {}

const xAOD::VertexContainer *	m_pvtxContainer {}

const xAOD::VertexContainer *	m_svtxContainer {}

const xAOD::VertexAuxContainer *	m_svtxAuxContainer {}

const xAOD::VertexContainer *	m_refPVContainer {}

const xAOD::VertexAuxContainer *	m_refPVAuxContainer {}

std::vector< xAOD::BPhysHelper::pv_type >	m_pvAssocTypes

unsigned int	m_nEvtsSeen {}

const xAOD::EventInfo *	m_eventInfo {}

StringIntMap_t	m_pvAssocResMap

uint64_t	m_trackTypesUsed {}

std::unique_ptr< TrackTypeCounter >	m_mttc

unsigned int	m_runNumber {}

uint64_t	m_evtNumber {}

bool	m_debugTracksInThisEvent {}

Static Private Attributes
static uint64_t	s_track_type_all_cached = 0x0

Detailed Description

Definition at line 56 of file BPhysVertexTrackBase.h.

Member Typedef Documentation

◆ StringIntMap_t

typedef std::map<std::string, int> DerivationFramework::BPhysVertexTrackBase::StringIntMap_t

protected

Definition at line 288 of file BPhysVertexTrackBase.h.

Member Enumeration Documentation

◆ track_type

enum DerivationFramework::BPhysVertexTrackBase::track_type

Enumerator
ASSOCPV
PVTYPE0
PVTYPE1
PVTYPE2
PVTYPE3
NONE
NULLVP
CAPVRFN3U0
CAPVNRN3U0
CAPVRF3DU0
CAPVNR3DU0
CAPVRFN3U1
CAPVNRN3U1
CAPVRF3DU1
CAPVNR3DU1
CAPVRFN3U2
CAPVNRN3U2
CAPVRF3DU2
CAPVNR3DU2
CAPVRFNNU3
CAPVNRNNU3
CAPVRFNNU4
CAPVNRNNU4
CAPVRFNNU5
CAPVNRNNU5
CAPVRFNNU6
CAPVNRNNU6
CAPVRFNNU7
CAPVNRNNU7
CAPVRFNNU8
CAPVNRNNU8
CAPVRFNNU9
CAPVNRNNU9

Definition at line 114 of file BPhysVertexTrackBase.h.

                       {ASSOCPV, PVTYPE0, PVTYPE1, PVTYPE2, PVTYPE3, NONE,
                        NULLVP,
                        CAPVRFN3U0, CAPVNRN3U0, CAPVRF3DU0, CAPVNR3DU0,
                        CAPVRFN3U1, CAPVNRN3U1, CAPVRF3DU1, CAPVNR3DU1,
                        CAPVRFN3U2, CAPVNRN3U2, CAPVRF3DU2, CAPVNR3DU2,
                        CAPVRFNNU3, CAPVNRNNU3, CAPVRFNNU4, CAPVNRNNU4,
                        CAPVRFNNU5, CAPVNRNNU5, CAPVRFNNU6, CAPVNRNNU6,
                        CAPVRFNNU7, CAPVNRNNU7, CAPVRFNNU8, CAPVNRNNU8,
                        CAPVRFNNU9, CAPVNRNNU9 };

Constructor & Destructor Documentation

◆ BPhysVertexTrackBase()

DerivationFramework::BPhysVertexTrackBase::BPhysVertexTrackBase	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 367 of file BPhysVertexTrackBase.cxx.

     : base_class(t,n,p), m_trackToVertexTool("Reco::TrackToVertex"),
       m_tvaTool("CP::TrackVertexAssociationTool"),
       m_tvaToolHasWpLoose(false),
       m_tracks(NULL), m_tracksAux(NULL), m_nEvtsSeen(0), m_eventInfo(nullptr),
       m_trackTypesUsed(0), m_runNumber(0), m_evtNumber(0),
       m_debugTracksInThisEvent(false) {
     
  
     // Declare branch prefix
     declareProperty("BranchPrefixes", m_branchPrefixes);
     declareProperty("BranchBaseName", m_branchBaseName = "iso");
     declareProperty("BranchSuffix"  , m_branchSuffix = ""     );
  
     // Necessary containers
     declareProperty("VertexContainerNames"  , m_vertexContainerNames);
     declareProperty("TrackParticleContainerName",
             m_trackParticleContainerName);
     declareProperty("TrackToVertexTool"     , m_trackToVertexTool);
     declareProperty("TrackSelectionTools"   , m_trackSelectionTools);
     declareProperty("TVATool"               , m_tvaTool);
     declareProperty("PVContainerName", m_pvContainerName = "PrimaryVertices");
     declareProperty("RefPVContainerNames"   , m_refPVContainerNames);
     declareProperty("DoVertexType"          , m_doVertexType = 8);
     declareProperty("UseTrackTypes"         , m_useTrackTypes = {7});
     declareProperty("IncPrecVerticesInDecay", m_incPrecVerticesInDecay = true);
     declareProperty("MinNTracksInPV"        , m_minNTracksInPV = 0);
     declareProperty("PVTypesToConsider"     , m_pvTypesToConsider = {1,3});
     declareProperty("DebugTrackTypes"       , m_debugTrackTypes=0);
     declareProperty("DebugTracksInEvents"   , m_debugTracksInEvents = {});
   }

Member Function Documentation

◆ addBranches()

StatusCode DerivationFramework::BPhysVertexTrackBase::addBranches ( ) const

overridevirtual

Definition at line 476 of file BPhysVertexTrackBase.cxx.

                                                      {
  
     ATH_MSG_DEBUG("BPhysVertexTrackBase::addBranches() -- begin");
  
     // counter
     m_nEvtsSeen++;
  
     // run and event numbers
     CHECK(evtStore()->retrieve(m_eventInfo));
     m_runNumber = m_eventInfo->runNumber();
     m_evtNumber = m_eventInfo->eventNumber();
  
     // debug tracks in current event?
     m_debugTracksInThisEvent = (std::find(m_debugTracksInEvents.begin(),
                                           m_debugTracksInEvents.end(),
                                           m_evtNumber)
                                 != m_debugTracksInEvents.end());
     
     // retrieve primary vertices container
     m_pvtxContainer = NULL;
     CHECK(evtStore()->retrieve(m_pvtxContainer, m_pvContainerName));
     ATH_MSG_DEBUG("Found PV collection with key " << m_pvContainerName);
  
  
     // retrieve ID track container
     m_tracks    = NULL;
     m_tracksAux = NULL;
     CHECK(evtStore()->retrieve(m_tracks, m_trackParticleContainerName));
     if (evtStore()->contains<xAOD::
     TrackParticleAuxContainer>(m_trackParticleContainerName+"Aux.")) {
       CHECK(evtStore()->retrieve(m_tracksAux,
                  m_trackParticleContainerName+"Aux."));
     } else {
       ATH_MSG_DEBUG("No aux track collection with key "
             << m_trackParticleContainerName+"Aux.");
     }
     ATH_MSG_DEBUG("Found track collection with key "
           << m_trackParticleContainerName);
     
     // Loop over all vertex containers
     for (size_t i=0; i<m_vertexContainerNames.size(); ++i) {
     // vertex container and its auxilliary store
       const xAOD::VertexContainer*     svtxContainer    = NULL;
       const xAOD::VertexAuxContainer*  svtxAuxContainer = NULL;
       // refitted primary vertex container and its auxilliary store
       const xAOD::VertexContainer*     refPVContainer    = NULL;
       const xAOD::VertexAuxContainer*  refPVAuxContainer = NULL;
  
       // retrieve from StoreGate
       CHECK(evtStore()->retrieve(svtxContainer, m_vertexContainerNames[i]));
       CHECK(evtStore()->retrieve(svtxAuxContainer,
                  m_vertexContainerNames[i]+"Aux."));
       ATH_MSG_DEBUG("Found SV collection with key "
             << m_vertexContainerNames[i]);
       CHECK(evtStore()->retrieve(refPVContainer   ,
                  m_refPVContainerNames[i]));
       CHECK(evtStore()->retrieve(refPVAuxContainer,
                  m_refPVContainerNames[i]+"Aux."));
       ATH_MSG_DEBUG("Found refitted PV collection with key "
             << m_refPVContainerNames[i]);
       
       // vertex container depending setup in derived class
       CHECK(addBranchesVCSetupHook(i));
       
       // loop over secondary vertices
       for (xAOD::VertexContainer::const_iterator vtxItr =
          svtxContainer->begin(); vtxItr!=svtxContainer->end();
        ++vtxItr) {
  
     CHECK(addBranchesSVLoopHook(*vtxItr));
     
       } // end of loop over vertices
     } // end of loop over vertex container names
     
     ATH_MSG_DEBUG("BPhysVertexTrackBase::addBranches() -- end");
  
     // nothing to do here
     return addBranchesHook();
   }

◆ addBranchesHook()

StatusCode DerivationFramework::BPhysVertexTrackBase::addBranchesHook ( ) const

protectedvirtual

Definition at line 573 of file BPhysVertexTrackBase.cxx.

                                                          {
  
     return StatusCode::SUCCESS;
   }  

◆ addBranchesSVLoopHook()

StatusCode DerivationFramework::BPhysVertexTrackBase::addBranchesSVLoopHook ( const xAOD::Vertex * vtx ) const

protectedvirtual

Definition at line 594 of file BPhysVertexTrackBase.cxx.

                                                                          {
  
     // just to avoid a compiler warning
     ATH_MSG_DEBUG("addBranchesSVLoopHook: Vertex " << vtx);
     
     return StatusCode::SUCCESS;
   }  

◆ addBranchesVCSetupHook()

StatusCode DerivationFramework::BPhysVertexTrackBase::addBranchesVCSetupHook ( size_t ivc ) const

protectedvirtual

Definition at line 581 of file BPhysVertexTrackBase.cxx.

                                                                           {
  
     // just to avoid a compiler warning
     ATH_MSG_DEBUG("addBranchesVCSetupHook: Vertex container index " << ivc
           << " for collection " << m_vertexContainerNames[ivc]
           << " with prefix " << m_branchPrefixes[ivc]);
     
     return StatusCode::SUCCESS;
   }  

◆ buildBranchBaseName()

std::string DerivationFramework::BPhysVertexTrackBase::buildBranchBaseName	(	unsigned int	its,
		unsigned int	ipv,
		unsigned int	itt,
		const std::string &	preSuffix = `""`
	)		const

protected

Definition at line 1310 of file BPhysVertexTrackBase.cxx.

           {
     
     ATH_MSG_DEBUG("BPhysVertexTrackBase::buildBranchBaseName -- begin");
     
     std::string tsName   = m_trackSelectionTools[its].name();
     std::string pvAssoc  = xAOD::BPhysHelper::pv_type_str[m_pvAssocTypes[ipv]];
  
     // need to get part of tsname after last underscore
     std::size_t ipos = tsName.find_last_of("_");
     if ( ipos != std::string::npos ) tsName = tsName.substr(ipos+1);
  
     // format it nicely
     std::string f = std::format("T{:010d}_{}_{}{}{}",
     m_useTrackTypes[itt], tsName, pvAssoc,
     (preSuffix.length() > 0 ? "_" + preSuffix : ""),
     (m_branchSuffix.length() > 0 ? "_" + m_branchSuffix : ""));
  
     ATH_MSG_DEBUG("BPhysVertexBaseTrackBase::buildBranchBaseName: " << f);
     return f;
   }

◆ buildPvAssocCacheName()

std::string DerivationFramework::BPhysVertexTrackBase::buildPvAssocCacheName	(	const xAOD::Vertex *	vtx,
		const int	ipv
	)		const

protectedvirtual

Definition at line 671 of file BPhysVertexTrackBase.cxx.

                                                {
     xAOD::BPhysHelper cand(vtx);
     std::string f = std::format("SV_{:p}_RPV_{:p}", static_cast<const void*>(cand.vtx()), static_cast<const void*>(cand.pv(m_pvAssocTypes[ipv])));
     
     return f;
   }

◆ calculateValues()

StatusCode DerivationFramework::BPhysVertexTrackBase::calculateValues ( const xAOD::Vertex * vtx ) const

protected

Definition at line 637 of file BPhysVertexTrackBase.cxx.

                                                                    {
  
     ATH_MSG_DEBUG("BPhysVertexTrackBase::calculateValues -- begin");
     
     unsigned int nPvAssocs   = m_pvAssocTypes.size();
     unsigned int nTrackSels  = m_trackSelectionTools.size();
     unsigned int nTrackTypes = m_useTrackTypes.size();
  
     m_pvAssocResMap.clear();
  
     const xAOD::BPhysHelper cand(vtx);
     for (unsigned int ipv = 0; ipv < nPvAssocs; ++ipv) {
       if ( ipv == 0 || ! fastFillHook(vtx, ipv) ) { 
     for (unsigned int its = 0; its < nTrackSels; ++its) {
       for (unsigned int itt = 0; itt < nTrackTypes; ++itt) {
         ATH_MSG_DEBUG("Calling calcValuesHook with ipv: " << ipv
               << ", its: " << its << ", itt: " << itt);
         CHECK(calcValuesHook(vtx, ipv, its, itt));
       } // for itt
     } // for its
     // cache result index -- only needed once per ipv value
     m_pvAssocResMap[buildPvAssocCacheName(vtx, ipv)] = ipv;
     ATH_MSG_DEBUG("calculateValues: cache index: "
               << buildPvAssocCacheName(vtx, ipv)
               << " -- cached ipv: " << ipv);
       } // if !fastFillHook()
     } // for ipv
       
     return StatusCode::SUCCESS;
   }

◆ calcValuesHook()

StatusCode DerivationFramework::BPhysVertexTrackBase::calcValuesHook	(	const xAOD::Vertex *	vtx,
		const unsigned int	ipv,
		const unsigned int	its,
		const unsigned int	itt
	)		const

protectedvirtual

Definition at line 606 of file BPhysVertexTrackBase.cxx.

                                                      {
  
     // just to avoid a compiler warning
     ATH_MSG_DEBUG("calcIsolationOpti:  vtx: " << vtx << ", ipv: " << ipv
           << ", its: " << its << ", itt: " << itt);
  
     return StatusCode::SUCCESS;
   }

◆ detTrackTypes()

uint64_t DerivationFramework::BPhysVertexTrackBase::detTrackTypes	(	const xAOD::TrackParticle *	track,
		const xAOD::Vertex *	candPV,
		const xAOD::Vertex *	candRefPV
	)		const

protected

Definition at line 1000 of file BPhysVertexTrackBase.cxx.

                                                                                   {
     int bits = 0x0;
  
     // PVTYPE0 - PVTYPE3, NONE
     ATH_MSG_ERROR("BPhysVertexTrackBase::detTrackTypes must be adjusted due to changes in TrackParticle");
  
     // ASOCPV
     if ( candPV != NULL ) {
       bool found(false);
       for (size_t i=0; i<candPV->nTrackParticles(); ++i) {
         if ( track == candPV->trackParticle(i) ) {
           found = true;
           break;
         }
       }
       if ( found ) bits |= track_type_bit[ASSOCPV];
       //
       // CLOSEAPV
       for (unsigned int i=7; i<n_track_types; ++i) {
         if ( (track_type_bit[i] & m_trackTypesUsed) > 0x0 ) {
           bool useRefittedPvs = ( i%2 == 1 );
           bool doDCAin3D      = ( (i-7)%4 > 1 );
           int  chi2DefToUse   = (i-7)/4;
           // adjustment above bit 20
           if ( i > 20 ) {
             doDCAin3D    = true;
             chi2DefToUse = (i-13)/2;
           }
           const xAOD::Vertex* minChi2PV(nullptr);
           if ( chi2DefToUse == 5 ) {
             minChi2PV =
               findAssocPV(track, candPV, candRefPV, m_pvTypesToConsider,
                           m_minNTracksInPV, useRefittedPvs);
           } else {
             minChi2PV =
               findMinChi2PV(track, candPV, candRefPV, m_pvTypesToConsider,
                             m_minNTracksInPV, useRefittedPvs,
                             doDCAin3D, chi2DefToUse).first;
           } // if chi2DefToUse
           if ( candPV == minChi2PV
                || (candRefPV != nullptr && candRefPV == minChi2PV) ) {
             bits |= track_type_bit[i];
           }
         } // if m_trackTypesUsed
       } // for i
  
     } // if candPV != NULL
  
     return bits;
   }

◆ fastFillHook()

bool DerivationFramework::BPhysVertexTrackBase::fastFillHook	(	const xAOD::Vertex *	vtx,
		const int	ipv
	)		const

protectedvirtual

Definition at line 621 of file BPhysVertexTrackBase.cxx.

                                            {
  
     // just to avoid a compiler warning
     ATH_MSG_DEBUG("fastIsoFill:  vtx: " << vtx << ", ipv: " << ipv);
     
     return false;
   }

◆ finalize()

StatusCode DerivationFramework::BPhysVertexTrackBase::finalize ( )

overridevirtual

Definition at line 463 of file BPhysVertexTrackBase.cxx.

                                             {
  
     ATH_MSG_DEBUG("BPhysVertexTrackBase::finalize()");
  
     // dump track type counters to log
     if ( m_debugTrackTypes > 0 ) {
       ATH_MSG_INFO("Track type counters:\n" << m_mttc->countsToString());
     }
     
     // everything all right
     return finalizeHook();
   }

◆ finalizeHook()

StatusCode DerivationFramework::BPhysVertexTrackBase::finalizeHook ( )

protectedvirtual

Definition at line 566 of file BPhysVertexTrackBase.cxx.

                                                 {
  
     return StatusCode::SUCCESS;
   }  

◆ findAllMuonIdTracksInDecay()

TrackBag DerivationFramework::BPhysVertexTrackBase::findAllMuonIdTracksInDecay	(	xAOD::BPhysHelper &	vtx,
		MuonBag &	muons
	)		const

protected

Definition at line 1130 of file BPhysVertexTrackBase.cxx.

                                                  {
  
     TrackBag tracks;
     muons = findAllMuonsInDecay(vtx);
  
     for (MuonBag::const_iterator muItr = muons.begin(); muItr != muons.end();
      ++muItr) {
       const xAOD::TrackParticle* track =
     (*muItr)->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
       tracks.push_back(track);
     } // for 
     
     return tracks;
   }

◆ findAllMuonsInDecay() [1/2]

MuonBag DerivationFramework::BPhysVertexTrackBase::findAllMuonsInDecay ( xAOD::BPhysHelper & vtx ) const

protected

Definition at line 1092 of file BPhysVertexTrackBase.cxx.

           {
  
     MuonBag muons;
     findAllMuonsInDecay(vtx, muons);
       
     return muons;
   }

◆ findAllMuonsInDecay() [2/2]

void DerivationFramework::BPhysVertexTrackBase::findAllMuonsInDecay	(	xAOD::BPhysHelper &	vtx,
		MuonBag &	muons
	)		const

protected

Definition at line 1106 of file BPhysVertexTrackBase.cxx.

           {
  
     for (int i=0; i < vtx.nMuons(); ++i) {
       if ( std::find(muons.begin(),muons.end(),vtx.muon(i)) == muons.end() ) {
     muons.push_back(vtx.muon(i));
       } // if
     } // for
     // loop over preceeding vertices
     if ( m_incPrecVerticesInDecay ) {
       for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
     xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
     findAllMuonsInDecay(precVtx, muons);
       } // for
     } // if
   }

◆ findAllTracksInDecay() [1/2]

TrackBag DerivationFramework::BPhysVertexTrackBase::findAllTracksInDecay ( xAOD::BPhysHelper & vtx ) const

protected

Definition at line 1056 of file BPhysVertexTrackBase.cxx.

           {
  
     TrackBag tracks;
     findAllTracksInDecay(vtx, tracks);
  
     return tracks;
   }

◆ findAllTracksInDecay() [2/2]

void DerivationFramework::BPhysVertexTrackBase::findAllTracksInDecay	(	xAOD::BPhysHelper &	vtx,
		TrackBag &	tracks
	)		const

protected

Definition at line 1070 of file BPhysVertexTrackBase.cxx.

           {
  
     for (unsigned int i=0; i < vtx.vtx()->nTrackParticles(); ++i) {
       const xAOD::TrackParticle* track = vtx.vtx()->trackParticle(i);
       if ( std::find(tracks.begin(),tracks.end(),track) == tracks.end() ) {
     tracks.push_back(track);
       } // if
     } // for
     // loop over preceeding vertices
     if ( m_incPrecVerticesInDecay ) {
       for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
     xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
     findAllTracksInDecay(precVtx, tracks);
       } // if
     } // for 
   }

◆ findAssocPV()

const xAOD::Vertex * DerivationFramework::BPhysVertexTrackBase::findAssocPV	(	const xAOD::TrackParticle *	track,
		const xAOD::Vertex *	candPV,
		const xAOD::Vertex *	candRefPV,
		const std::vector< uint64_t > &	pvtypes,
		const int	minNTracksInPV,
		const bool	useRefittedPvs
	)		const

protected

Definition at line 1410 of file BPhysVertexTrackBase.cxx.

                                                                      {
  
     // select PVs to be considered/replace candPV by candRefPV if requested
     std::vector<const xAOD::Vertex*> vpvtx;
     for (auto pvtx: *m_pvtxContainer) {
       if ( pvtx != nullptr ) {
         if ( std::find(pvtypes.begin(),pvtypes.end(),pvtx->vertexType())
              != pvtypes.end() ) {
           const xAOD::Vertex* cvtx = pvtx;
           // replace by refitted PV if associated PV matches orignal PV
           if ( useRefittedPvs && pvtx == candPV ) {
             if ( candRefPV != nullptr ) {
               cvtx = candRefPV;
             } else {
               ATH_MSG_WARNING("BPhysVertexTrackBase::findAssocPV:"
                               << " candRefPV == NULL!");
               continue;
             }
           } // if pvtx == candPV
           if ( (int)cvtx->nTrackParticles() >= minNTracksInPV ) {
             vpvtx.push_back(cvtx);
           } // if minNTracksInPV
         } // if pvTypes in pvtypes vector
       } // if pvtx != nullptr
     } // for pvtx
  
     const xAOD::Vertex* assocPV(NULL);
     if ( useRefittedPvs && m_tvaToolHasWpLoose ) {
       // check whether track is in refitted PV - if so accept
       // Need to do this here as the TrackVertexAssociationTool
       // with WP 'Loose' only checks the track->vertex() pointer
       // which always points to the original PV.
       for (const auto &tp : candRefPV->trackParticleLinks()) {
         if ( *tp == track ) {
           // track is part of refitted PV -- accept it
           assocPV = candRefPV;
           break;
         }
       } // for tp
       // if not matching use the TrackVertexAssociationTool (other PVs etc)
       if ( assocPV == nullptr ) {
         assocPV = m_tvaTool->getUniqueMatchVertex(*track, vpvtx);
       }
     } else {
       assocPV = m_tvaTool->getUniqueMatchVertex(*track, vpvtx);
     } // if useRefittedPvs && m_tvaToolHasWpLoose
     if ( assocPV == nullptr ) {
       ATH_MSG_WARNING("BPhysVertexTrackBase::findAssocPV:"
                       << " assocPV == NULL for track!"
                       << " len(vpvtx) = " << vpvtx.size()
                       << " useRefittedPvs = " << useRefittedPvs
                       << " minNTracksInPV = " << minNTracksInPV);
     }
     
     return assocPV;
   }  

◆ findMinChi2PV()

std::pair< const xAOD::Vertex *, double > DerivationFramework::BPhysVertexTrackBase::findMinChi2PV	(	const xAOD::TrackParticle *	track,
		const xAOD::Vertex *	candPV,
		const xAOD::Vertex *	candRefPV,
		const std::vector< uint64_t > &	pvtypes,
		const int	minNTracksInPV,
		const bool	useRefittedPvs,
		const bool	doDCAin3D,
		const int	chi2DefToUse
	)		const

protected

Definition at line 1358 of file BPhysVertexTrackBase.cxx.

                                                                     {
  
     double minChi2 = std::numeric_limits<double>::max();
     const xAOD::Vertex* minChi2PV(nullptr);
     
     for (auto pvtx: *m_pvtxContainer) {
       if ( pvtx != nullptr ) {
         if ( std::find(pvtypes.begin(),pvtypes.end(),pvtx->vertexType())
              != pvtypes.end() ) {
           const xAOD::Vertex* cvtx = pvtx;
           // replace by refitted PV if associated PV matches orignal PV
           if ( useRefittedPvs && pvtx == candPV ) {
             if ( candRefPV != nullptr ) {
               cvtx = candRefPV;
             } else {
               ATH_MSG_WARNING(" BPhysVertexTrackBase::findMinChi2PV:"
                               << " candRefPV == NULL!");
               continue;
             }
           } // if pvtx == candPV
           if ( (int)cvtx->nTrackParticles() >= minNTracksInPV ) {
             double chi2 = getTrackLogChi2DCA(track, cvtx, doDCAin3D,
                                              chi2DefToUse)[4];
             if ( chi2 < minChi2 ) {
               minChi2   = chi2;
               minChi2PV = cvtx;
             } // if chi2 < minChi2
           } // if minNTracksInPV
         } // if pvTypes in pvtypes vector
       } // if pvtx != nullptr
     } // for pvtx
  
     return std::make_pair(minChi2PV, minChi2);
   }  

◆ findMuonRefTrackMomenta()

std::vector< TVector3 > DerivationFramework::BPhysVertexTrackBase::findMuonRefTrackMomenta	(	xAOD::BPhysHelper &	vtx,
		MuonBag &	muons
	)		const

protected

Definition at line 1151 of file BPhysVertexTrackBase.cxx.

                                               {
  
     std::vector<TVector3> refMuTracks;
  
     // quick solution if nRefTrks == nMuons:
     if ( vtx.nRefTrks() == vtx.nMuons() && !m_incPrecVerticesInDecay ) {
       muons = vtx.muons();
       for ( auto refMuTrack : vtx.refTrks() ) {
     refMuTracks.push_back(refMuTrack);
       }
     } else {
       TrackBag muonIdTracks = findAllMuonIdTracksInDecay(vtx, muons);
       if ( vtx.nRefTrks() == (int)vtx.vtx()->nTrackParticles() ) {
     for (int i=0; i<vtx.nRefTrks(); ++i) {
       const xAOD::TrackParticle* otp =
         (const xAOD::TrackParticle*)vtx.refTrkOrigin(i);
       if ( otp != NULL ) {
         if ( std::find(muonIdTracks.begin(), muonIdTracks.end(), otp)
          != muonIdTracks.end() ) {
           refMuTracks.push_back(vtx.refTrk(i));
         }
       } else {
         ATH_MSG_WARNING("BPhysVertexTrackBase::findMuonRefTrackMomenta():"
                 " refTrkOrigin == NULL for refTrk # "
                 << i << " !");
       }
     } // for
       } else {
     ATH_MSG_WARNING("BPhysVertexTrackBase::findMuonRefTrackMomenta():"
             " size mismatch #refTrks = " << vtx.nRefTrks()
             << "#trackParticles = " << vtx.vtx()->nTrackParticles()
             << " !");
       } // if nRefTracks == nTrackParticles
       // loop over preceeding vertices -- only if not all refMuTrks found yet
       if ( m_incPrecVerticesInDecay && muons.size() > refMuTracks.size() ) {
     for (int ivtx = 0; ivtx < vtx.nPrecedingVertices(); ++ivtx) {
       xAOD::BPhysHelper precVtx(vtx.precedingVertex(ivtx));
       std::vector<TVector3> precRefMuTracks =
         findMuonRefTrackMomenta(precVtx, muons);
       // append only if not yet contained in
       for ( auto precRefMuTrack : precRefMuTracks ) {
         if ( std::find(refMuTracks.begin(), refMuTracks.end(),
                precRefMuTrack) == refMuTracks.end() ) {
           refMuTracks.push_back(precRefMuTrack);
         } // if
       } // for 
     } // for ivtx
       } // if
     } // if (shortcut)
  
     // debug output
     if ( msgLvl( MSG::DEBUG ) ) { 
     ATH_MSG_DEBUG("BPhysVertexTrackBase::findMuonRefTrackMomenta():"
               << " #muons: " << muons.size()
               << "  #refMuTrks: " << refMuTracks.size());
     TString str = Form(">> refMuTracks(%d):\n", (int)refMuTracks.size());
     for (unsigned int i=0; i < refMuTracks.size(); ++i) {
       str += Form("(%10.4f,%10.4f,%10.4f) ",
               refMuTracks[i].x(), refMuTracks[i].y(),
               refMuTracks[i].z());
     }
     ATH_MSG_DEBUG(str.Data());
       }
     
     return refMuTracks;
   }

◆ getTrackCandPVLogChi2()

double DerivationFramework::BPhysVertexTrackBase::getTrackCandPVLogChi2	(	const xAOD::TrackParticle *	track,
		const xAOD::Vertex *	vtx,
		bool	doDCAin3D = `false`,
		int	chi2DefToUse = `0`
	)		const

protected

Definition at line 683 of file BPhysVertexTrackBase.cxx.

                                                              {
  
     return getTrackLogChi2DCA(track, vtx, doDCAin3D, chi2DefToUse)[4];
   }

◆ getTrackLogChi2DCA()

std::vector< double > DerivationFramework::BPhysVertexTrackBase::getTrackLogChi2DCA	(	const xAOD::TrackParticle *	track,
		const xAOD::Vertex *	vtx,
		bool	doDCAin3D = `false`,
		int	chi2DefToUse = `0`
	)		const

protected

Definition at line 721 of file BPhysVertexTrackBase.cxx.

                                                                     {
     // presets
     std::vector<double> res = {-999., -99., -999., -99., -100., -100., -1.,
                                -99., -99., -999.};
     
     const Amg::Vector3D   pos = vtx->position();
     const AmgSymMatrix(3) poscov = vtx->covariancePosition();
     auto ctx = Gaudi::Hive::currentContext();
     if ( track != NULL ) {
       if ( chi2DefToUse < 2 || (chi2DefToUse > 5 && chi2DefToUse < 8) ) {
         // use track perigee method
         std::unique_ptr<const Trk::Perigee>
           trkPerigee(m_trackToVertexTool->perigeeAtVertex(ctx, *track, pos));
         if ( trkPerigee != NULL  ) {
           res[0] = trkPerigee->parameters()[Trk::d0];
           res[2] = trkPerigee->parameters()[Trk::z0];
           const AmgSymMatrix(5)* locError = trkPerigee->covariance();
           if ( locError != NULL ) {
             // uncertainties from track
             res[1] = Amg::error(*locError, Trk::d0);
             res[3] = Amg::error(*locError, Trk::z0);
             if ( chi2DefToUse == 1 ) {
               // add uncertainties from vertex
               Amg::Vector3D perppt(trkPerigee->momentum().y()/trkPerigee->pT(),
                                    -trkPerigee->momentum().x()/trkPerigee->pT(),
                                    0.);
               double vtxD0Err2 = perppt.transpose()*poscov*perppt;
               res[1] = sqrt( pow(res[1], 2.) + vtxD0Err2 );
               res[3] = sqrt( pow(res[3], 2.) + poscov(2,2) );
             }
             if ( chi2DefToUse < 2 ) {
               if ( fabs(res[1]) > 0. && fabs(res[3]) > 0. ) {
                 res[4] = log( pow(res[0]/res[1], 2.)
                               + pow(res[2]/res[3], 2.) );
                 res[6] = 2.; // ok
               } else {
                 ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
                                 << " d0 = " << res[0] << ", d0Err = "
                                 << res[1] << ", z0 = " << res[2]
                                 << ", z0Err = " << res[3]);
               }
             }
             // chi2DefToUse 6 or 7
             if ( chi2DefToUse > 5 && chi2DefToUse < 8 ) {
               double phi0 = trkPerigee->parameters()[Trk::phi0];
               double doca = sqrt(pow(res[0],2.) + pow(res[2], 2.));
               res[9] = phi0;
               if ( doca > 0. ) {
                 if ( chi2DefToUse == 6 ) {
                   AmgMatrix(5,3) dmat = AmgMatrix(5,3)::Zero();
                   dmat(0,0) = -sin(phi0);
                   dmat(0,1) =  cos(phi0);
                   dmat(1,2) =  1.;
                   dmat(2,0) = -res[0]*cos(phi0);
                   dmat(2,1) = -res[0]*sin(phi0);
                   AmgSymMatrix(3) mCovTrk3D = dmat.transpose()*(*locError)*dmat;
                   Amg::Vector3D dvec(-res[0]*sin(phi0), res[0]*cos(phi0),
                                      res[2]); // (x,y,z)
                   Amg::Vector3D duvec = dvec.unit();
                   // log(chi2) = log( docavec^T * V^-1 * docavec )
                   res[4] = log( dvec.transpose() * (poscov+mCovTrk3D).inverse()
                                 * dvec );
                   res[7] = duvec.transpose()*poscov*duvec;
                   res[8] = duvec.transpose()*mCovTrk3D*duvec;
                   res[6] = 3.; // ok
                 }
                 if ( chi2DefToUse == 7 ) {
                   AmgMatrix(3,2) dmat = AmgMatrix(3,2)::Zero();
                   dmat(0,0) = -sin(phi0);
                   dmat(1,0) =  cos(phi0);
                   dmat(2,0) =  0.;
                   dmat(0,1) =  0.;
                   dmat(1,1) =  0.;
                   dmat(2,1) =  1.;
                   AmgSymMatrix(2) mCovVtx2D = dmat.transpose()*poscov*dmat;
                   AmgSymMatrix(2) mCovTrk2D = AmgSymMatrix(2)::Zero();
                   mCovTrk2D(0,0) = (*locError)(Trk::d0,Trk::d0);
                   mCovTrk2D(0,1) = (*locError)(Trk::d0,Trk::z0);
                   mCovTrk2D(1,0) = (*locError)(Trk::d0,Trk::z0);
                   mCovTrk2D(1,1) = (*locError)(Trk::z0,Trk::z0);
                   Amg::Vector2D dvec(res[0], res[2]); // (d0, z0)
                   Amg::Vector2D duvec = dvec.unit();
                   // log(chi2) = log( (d0, z0) * V^-1 * (d0, z0)^T )
                   res[4] = log( dvec.transpose()*(mCovVtx2D+mCovTrk2D).inverse()
                                 * dvec );
                   res[7] = duvec.transpose()*mCovVtx2D*duvec;
                   res[8] = duvec.transpose()*mCovTrk2D*duvec;
                   res[6] = 4.; // ok
                 }
               } else {
                 ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
                                 << " doca == 0 !");
               }
             } // if chi2DefToUse > 5 && chi2DefToUse < 8
             res[5] = doDCAin3D ?
               sqrt( pow(res[0], 2.) + pow(res[2], 2.) ) : res[0];
             res[6] += 1.; // ok
           } else {
             ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
                             " locError pointer is NULL!");
           }
         } else {
           ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
                           " trkPerigee pointer is NULL!");
         } // if trkPerigee
  
       } else if ( chi2DefToUse == 2
                   || (chi2DefToUse > 7 && chi2DefToUse < 10 )) {
         // simple extrapolation method
         // (directly taken from NtupleMaker for comparisons)
  
         // SV position and covariance matrix
         TVector3 SV_def(vtx->x(), vtx->y(), vtx->z());
         const AmgSymMatrix(3)& SV_cov = poscov;
         
         // chi2 track to SV
         double px      = ( track->p4() ).Px();
         double py      = ( track->p4() ).Py();
         double pt      = ( track->p4() ).Pt();
         double d0      = track->d0();
         double d0Err2  = track->definingParametersCovMatrixVec()[0];
         double z0      = track->z0();
         double z0Err2  = track->definingParametersCovMatrixVec()[2];
         double theta   = track->theta();
         double d0z0Cov = track->definingParametersCovMatrixVec()[1];
         double phi     = track->phi();
  
         TVector3 trk_origin(  track->vx(),  track->vy(),  track->vz() );
         TVector3 SV = SV_def - trk_origin;
         
         // calc. error in direction perpendicular to pT (still x-y plane)
         double upx        = py/pt;
         double upy        = -px/pt;
         double d0toSV     = d0 + (SV[0]*upx + SV[1]*upy);
         double d0toSVErr2 = upx*SV_cov(0, 0)*upx + 2*upx*SV_cov(1, 0)*upy
           + upy*SV_cov(1, 1)*upy + d0Err2;
  
         upx = px/pt;
         upy = py/pt;
         double cot_theta  = cos(theta)/sin(theta);
         double z0corr     = (SV[0]*upx + SV[1]*upy)*cot_theta;
         double z0toSV     = z0 + z0corr - SV[2];
         double z0toSVErr2 = SV_cov(2, 2) + z0Err2;
  
         double docaSV     = sqrt( pow(d0toSV, 2) + pow(z0toSV, 2) );
      
         double chi2testSV(999.);
         if ( chi2DefToUse == 2 ) {
           if (d0toSVErr2 !=0 && z0toSVErr2 != 0)
             chi2testSV = log(pow( d0toSV, 2)/d0toSVErr2
                              + pow( z0toSV, 2)/z0toSVErr2);
           // set results
           res = {d0toSV, sqrt(d0toSVErr2), z0toSV, sqrt(z0toSVErr2),
                  chi2testSV, (doDCAin3D ? docaSV : d0toSV), 4,
                  -99., -99., -999.};
         }
         if ( chi2DefToUse > 7 && chi2DefToUse < 10 ) {
           if ( docaSV > 0. ) {
             if ( chi2DefToUse == 8 ) {
               AmgMatrix(5,3) dmat = AmgMatrix(5,3)::Zero();
               dmat(0,0) = -sin(phi);
               dmat(0,1) =  cos(phi);
               dmat(1,2) =  1.;
               dmat(2,0) = -d0toSV*cos(phi);
               dmat(2,1) = -d0toSV*sin(phi);
               const AmgSymMatrix(5) mCovTrk5D =
                 track->definingParametersCovMatrix();
               AmgSymMatrix(3) mCovTrk3D = dmat.transpose()*mCovTrk5D*dmat;
               Amg::Vector3D dvec(-d0toSV*sin(phi), d0toSV*cos(phi),
                                  z0toSV); // (x,y,z)
               Amg::Vector3D duvec = dvec.unit();
               // log(chi2) = log( docavec^T * V^-1 * docavec )
               double chi2testSV = log( dvec.transpose()
                                        * (poscov+mCovTrk3D).inverse()
                                        * dvec );
               double vtx3DErr2 = duvec.transpose()*poscov*duvec;
               double trk3DErr2 = duvec.transpose()*mCovTrk3D*duvec;
               // set results
               res = {d0toSV, sqrt(d0Err2), z0toSV, sqrt(z0Err2),
                      chi2testSV, (doDCAin3D ? docaSV : d0toSV), 5,
                      vtx3DErr2, trk3DErr2, phi};
             }
             if ( chi2DefToUse == 9 ) {
               AmgMatrix(3,2) dmat = AmgMatrix(3,2)::Zero();
               dmat(0,0) = -sin(phi);
               dmat(1,0) =  cos(phi);
               dmat(2,0) =  0.;
               dmat(0,1) =  0.;
               dmat(1,1) =  0.;
               dmat(2,1) =  1.;
               AmgSymMatrix(2) mCovVtx2D = dmat.transpose()*SV_cov*dmat;
               AmgSymMatrix(2) mCovTrk2D = AmgSymMatrix(2)::Zero();
               mCovTrk2D(0,0) = d0Err2;
               mCovTrk2D(0,1) = d0z0Cov;
               mCovTrk2D(1,0) = d0z0Cov;
               mCovTrk2D(1,1) = z0Err2;
               Amg::Vector2D dvec(d0toSV, z0toSV);
               Amg::Vector2D duvec = dvec.unit();
               // log(chi2) = log( (d0, z0) * V^-1 * (d0, z0)^T )
               chi2testSV = log( dvec.transpose()*(mCovVtx2D+mCovTrk2D).inverse()
                                 * dvec );
               double vtx2DErr2 = duvec.transpose()*mCovVtx2D*duvec;
               double trk2DErr2 = duvec.transpose()*mCovTrk2D*duvec;
  
               if ( vtx2DErr2 < 0. || trk2DErr2 < 0. ) {
                 ATH_MSG_WARNING("BPhysVertexTrackBase::"
                                 "getTrackLogChi2DCA(): "
                                 << "vtx2DErr2 = " << vtx2DErr2
                                 << " trk2DErr2 = " << trk2DErr2
                                 << " chi2testSV = " << chi2testSV);
                 ATH_MSG_WARNING("dvec = " << dvec);
                 ATH_MSG_WARNING("mCovVtx2D = " << mCovVtx2D);
                 ATH_MSG_WARNING("mCovTrk2D = " << mCovTrk2D);
                 ATH_MSG_WARNING("dmat = " << dmat);
                 ATH_MSG_WARNING("SV_cov = " << SV_cov);
                 ATH_MSG_WARNING("det(mCovVtx2D) = " << mCovVtx2D.determinant());
                 ATH_MSG_WARNING("det(mCovTrk2D) = " << mCovTrk2D.determinant());
                 ATH_MSG_WARNING("det(SV_cov) = " << SV_cov.determinant());
                 ATH_MSG_WARNING("d0toSV = " << d0toSV
                                 << " z0toSV = " << z0toSV
                                 << " phi = " << phi
                                 << " docaSV = " << docaSV);
               }
                  
               // set results
               res = {d0toSV, sqrt(d0Err2), z0toSV, sqrt(z0Err2),
                      chi2testSV, (doDCAin3D ? docaSV : d0toSV), 6,
                      vtx2DErr2, trk2DErr2, phi};
             }
           } else {
             ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
                             << " docaSV == 0 !");
           }
         } // if chi2DefToUse > 7 && chi2DefToUse < 10
  
       } else if ( chi2DefToUse > 2 && chi2DefToUse < 5 ) {
         // CalcLogChi2toPV method using xAOD::TrackingHelpers
         // (simply taken from NtupleMaker for comparisons)
         // N.B. z0significance method of the helper doesn't include pv_z0
         // uncertainty
         double d0sign(0.);
         if (chi2DefToUse == 4) {
           d0sign =
             xAOD::TrackingHelpers::d0significance(track,
                                                   m_eventInfo->beamPosSigmaX(),
                                                   m_eventInfo->beamPosSigmaY(),
                                                   m_eventInfo->beamPosSigmaXY()
                                                   );
         } else {
           d0sign = xAOD::TrackingHelpers::d0significance( track );
         }
         // trk z0 is expressed relative to the beamspot position along z-axis
         // (trk->vz())
         // DCA always in 3D
         double z0toPV = track->z0() + track->vz() - vtx->z();
         double z0Err2 = track->definingParametersCovMatrixVec()[2];
         if (chi2DefToUse == 4) z0Err2+= vtx->covariancePosition()(2,2);
         double z0sign = z0toPV / sqrt( z0Err2 );
         double chi2 = log( pow(d0sign, 2.) + pow(z0sign, 2.) );
         // set results
         res = {-999., -99., z0toPV, sqrt(z0Err2), chi2, -100., 4, -99., -99.,
                -999.};
         
       } // if chi2DefToUse
     } else {
       ATH_MSG_WARNING("BPhysVertexTrackBase::getTrackLogChi2DCA():"
                       " track pointer is NULL!");
       res[6] = -2.;
     } // if track != NULL
     return res;
   }

◆ initialize()

StatusCode DerivationFramework::BPhysVertexTrackBase::initialize ( )

overridevirtual

Definition at line 401 of file BPhysVertexTrackBase.cxx.

                                               {
   
     ATH_MSG_DEBUG("BPhysVertexTrackBase::initialize() -- begin");
  
     if ( m_vertexContainerNames.size() == 0 ) {
       ATH_MSG_ERROR("No vertex container names provided!");
     }
     if ( m_refPVContainerNames.size() == 0 ) {
       ATH_MSG_ERROR("No refitted PV container names provided!");
     }
     if ( m_trackParticleContainerName == "" ) {
       ATH_MSG_ERROR("No track particle container name provided!");
     }
     if ( m_pvContainerName == "" ) {
       ATH_MSG_ERROR("No PV container name provided!");
     }
     if ( m_vertexContainerNames.size() != m_refPVContainerNames.size() ) {
       ATH_MSG_ERROR("Size mismatch of VertexContainerNames ("
             << m_vertexContainerNames.size()
             << ") and RefPVContainerNames ("
             << m_refPVContainerNames.size() << ") lists!");
     }
  
     if ( m_vertexContainerNames.size() != m_branchPrefixes.size() ) {
       ATH_MSG_ERROR("Size mismatch of VertexContainerNames ("
             << m_vertexContainerNames.size()
             << ") and BranchPrefixes ("
             << m_branchPrefixes.size() << ") lists!");
     }      
     
     // TrackToVertexTool
     ATH_CHECK(m_trackToVertexTool.retrieve());
  
     // TrackSelectionTools
     for (auto selTool : m_trackSelectionTools ) {
       ATH_CHECK(selTool.retrieve());
     }
  
     // TrackVertexAssociationTool
     ATH_CHECK(m_tvaTool.retrieve());
     // take note of working point
     // const std::string tvaWp("Loose");
     const std::string tvaWp =
       dynamic_cast<CP::TrackVertexAssociationTool*>(m_tvaTool.get())->getProperty("WorkingPoint").toString();
     m_tvaToolHasWpLoose = (tvaWp == "Loose");
     
     // initialize PV-to-SV association type vector
     initPvAssocTypeVec();
  
     // initialize track type request pattern
     m_trackTypesUsed = rttor(m_useTrackTypes);
  
     // initialize track type counters
     if ( m_debugTrackTypes > 0 ) {
       m_mttc = std::make_unique<TrackTypeCounter>(*this, name());    
     }
  
     ATH_MSG_DEBUG("BPhysVertexTrackBase::initialize() -- end");
  
     return initializeHook();
   }  

◆ initializeHook()

StatusCode DerivationFramework::BPhysVertexTrackBase::initializeHook ( )

protectedvirtual

Definition at line 559 of file BPhysVertexTrackBase.cxx.

                                                   {
  
     return StatusCode::SUCCESS;
   }  

◆ initPvAssocTypeVec()

void DerivationFramework::BPhysVertexTrackBase::initPvAssocTypeVec ( )

protectedvirtual

Definition at line 1339 of file BPhysVertexTrackBase.cxx.

                                                 {
  
     m_pvAssocTypes.clear();
     for (unsigned int i=0; i<xAOD::BPhysHelper::n_pv_types; ++i) {
       if ( (m_doVertexType & (1 << i)) > 0 )
     m_pvAssocTypes.push_back((xAOD::BPhysHelper::pv_type)i);
     }
   }

◆ rttor()

uint64_t DerivationFramework::BPhysVertexTrackBase::rttor ( const std::vector< uint64_t > & vtypes )

static

Definition at line 327 of file BPhysVertexTrackBase.cxx.

                                                                         {
     // or of requested track types
     uint64_t ttor(0);
     for (size_t i=0; i<vtypes.size(); ++i) {
       ttor |= vtypes[i];
     }
     return ttor;
   }

◆ selectTracks() [1/2]

TrackBag DerivationFramework::BPhysVertexTrackBase::selectTracks	(	const xAOD::TrackParticleContainer *	inpTracks,
		const TrackBag &	exclTracks,
		xAOD::BPhysHelper &	cand,
		const unsigned int	ipv,
		const unsigned int	its,
		const unsigned int	itt
	)		const

protected

Definition at line 1240 of file BPhysVertexTrackBase.cxx.

                                                         {
  
     const xAOD::Vertex* candRefPV  = cand.pv(m_pvAssocTypes[ipv]);
     const xAOD::Vertex* candPV     = cand.origPv(m_pvAssocTypes[ipv]);
  
     ATH_MSG_DEBUG("selectTracks: Found " << exclTracks.size()
           << " " << exclTracks
           << " for decay candidate " << cand.vtx()
           << "; candPV: " << candPV << " candRefPV: " << candRefPV);
  
     std::string bname(buildBranchBaseName(its, ipv, itt));
     
     // tracks to be considered
     TrackBag tracks;
     for (xAOD::TrackParticleContainer::const_iterator trkItr =
        inpTracks->begin(); trkItr != inpTracks->end(); ++trkItr) {
       const xAOD::TrackParticle* track = *trkItr;
       uint64_t trackTypesForTrack(0x0);
       // debug track types (before any cuts)
       if ( m_debugTrackTypes > 0 ) {
         trackTypesForTrack = detTrackTypes(track, candPV, candRefPV);
         m_mttc->addToCounter(trackTypesForTrack, itt, bname, "all");
       }
       // track selection check
       if ( ! m_trackSelectionTools[its]->accept(*track, candRefPV) ) continue;
       // debug track types (after track selection cuts)
       if ( m_debugTrackTypes > 0 ) {
         m_mttc->addToCounter(trackTypesForTrack, itt, bname, "ats");
       }
  
       // calcluation of track type bits not necessary if all bits requested
       if ( ! ((unsigned int)m_useTrackTypes[itt] == ttall() ||
               (unsigned int)m_useTrackTypes[itt] == ttallMin()) ) {
         // track type check -- determination if not in debugging mode
         // delayed for execution speed reasons
         if ( trackTypesForTrack == 0x0 ) {
           trackTypesForTrack = detTrackTypes(track, candPV, candRefPV);
         }
         if ( (trackTypesForTrack &  m_useTrackTypes[itt]) == 0x0 ) {
           continue;
         }
       }
       // debug track types (after track type cuts)
       if ( m_debugTrackTypes > 0 ) {
         m_mttc->addToCounter(trackTypesForTrack, itt, bname, "att");
       }
       // track not in list of tracks to exclude
       if ( std::find(exclTracks.begin(), exclTracks.end(), track)
            != exclTracks.end() ) continue;
       // debug track types (after all cuts)
       if ( m_debugTrackTypes > 0 ) {
         m_mttc->addToCounter(trackTypesForTrack, itt, bname, "fin");
       }
       // tracks that survived so far
       tracks.push_back(track);
     } // for
  
     return tracks;
   }

◆ selectTracks() [2/2]

TrackBag DerivationFramework::BPhysVertexTrackBase::selectTracks	(	const xAOD::TrackParticleContainer *	inpTracks,
		xAOD::BPhysHelper &	cand,
		const unsigned int	ipv,
		const unsigned int	its,
		const unsigned int	itt
	)		const

protected

Definition at line 1224 of file BPhysVertexTrackBase.cxx.

                                                         {
  
     return selectTracks(inpTracks, findAllTracksInDecay(cand), cand,
             ipv, its, itt);
   }

◆ trackToString()

std::string DerivationFramework::BPhysVertexTrackBase::trackToString ( const xAOD::TrackParticle * track )

static

Definition at line 338 of file BPhysVertexTrackBase.cxx.

                                                                     {
     std::string str;
     if (track != nullptr) {
     std::string str = std::format("p({:10.4f},{:10.4f},{:10.4f})\n"
     "d:({:10.5f},{:10.5f},{:10.5f},{:10.5f},{:10.6f})",
     (track->p4()).Px(), (track->p4()).Py(), (track->p4()).Pz(),
     track->d0(), track->z0(), track->phi0(), track->theta(),
     track->qOverP());
     } // if track
   return str;
   }

◆ ttall()

uint64_t DerivationFramework::BPhysVertexTrackBase::ttall ( )

static

Definition at line 318 of file BPhysVertexTrackBase.cxx.

                                        {
     if ( s_track_type_all_cached == 0x0 ) {
       for (unsigned int i=0; i<n_track_types; ++i) {
         s_track_type_all_cached |= track_type_bit[i];
       }
     }
     return s_track_type_all_cached;
   }

◆ ttallMin()

uint64_t DerivationFramework::BPhysVertexTrackBase::ttallMin ( )

static

Definition at line 313 of file BPhysVertexTrackBase.cxx.

                                           {
     // only bits 0 - 6
     return 127;
   }

◆ ttb()

uint64_t DerivationFramework::BPhysVertexTrackBase::ttb ( BPhysVertexTrackBase::track_type type )

static

Definition at line 309 of file BPhysVertexTrackBase.cxx.

                                                                         {
     return track_type_bit[type];
   }

◆ tts()

const std::string DerivationFramework::BPhysVertexTrackBase::tts ( BPhysVertexTrackBase::track_type type )

static

Definition at line 305 of file BPhysVertexTrackBase.cxx.

                                                                {
     return track_type_str[type];
   }

◆ wrapLines()

std::string DerivationFramework::BPhysVertexTrackBase::wrapLines	(	const std::string &	lines,
		const std::string &	prefix
	)

static

Definition at line 353 of file BPhysVertexTrackBase.cxx.

                                                    {
     
     std::string ostr;
     std::istringstream stream(lines);
     std::string line;
     while ( std::getline(stream, line) ) {
       if ( !ostr.empty() ) ostr += "\n";
       ostr += prefix + line;
     }
     return ostr;
   }

Member Data Documentation

◆ m_branchBaseName

std::string DerivationFramework::BPhysVertexTrackBase::m_branchBaseName

protected

Definition at line 246 of file BPhysVertexTrackBase.h.

◆ m_branchPrefixes

std::vector<std::string> DerivationFramework::BPhysVertexTrackBase::m_branchPrefixes

protected

Definition at line 245 of file BPhysVertexTrackBase.h.

◆ m_branchSuffix

std::string DerivationFramework::BPhysVertexTrackBase::m_branchSuffix

protected

Definition at line 247 of file BPhysVertexTrackBase.h.

◆ m_debugTracksInEvents

std::vector<uint64_t> DerivationFramework::BPhysVertexTrackBase::m_debugTracksInEvents

protected

Definition at line 265 of file BPhysVertexTrackBase.h.

◆ m_debugTracksInThisEvent

bool DerivationFramework::BPhysVertexTrackBase::m_debugTracksInThisEvent {}

mutableprotected

Definition at line 302 of file BPhysVertexTrackBase.h.

◆ m_debugTrackTypes

int DerivationFramework::BPhysVertexTrackBase::m_debugTrackTypes {}

protected

Definition at line 264 of file BPhysVertexTrackBase.h.

◆ m_doVertexType

int DerivationFramework::BPhysVertexTrackBase::m_doVertexType {}

protected

Definition at line 259 of file BPhysVertexTrackBase.h.

◆ m_eventInfo

const xAOD::EventInfo* DerivationFramework::BPhysVertexTrackBase::m_eventInfo {}

mutableprotected

Definition at line 285 of file BPhysVertexTrackBase.h.

◆ m_evtNumber

uint64_t DerivationFramework::BPhysVertexTrackBase::m_evtNumber {}

mutableprotected

Definition at line 299 of file BPhysVertexTrackBase.h.

◆ m_incPrecVerticesInDecay

bool DerivationFramework::BPhysVertexTrackBase::m_incPrecVerticesInDecay {}

protected

Definition at line 261 of file BPhysVertexTrackBase.h.

◆ m_minNTracksInPV

int DerivationFramework::BPhysVertexTrackBase::m_minNTracksInPV {}

protected

Definition at line 262 of file BPhysVertexTrackBase.h.

◆ m_mttc

std::unique_ptr<TrackTypeCounter> DerivationFramework::BPhysVertexTrackBase::m_mttc

protected

Definition at line 295 of file BPhysVertexTrackBase.h.

◆ m_nEvtsSeen

unsigned int DerivationFramework::BPhysVertexTrackBase::m_nEvtsSeen {}

mutableprotected

Definition at line 282 of file BPhysVertexTrackBase.h.

◆ m_pvAssocResMap

StringIntMap_t DerivationFramework::BPhysVertexTrackBase::m_pvAssocResMap

mutableprotected

Definition at line 289 of file BPhysVertexTrackBase.h.

◆ m_pvAssocTypes

std::vector<xAOD::BPhysHelper::pv_type> DerivationFramework::BPhysVertexTrackBase::m_pvAssocTypes

protected

Definition at line 280 of file BPhysVertexTrackBase.h.

◆ m_pvContainerName

std::string DerivationFramework::BPhysVertexTrackBase::m_pvContainerName

protected

Definition at line 256 of file BPhysVertexTrackBase.h.

◆ m_pvtxContainer

const xAOD::VertexContainer* DerivationFramework::BPhysVertexTrackBase::m_pvtxContainer {}

mutableprotected

Definition at line 273 of file BPhysVertexTrackBase.h.

◆ m_pvTypesToConsider

std::vector<uint64_t> DerivationFramework::BPhysVertexTrackBase::m_pvTypesToConsider

protected

Definition at line 263 of file BPhysVertexTrackBase.h.

◆ m_refPVAuxContainer

const xAOD::VertexAuxContainer* DerivationFramework::BPhysVertexTrackBase::m_refPVAuxContainer {}

mutableprotected

Definition at line 277 of file BPhysVertexTrackBase.h.

◆ m_refPVContainer

const xAOD::VertexContainer* DerivationFramework::BPhysVertexTrackBase::m_refPVContainer {}

mutableprotected

Definition at line 276 of file BPhysVertexTrackBase.h.

◆ m_refPVContainerNames

std::vector<std::string> DerivationFramework::BPhysVertexTrackBase::m_refPVContainerNames

protected

Definition at line 257 of file BPhysVertexTrackBase.h.

◆ m_runNumber

unsigned int DerivationFramework::BPhysVertexTrackBase::m_runNumber {}

mutableprotected

Definition at line 298 of file BPhysVertexTrackBase.h.

◆ m_svtxAuxContainer

const xAOD::VertexAuxContainer* DerivationFramework::BPhysVertexTrackBase::m_svtxAuxContainer {}

mutableprotected

Definition at line 275 of file BPhysVertexTrackBase.h.

◆ m_svtxContainer

const xAOD::VertexContainer* DerivationFramework::BPhysVertexTrackBase::m_svtxContainer {}

mutableprotected

Definition at line 274 of file BPhysVertexTrackBase.h.

◆ m_trackParticleContainerName

std::string DerivationFramework::BPhysVertexTrackBase::m_trackParticleContainerName

protected

Definition at line 249 of file BPhysVertexTrackBase.h.

◆ m_tracks

const xAOD::TrackParticleContainer* DerivationFramework::BPhysVertexTrackBase::m_tracks {}

mutableprotected

Definition at line 271 of file BPhysVertexTrackBase.h.

◆ m_tracksAux

const xAOD::TrackParticleAuxContainer* DerivationFramework::BPhysVertexTrackBase::m_tracksAux {}

mutableprotected

Definition at line 272 of file BPhysVertexTrackBase.h.

◆ m_trackSelectionTools

ToolHandleArray<TrkSelTool> DerivationFramework::BPhysVertexTrackBase::m_trackSelectionTools

protected

Definition at line 250 of file BPhysVertexTrackBase.h.

◆ m_trackToVertexTool

ToolHandle<Reco::ITrackToVertex> DerivationFramework::BPhysVertexTrackBase::m_trackToVertexTool

protected

Definition at line 252 of file BPhysVertexTrackBase.h.

◆ m_trackTypesUsed

uint64_t DerivationFramework::BPhysVertexTrackBase::m_trackTypesUsed {}

protected

Definition at line 292 of file BPhysVertexTrackBase.h.

◆ m_tvaTool

ToolHandle<CP::ITrackVertexAssociationTool> DerivationFramework::BPhysVertexTrackBase::m_tvaTool

protected

Definition at line 254 of file BPhysVertexTrackBase.h.

◆ m_tvaToolHasWpLoose

bool DerivationFramework::BPhysVertexTrackBase::m_tvaToolHasWpLoose {}

protected

Definition at line 268 of file BPhysVertexTrackBase.h.

◆ m_useTrackTypes

std::vector<uint64_t> DerivationFramework::BPhysVertexTrackBase::m_useTrackTypes

protected

Definition at line 260 of file BPhysVertexTrackBase.h.

◆ m_vertexContainerNames

std::vector<std::string> DerivationFramework::BPhysVertexTrackBase::m_vertexContainerNames

protected

Definition at line 248 of file BPhysVertexTrackBase.h.

◆ n_track_types

const int DerivationFramework::BPhysVertexTrackBase::n_track_types = 33

static

Definition at line 123 of file BPhysVertexTrackBase.h.

◆ s_track_type_all_cached

uint64_t DerivationFramework::BPhysVertexTrackBase::s_track_type_all_cached = 0x0

staticprivate

Definition at line 127 of file BPhysVertexTrackBase.h.

◆ track_type_bit

const uint64_t DerivationFramework::BPhysVertexTrackBase::track_type_bit

static

Initial value:

=
    {0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40,
     0x80, 0x100, 0x200, 0x400,
     0x800, 0x1000, 0x2000, 0x4000,
     0x8000, 0x10000, 0x20000, 0x40000,
     0x80000, 0x100000, 0x200000, 0x400000,
     0x800000, 0x1000000, 0x2000000, 0x4000000,
     0x8000000, 0x10000000, 0x20000000, 0x40000000,
     0x80000000, 0x100000000}

Definition at line 125 of file BPhysVertexTrackBase.h.

◆ track_type_str

const std::string DerivationFramework::BPhysVertexTrackBase::track_type_str

static

Initial value:

=
    {"ASSOCPV", "PVTYPE0", "PVTYPE1", "PVTYPE2", "PVTYPE3", "NONE", "NULLVP",
     "CAPVRFN3U0", "CAPVNRN3U0", "CAPVRF3DU0", "CAPVNR3DU0",
     "CAPVRFN3U1", "CAPVNRN3U1", "CAPVRF3DU1", "CAPVNR3DU1",
     "CAPVRFN3U2", "CAPVNRN3U2", "CAPVRF3DU2", "CAPVNR3DU2",
     "CAPVRFNNU3", "CAPVNRNNU3", "CAPVRFNNU4", "CAPVNRNNU4",
     "CAPVRFNNU5", "CAPVNRNNU5", "CAPVRFNNU6", "CAPVNRNNU6",
     "CAPVRFNNU7", "CAPVNRNNU7", "CAPVRFNNU8", "CAPVNRNNU8",
     "CAPVRFNNU9", "CAPVNRNNU9"}

Definition at line 124 of file BPhysVertexTrackBase.h.

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StringIntMap_t

Member Enumeration Documentation

◆ track_type

Constructor & Destructor Documentation

◆ BPhysVertexTrackBase()

Member Function Documentation

◆ addBranches()

◆ addBranchesHook()

◆ addBranchesSVLoopHook()

◆ addBranchesVCSetupHook()

◆ buildBranchBaseName()

◆ buildPvAssocCacheName()

◆ calculateValues()

◆ calcValuesHook()

◆ detTrackTypes()

◆ fastFillHook()

◆ finalize()

◆ finalizeHook()

◆ findAllMuonIdTracksInDecay()

◆ findAllMuonsInDecay() [1/2]

◆ findAllMuonsInDecay() [2/2]

◆ findAllTracksInDecay() [1/2]

◆ findAllTracksInDecay() [2/2]

◆ findAssocPV()

◆ findMinChi2PV()

◆ findMuonRefTrackMomenta()

◆ getTrackCandPVLogChi2()

◆ getTrackLogChi2DCA()

◆ initialize()

◆ initializeHook()

◆ initPvAssocTypeVec()

◆ rttor()

◆ selectTracks() [1/2]

◆ selectTracks() [2/2]

◆ trackToString()

◆ ttall()

◆ ttallMin()

◆ ttb()

◆ tts()

◆ wrapLines()

Member Data Documentation

◆ m_branchBaseName

◆ m_branchPrefixes

◆ m_branchSuffix

◆ m_debugTracksInEvents

◆ m_debugTracksInThisEvent

◆ m_debugTrackTypes

◆ m_doVertexType

◆ m_eventInfo

◆ m_evtNumber

◆ m_incPrecVerticesInDecay

◆ m_minNTracksInPV

◆ m_mttc

◆ m_nEvtsSeen

◆ m_pvAssocResMap

◆ m_pvAssocTypes

◆ m_pvContainerName

◆ m_pvtxContainer

◆ m_pvTypesToConsider

◆ m_refPVAuxContainer

◆ m_refPVContainer

◆ m_refPVContainerNames

◆ m_runNumber

◆ m_svtxAuxContainer

◆ m_svtxContainer

◆ m_trackParticleContainerName

◆ m_tracks

◆ m_tracksAux

◆ m_trackSelectionTools