xAOD::BPhysTrackVertexMapTool Class Reference

Dual-use tool createing a track-to-vertex map from the vertex-to-track information. More...

#include <BPhysTrackVertexMapTool.h>

Inheritance diagram for xAOD::BPhysTrackVertexMapTool:

Public Member Functions
	BPhysTrackVertexMapTool (const std::string &name="BPhysTrackVertexMapTool")
	Declare the correct constructor for Athena.
virtual StatusCode	initialize () override
	Function initialising the tool.
virtual StatusCode	logEvent () override
	Function being excuted for each event.
virtual StatusCode	finalize () override
	Function finalizing the tool.
virtual bool	doLog () const override
	Function indicating whether log counter allows logging of current event.
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Static Public Member Functions
static std::string	wrapLines (const std::string &lines, const std::string &prefix)
	convenience method to wrap output lines by a prefix

Protected Member Functions
virtual float	getFloat (std::string name, const xAOD::Vertex *b)
virtual std::vector< std::string >	getTokens (std::string input, std::string seperators)
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.
Functions to be called by user classes
fill cache for current event
virtual StatusCode	cacheEvent () override
virtual std::vector< const xAOD::Vertex * >	pvsForIDTrack (const xAOD::TrackParticle *track) const override
	obtain primary vertices for a given ID track (may return empty vector)
virtual std::vector< const xAOD::Vertex * >	refPVsForIDTrack (const xAOD::TrackParticle *track) const override
	obtain refitted primary vertices for a given ID track (may return empty vector)
virtual std::vector< const xAOD::Vertex * >	svsForIDTrack (const xAOD::TrackParticle *track) const override
	obtain secondary vertices for a given ID track (may return empty vector)
virtual std::string	idTrackToString (const xAOD::TrackParticle *track, unsigned int indent=0, bool withPV=false, bool withRefPV=false, bool withSV=false) override
virtual std::string	pvToString (const xAOD::Vertex *vtx, unsigned int indent=0, bool withTracks=false) override
virtual std::string	refPVToString (const xAOD::Vertex *vtx, unsigned int indent=0, bool withTracks=false) override
virtual std::string	svToString (const xAOD::Vertex *vtx, unsigned int indent=0, bool withTracks=false, bool withMasses=false) override
virtual std::string	idTracksToString (const xAOD::TrackParticleContainer *tpc, unsigned int indent=0, bool withPV=false, bool withRefPV=false, bool withSV=false) override
virtual std::string	pvsToString (const xAOD::VertexContainer *pvc, unsigned int indent=0, bool withTracks=false) override
virtual std::string	refPVsToString (const xAOD::VertexContainer *rpvc, unsigned int indent=0, bool withTracks=false) override
virtual std::string	svsToString (const xAOD::VertexContainer *svc, unsigned int indent=0, bool withTracks=false, bool withMasses=false) override
virtual std::string	summaryToString (std::string prefix) override

Protected Attributes
std::string	m_vertexContainerName
std::string	m_refPVContainerName
std::string	m_pvContainerName
std::string	m_trackParticleContainerName
int	m_debugTrkToVtxMaxEvents
std::string	m_dumpPrefix
std::string	m_hypoName
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
unsigned int	m_nEvtsSeen
int	m_cachedRun
int	m_cachedEvent

Private Types
typedef std::map< const xAOD::TrackParticle *, std::vector< const xAOD::Vertex * > >	TrackToVertexMap_t
typedef std::map< const xAOD::Vertex *, std::string >	VertexNameMap_t
typedef std::map< const xAOD::TrackParticle *, std::string >	TrackNameMap_t
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual void	initTrackVertexMaps (const xAOD::TrackParticleContainer *tpc, const xAOD::VertexContainer *pvc, const xAOD::VertexContainer *rpvc, const xAOD::VertexContainer *svc)
virtual void	addVertexToTrackVertexMap (TrackToVertexMap_t &map, const xAOD::TrackParticle *track, const xAOD::Vertex *vtx)
virtual std::string	pvName (const xAOD::Vertex *vtx)
virtual std::string	refPVName (const xAOD::Vertex *vtx)
virtual std::string	svName (const xAOD::Vertex *vtx)
virtual std::string	idTrackName (const xAOD::TrackParticle *vtx)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
VertexNameMap_t	m_pvNameMap
VertexNameMap_t	m_refPVNameMap
VertexNameMap_t	m_svNameMap
TrackNameMap_t	m_idTrackNameMap
TrackToVertexMap_t	m_idTrackToPVMap
TrackToVertexMap_t	m_idTrackToRefPVMap
TrackToVertexMap_t	m_idTrackToSVMap
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Dual-use tool createing a track-to-vertex map from the vertex-to-track information.

Job options provided by this class:

• VertexContainerName – name of container for secondary vertices
• RefPVContainerName – name of container for refitted PVs
• PVContainerName – name of container for primary vertices
• TrackParticleContainerName – name of container for TrackParticles
• DebugTrkToVtxMaxEvents – Maximum number of events to produce detailed log output for the track-to-vertex association maps. Set to -1 for infinity.
• DumpPrefix – Line prefix for log dump lines.
• HypoName – Hypothesis name (for picking up inv. mass values) May be a set of hypo names to be tested, delimited by '|'.

Author

Wolfgang Walkowiak Wolfg.nosp@m.ang..nosp@m.Walko.nosp@m.wiak.nosp@m.@cern.nosp@m..ch

$Revision:$

Date

Definition at line 47 of file BPhysTrackVertexMapTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TrackNameMap_t

typedef std::map<const xAOD::TrackParticle*, std::string> xAOD::BPhysTrackVertexMapTool::TrackNameMap_t

private

Definition at line 185 of file BPhysTrackVertexMapTool.h.

TrackToVertexMap_t

typedef std::map<const xAOD::TrackParticle*, std::vector<const xAOD::Vertex*> > xAOD::BPhysTrackVertexMapTool::TrackToVertexMap_t

private

Definition at line 140 of file BPhysTrackVertexMapTool.h.

VertexNameMap_t

typedef std::map<const xAOD::Vertex*, std::string> xAOD::BPhysTrackVertexMapTool::VertexNameMap_t

private

Definition at line 180 of file BPhysTrackVertexMapTool.h.

Constructor & Destructor Documentation

BPhysTrackVertexMapTool()

xAOD::BPhysTrackVertexMapTool::BPhysTrackVertexMapTool

(

const std::string &

name = "BPhysTrackVertexMapTool"

)

Declare the correct constructor for Athena.

Regular AsgTool constructor

Definition at line 36 of file BPhysTrackVertexMapTool.cxx.

    : asg::AsgTool( name ),
      m_tracks(NULL), m_tracksAux(NULL), m_pvtxContainer(NULL),
      m_svtxContainer(NULL), m_svtxAuxContainer(NULL), m_refPVContainer(NULL),
      m_refPVAuxContainer(NULL),
      m_nEvtsSeen (0), m_cachedRun(-1), m_cachedEvent(-1) {
 
#ifdef ASGTOOL_ATHENA
    declareInterface< IBPhysTrackVertexMapTool >( this );
#endif // ASGTOOL_ATHENA
 
    // Necessary containers
    declareProperty("VertexContainerName", m_vertexContainerName);
    declareProperty("TrackParticleContainerName",
            m_trackParticleContainerName="InDetTrackParticles");
    declareProperty("PVContainerName", m_pvContainerName = "PrimaryVertices");
    declareProperty("RefPVContainerName", m_refPVContainerName);
 
    // Maximum number of events to dump maps to log file for 
    declareProperty("DebugTrkToVtxMaxEvents", m_debugTrkToVtxMaxEvents = 0);
 
    // Prefix for log dump lines 
    declareProperty("DumpPrefix", m_dumpPrefix="TTV> ");
 
    // Hypothesis name (for mass value pickup)
    declareProperty("HypoName", m_hypoName="__NONE__");
  }

Member Function Documentation

addVertexToTrackVertexMap()

void xAOD::BPhysTrackVertexMapTool::addVertexToTrackVertexMap ( TrackToVertexMap_t & map, const xAOD::TrackParticle * track, const xAOD::Vertex * vtx )

privatevirtual

Definition at line 323 of file BPhysTrackVertexMapTool.cxx.

                                         {
 
    TrackToVertexMap_t::const_iterator it = map.find(track);
 
    if ( it == map.end() ) {
      map[track] = std::vector<const xAOD::Vertex*>();
    }
    map[track].push_back(vtx);
  }

cacheEvent()

StatusCode xAOD::BPhysTrackVertexMapTool::cacheEvent ( )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 139 of file BPhysTrackVertexMapTool.cxx.

                                                 {
 
    ATH_MSG_DEBUG("BPhysTrackVertexMapTool::cacheEvent -- begin");
    
    const xAOD::EventInfo* eventInfo = NULL;
    ATH_CHECK(evtStore()->retrieve(eventInfo, "EventInfo"));
 
    if ( m_cachedRun   != (int)eventInfo->runNumber() ||
     m_cachedEvent != (int)eventInfo->eventNumber() ) {
 
      // note update
      m_cachedRun   = eventInfo->runNumber();
      m_cachedEvent = eventInfo->eventNumber();
 
      ATH_MSG_DEBUG("BPhysTrackVertexMapTool::cacheEvent: caching now: "
            << "run " << m_cachedRun << " event " << m_cachedEvent);
      
      // retrieve primary vertices container
      m_pvtxContainer = NULL;
      ATH_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;
      ATH_CHECK(evtStore()->retrieve(m_tracks, m_trackParticleContainerName));
      if (evtStore()->contains<xAOD::
      TrackParticleAuxContainer>(m_trackParticleContainerName+"Aux.")) {
    ATH_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);
      
      // vertex container and its auxilliary store
      m_svtxContainer    = NULL;
      m_svtxAuxContainer = NULL;
      ATH_CHECK(evtStore()->retrieve(m_svtxContainer, m_vertexContainerName));
      ATH_CHECK(evtStore()->retrieve(m_svtxAuxContainer,
                     m_vertexContainerName+"Aux."));
      ATH_MSG_DEBUG("Found SV collection with key " << m_vertexContainerName);
      
      // refitted primary vertex container and its auxilliary store
      m_refPVContainer    = NULL;
      m_refPVAuxContainer = NULL;
      ATH_CHECK(evtStore()->retrieve(m_refPVContainer, m_refPVContainerName));
      ATH_CHECK(evtStore()->retrieve(m_refPVAuxContainer,
                     m_refPVContainerName+"Aux."));
      ATH_MSG_DEBUG("Found refitted PV collection with key "
            << m_refPVContainerName);
 
      // initialize track, PV and refPV maps
      initTrackVertexMaps(m_tracks, m_pvtxContainer, m_refPVContainer, 
              m_svtxContainer);
    } // if new run/event
    
    ATH_MSG_DEBUG("BPhysTrackVertexMapTool::cacheEvent -- end");
    
    // Return gracefully:
    return StatusCode::SUCCESS;
  } 

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

doLog()

bool xAOD::BPhysTrackVertexMapTool::doLog ( ) const

overridevirtual

Function indicating whether log counter allows logging of current event.

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 126 of file BPhysTrackVertexMapTool.cxx.

                                            {
 
    return ( m_debugTrkToVtxMaxEvents < 0 ||
         m_debugTrkToVtxMaxEvents > (int)m_nEvtsSeen );
  }  

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode xAOD::BPhysTrackVertexMapTool::finalize ( )

overridevirtual

Function finalizing the tool.

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 95 of file BPhysTrackVertexMapTool.cxx.

                                               {
 
    ATH_MSG_DEBUG( "Finalizing xAOD::BPhysTrackVertexMapTool" );
 
    // Return gracefully:
    return StatusCode::SUCCESS;
  }  

getFloat()

float xAOD::BPhysTrackVertexMapTool::getFloat ( std::string name, const xAOD::Vertex * b )

protectedvirtual

Definition at line 615 of file BPhysTrackVertexMapTool.cxx.

                                           {
 
    float res = -999999.;
 
    SG::AuxElement::Accessor<float> floatAcc(name);
    if ( floatAcc.isAvailable(*b) ) res = floatAcc(*b);
 
    return res;
  } 

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

getTokens()

std::vector< std::string > xAOD::BPhysTrackVertexMapTool::getTokens ( std::string input, std::string seperators )

protectedvirtual

Definition at line 628 of file BPhysTrackVertexMapTool.cxx.

                                                   {
 
    std::vector<std::string> tokens;
    boost::char_separator<char> sep(seperators.c_str());
    typedef boost::tokenizer<boost::char_separator<char> > Tokenizer_t;
    Tokenizer_t tokenizer(input, sep);
    for (auto& token : tokenizer) {
      tokens.push_back(token);
    }
    return tokens;
  }

idTrackName()

std::string xAOD::BPhysTrackVertexMapTool::idTrackName ( const xAOD::TrackParticle * vtx )

privatevirtual

Definition at line 372 of file BPhysTrackVertexMapTool.cxx.

                                                                     {
    
    if ( m_idTrackNameMap.find(track) == m_idTrackNameMap.end() ) {
      std::string f = std::format("T{:04d}", m_idTrackNameMap.size());
      m_idTrackNameMap[track] = f;
    }
    return m_idTrackNameMap[track];
  }

idTracksToString()

std::string xAOD::BPhysTrackVertexMapTool::idTracksToString ( const xAOD::TrackParticleContainer * tpc, unsigned int indent = 0, bool withPV = false, bool withRefPV = false, bool withSV = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 514 of file BPhysTrackVertexMapTool.cxx.

                                     {
 
    std::string str;
    std::string sind(indent, ' ');
    str += sind + "ID tracks: (" + std::to_string(tpc->size()) + ")\n";
    str += sind + std::string(80-indent, '-');
    // loop over ID tracks
    for (xAOD::TrackParticleContainer::const_iterator trkItr = tpc->begin();
     trkItr != tpc->end(); ++trkItr) {
      const xAOD::TrackParticle* track = *trkItr;
      str += "\n" 
    + idTrackToString(track, indent+2, withPV, withRefPV, withSV);
    }
    return str;
  }

idTrackToString()

std::string xAOD::BPhysTrackVertexMapTool::idTrackToString ( const xAOD::TrackParticle * track, unsigned int indent = 0, bool withPV = false, bool withRefPV = false, bool withSV = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 384 of file BPhysTrackVertexMapTool.cxx.

                                    {
    
    std::string sind(indent, ' ');
    std::string str = std::format("{} {:<5} {} ({:10.4f}, {:10.4f}, {:10.4f}) VL ", 
    sind, idTrackName(track), static_cast<const void*>(track), 
    track->pt(),track->eta(), track->phi());
    if ( withPV ) {
      TrackToVertexMap_t::iterator it = m_idTrackToPVMap.find(track);
      if ( it != m_idTrackToPVMap.end() ) {
    for ( auto vtx : it->second ) {
      str += "\n" + pvToString(vtx, indent+2, false);
    }
      } else {
        std::string f = std::format("\n{}  {}", sind, "NOPV");
        str += f;
        
      }
    }
    if ( withRefPV ) {
      TrackToVertexMap_t::iterator it = m_idTrackToRefPVMap.find(track);
      if ( it != m_idTrackToRefPVMap.end() ) {
    for ( auto vtx : it->second ) {
      str += "\n" + refPVToString(vtx, indent+2, false);
    }
      } else {
        std::string f = std::format("\n{}  {}", sind, "NORV");
        str += f;
      }
    }
    if ( withSV ) {
      TrackToVertexMap_t::iterator it = m_idTrackToSVMap.find(track);
      if ( it != m_idTrackToSVMap.end() ) {
    for ( auto vtx : it->second ) {
      str += "\n" + svToString(vtx, indent+2, false);
    }
      } else {
        std::string f2 = std::format("\n{}  {}", sind, "NOSV");
        str += f2;
      }
    }
    return str;
  }  

initialize()

StatusCode xAOD::BPhysTrackVertexMapTool::initialize ( void )

overridevirtual

Function initialising the tool.

Reimplemented from asg::AsgTool.

Definition at line 64 of file BPhysTrackVertexMapTool.cxx.

                                                 {
    
    // Greet the user:
    ATH_MSG_DEBUG( "Initializing xAOD::BPhysTrackVertexMapTool" );
    
    if ( m_vertexContainerName == "" ) {
      ATH_MSG_ERROR("No vertex container name provided!");
    }
    if ( m_refPVContainerName == "" ) {
      ATH_MSG_ERROR("No refitted PV container name provided!");
    }
    if ( m_trackParticleContainerName == "" ) {
      ATH_MSG_ERROR("No track particle container name provided!");
    }
    if ( m_pvContainerName == "" ) {
      ATH_MSG_ERROR("No PV container name provided!");
    }
    // some info for the job log
    ATH_MSG_INFO("VertexContainerName        : " << m_vertexContainerName);
    ATH_MSG_INFO("PVContainerName            : " << m_pvContainerName);
    ATH_MSG_INFO("RefPVContainerName         : " << m_refPVContainerName);
    ATH_MSG_INFO("TrackParticleContainerName : "
         << m_trackParticleContainerName);
    ATH_MSG_INFO("DebugTrkToVtxMaxEvents     : " << m_debugTrkToVtxMaxEvents);
    ATH_MSG_INFO("DumpPrefix                 : " << m_dumpPrefix);
    ATH_MSG_INFO("HypoName                   : " << m_hypoName);
    
    // Return gracefully:
    return StatusCode::SUCCESS;
  }

initTrackVertexMaps()

void xAOD::BPhysTrackVertexMapTool::initTrackVertexMaps ( const xAOD::TrackParticleContainer * tpc, const xAOD::VertexContainer * pvc, const xAOD::VertexContainer * rpvc, const xAOD::VertexContainer * svc )

privatevirtual

Definition at line 262 of file BPhysTrackVertexMapTool.cxx.

                                                   {
 
    // clear previous entries
    m_pvNameMap.clear();
    m_refPVNameMap.clear();
    m_svNameMap.clear();
    m_idTrackNameMap.clear();
    m_idTrackToPVMap.clear();
    m_idTrackToRefPVMap.clear();
    m_idTrackToSVMap.clear();
 
    // initialize maps for PVs
    for (xAOD::VertexContainer::const_iterator vtxItr = pvc->begin();
     vtxItr != pvc->end(); ++vtxItr) {
      const xAOD::Vertex* vtx = *vtxItr;
      pvName(vtx);
      for (size_t i = 0; i < vtx->nTrackParticles(); ++i) {
    const xAOD::TrackParticle* track = vtx->trackParticle(i);
    // m_idTrackToPVMap[track] = vtx;
    addVertexToTrackVertexMap(m_idTrackToPVMap, track, vtx);
      }
    }
    // initialize maps for refitted PVs
    for (xAOD::VertexContainer::const_iterator vtxItr = rpvc->begin();
     vtxItr != rpvc->end(); ++vtxItr) {
      const xAOD::Vertex* vtx = *vtxItr;
      refPVName(vtx);
      for (size_t i = 0; i < vtx->nTrackParticles(); ++i) {
    const xAOD::TrackParticle* track = vtx->trackParticle(i);
    // m_idTrackToRefPVMap[track] = vtx;
    addVertexToTrackVertexMap(m_idTrackToRefPVMap, track, vtx);
      }
    }
 
    // initialize maps for SVs
    for (xAOD::VertexContainer::const_iterator vtxItr = svc->begin();
     vtxItr != svc->end(); ++vtxItr) {
      const xAOD::Vertex* vtx = *vtxItr;
      svName(vtx);
      for (size_t i = 0; i < vtx->nTrackParticles(); ++i) {
    const xAOD::TrackParticle* track = vtx->trackParticle(i);
    // m_idTrackToSVMap[track] = vtx;
    addVertexToTrackVertexMap(m_idTrackToSVMap, track, vtx);
      }
    }
    // initialize maps for ID tracks
    for (xAOD::TrackParticleContainer::const_iterator trkItr = tpc->begin();
     trkItr != tpc->end(); ++trkItr) {
      const xAOD::TrackParticle* track = *trkItr;
      idTrackName(track);
    }
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

logEvent()

StatusCode xAOD::BPhysTrackVertexMapTool::logEvent ( )

overridevirtual

Function being excuted for each event.

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 103 of file BPhysTrackVertexMapTool.cxx.

                                               {
 
    ATH_MSG_DEBUG( "logEvent in xAOD::BPhysTrackVertexMapTool" );
  
    // read info into maps cache
    ATH_CHECK(cacheEvent());
    
    // dump info from maps if requested
    if ( doLog() ) {
 
      ATH_MSG_INFO("Track-to-vertex association map:");
      
      std::cout << summaryToString(m_dumpPrefix) << std::endl;
      
    } // if requested
 
    // increment counter
    m_nEvtsSeen++;
 
    // Return gracefully:
    return StatusCode::SUCCESS;
  }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

pvName()

std::string xAOD::BPhysTrackVertexMapTool::pvName ( const xAOD::Vertex * vtx )

privatevirtual

Definition at line 338 of file BPhysTrackVertexMapTool.cxx.

                                                                 {
    
    if ( m_pvNameMap.find(vtx) == m_pvNameMap.end() ) {
      std::string f = std::format("PV{:03d}", m_pvNameMap.size());
      m_pvNameMap[vtx] = f;
    }
    return m_pvNameMap[vtx];
  }

pvsForIDTrack()

std::vector< const xAOD::Vertex * > xAOD::BPhysTrackVertexMapTool::pvsForIDTrack ( const xAOD::TrackParticle * track ) const

overrideprotectedvirtual

obtain primary vertices for a given ID track (may return empty vector)

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 209 of file BPhysTrackVertexMapTool.cxx.

          {
    
    TrackToVertexMap_t::const_iterator it = m_idTrackToPVMap.find(track);
 
    if ( it != m_idTrackToPVMap.end() ) {
      return it->second;
    } else {
      std::vector<const xAOD::Vertex*> dummy;
      return dummy;
    }
  }

pvsToString()

std::string xAOD::BPhysTrackVertexMapTool::pvsToString ( const xAOD::VertexContainer * pvc, unsigned int indent = 0, bool withTracks = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 538 of file BPhysTrackVertexMapTool.cxx.

                                        {
 
    std::string str;
    std::string sind(indent, ' ');
    str += sind + "Primary vertices: (" + std::to_string(pvc->size()) + ")\n";
    str += sind + std::string(80-indent, '-');
    for (xAOD::VertexContainer::const_iterator vtxItr = pvc->begin();
     vtxItr != pvc->end(); ++vtxItr) {
      const xAOD::Vertex* vtx = *vtxItr;
      str += "\n" + pvToString(vtx, indent+2, withTracks);
    } // for    
 
    return str;
  }

pvToString()

std::string xAOD::BPhysTrackVertexMapTool::pvToString ( const xAOD::Vertex * vtx, unsigned int indent = 0, bool withTracks = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 433 of file BPhysTrackVertexMapTool.cxx.

                                       {
 
    std::string sind(indent, ' ');
    std::string str = std::format("{} {:<5} {} ({:10.4f}, {:10.4f}, {:10.4f}) NT {:4d} VT {}",
    sind, pvName(vtx), static_cast<const void*>(vtx), vtx->x(), vtx->y(), vtx->z(),
    vtx->nTrackParticles(), static_cast<int>(vtx->vertexType()));
    if ( withTracks ) {
      for (size_t i=0; i < vtx->nTrackParticles(); ++i) {
        std::string f2 = std::format("\n{}  {:4d} {}", 
        sind, i, idTrackToString(vtx->trackParticle(i), 0, false, false));
        str += f2;
      } // for
    }
 
    return str;
  }

refPVName()

std::string xAOD::BPhysTrackVertexMapTool::refPVName ( const xAOD::Vertex * vtx )

privatevirtual

Definition at line 349 of file BPhysTrackVertexMapTool.cxx.

                                                                    {
    
    if ( m_refPVNameMap.find(vtx) == m_refPVNameMap.end() ) {
      std::string f = std::format("RV{:03d}", m_refPVNameMap.size());
      m_refPVNameMap[vtx] = f;
    }
    return m_refPVNameMap[vtx];
  }

refPVsForIDTrack()

std::vector< const xAOD::Vertex * > xAOD::BPhysTrackVertexMapTool::refPVsForIDTrack ( const xAOD::TrackParticle * track ) const

overrideprotectedvirtual

obtain refitted primary vertices for a given ID track (may return empty vector)

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 227 of file BPhysTrackVertexMapTool.cxx.

          {
    
    TrackToVertexMap_t::const_iterator it = m_idTrackToRefPVMap.find(track);
 
    if ( it != m_idTrackToRefPVMap.end() ) {
      return it->second;
    } else {
      std::vector<const xAOD::Vertex*> dummy;
      return dummy;
    }
  }

refPVsToString()

std::string xAOD::BPhysTrackVertexMapTool::refPVsToString ( const xAOD::VertexContainer * rpvc, unsigned int indent = 0, bool withTracks = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 559 of file BPhysTrackVertexMapTool.cxx.

                                       {
 
    std::string str;
    std::string sind(indent, ' ');
    str += sind + "Refitted primary vertices: (" + std::to_string(rpvc->size()) + ")\n";
    str += sind + std::string(80-indent, '-');
    for (xAOD::VertexContainer::const_iterator vtxItr = rpvc->begin();
     vtxItr != rpvc->end(); ++vtxItr) {
      const xAOD::Vertex* vtx = *vtxItr;
      str += "\n" + refPVToString(vtx, indent+2, withTracks);
    } // for    
 
    return str;
  }

refPVToString()

std::string xAOD::BPhysTrackVertexMapTool::refPVToString ( const xAOD::Vertex * vtx, unsigned int indent = 0, bool withTracks = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 455 of file BPhysTrackVertexMapTool.cxx.

                                      {
 
    std::string sind(indent, ' ');
    std::string str = std::format("{} {:<5} {} ({:10.4f}, {:10.4f}, {:10.4f}) NT {:4d} VT {}",
    sind,refPVName(vtx), static_cast<const void*>(vtx), vtx->x(), vtx->y(), vtx->z(),
    vtx->nTrackParticles(), static_cast<int>(vtx->vertexType()));
    if ( withTracks ) {
      for (size_t i=0; i < vtx->nTrackParticles(); ++i) {
        str += std::format("\n{}  {:4} {}", sind, i, idTrackToString(vtx->trackParticle(i), 0, false, false));
      } // for
    }
 
    return str;
  }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

summaryToString()

std::string xAOD::BPhysTrackVertexMapTool::summaryToString ( std::string prefix )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 599 of file BPhysTrackVertexMapTool.cxx.

                                                                     {
 
    std::string form_str = std::format("{}\n\nRun: {}  Event: {}\n\n", name(), m_cachedRun, m_cachedEvent);
    std::string dstr = 
      wrapLines("\n"+form_str +
        pvsToString(m_pvtxContainer, 0, true) + "\n\n" +
        refPVsToString(m_refPVContainer, 0, true) + "\n\n" +
        svsToString(m_svtxContainer, 0, true, true) + "\n\n" +
        idTracksToString(m_tracks, 0, true, true, true) + "\n",
        prefix);
 
    return dstr;
  }

svName()

std::string xAOD::BPhysTrackVertexMapTool::svName ( const xAOD::Vertex * vtx )

privatevirtual

Definition at line 360 of file BPhysTrackVertexMapTool.cxx.

                                                                 {
    
    if ( m_svNameMap.find(vtx) == m_svNameMap.end() ) {
      std::string f = std::format("SV{:03d}", m_svNameMap.size());
      m_svNameMap[vtx] = f;
    }
    return m_svNameMap[vtx];
  }

svsForIDTrack()

std::vector< const xAOD::Vertex * > xAOD::BPhysTrackVertexMapTool::svsForIDTrack ( const xAOD::TrackParticle * track ) const

overrideprotectedvirtual

obtain secondary vertices for a given ID track (may return empty vector)

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 245 of file BPhysTrackVertexMapTool.cxx.

          {
    
    TrackToVertexMap_t::const_iterator it = m_idTrackToSVMap.find(track);
 
    if ( it != m_idTrackToSVMap.end() ) {
      return it->second;
    } else {
      std::vector<const xAOD::Vertex*> dummy;
      return dummy;
    }
  }

svsToString()

std::string xAOD::BPhysTrackVertexMapTool::svsToString ( const xAOD::VertexContainer * svc, unsigned int indent = 0, bool withTracks = false, bool withMasses = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 579 of file BPhysTrackVertexMapTool.cxx.

                                        {
 
    std::string str;
    std::string sind(indent, ' ');
    str += sind + "Secondary vertices: (" + std::to_string(svc->size()) + ")\n";
    str += sind + std::string(80-indent, '-');
    for (xAOD::VertexContainer::const_iterator vtxItr = svc->begin();
     vtxItr != svc->end(); ++vtxItr) {
      const xAOD::Vertex* vtx = *vtxItr;
      str += "\n" + svToString(vtx, indent+2, withTracks, withMasses);
    } // for    
 
    return str;
  }

svToString()

std::string xAOD::BPhysTrackVertexMapTool::svToString ( const xAOD::Vertex * vtx, unsigned int indent = 0, bool withTracks = false, bool withMasses = false )

overrideprotectedvirtual

Implements xAOD::IBPhysTrackVertexMapTool.

Definition at line 475 of file BPhysTrackVertexMapTool.cxx.

                                       {
    
    std::string sind(indent, ' ');
    std::string str = std::format("{} {:<5} {} ({:10.4f}, {:10.4f}, {:10.4f}) NT {:4} VT {}",
    sind, svName(vtx), static_cast<const void*>(vtx), vtx->x(), vtx->y(), vtx->z(),
    vtx->nTrackParticles(), static_cast<int>(vtx->vertexType()));
    if ( withMasses && m_hypoName != "__NONE__" ) {
      // vector of possible hypo names
      std::vector<std::string> hypoNames = getTokens(m_hypoName, "|;/");
      for ( const std::string& hypoName : hypoNames ) {
    BPhysHypoHelper bhh(hypoName, vtx);
    float bMass       = bhh.mass();
    float bMassErr    = bhh.massErr();
    float bMucMass    = getFloat(hypoName+"_MUCALC_mass", vtx);
    float bMucMassErr = getFloat(hypoName+"_MUCALC_massErr", vtx);
    if ( bMass > 0. || bMassErr > 0.
         || bMucMass > 0. || bMucMassErr > 0. ) {
          str += std::format("\n{}  {:<10} : mass     : ({:15.4f} +/- {:15.4f}) MeV",
          sind, hypoName, bMass, bMassErr);
          str += std::format("\n{}  {:<10} : m(MUCALC): ({:15.4f} +/- {:15.4f}) MeV",
          sind, hypoName, bMucMass, bMucMassErr);
    } // if one > 0.
      } // for hypoNames
    } // if withMasses
    if ( withTracks ) {
      for (size_t i=0; i < vtx->nTrackParticles(); ++i) {
        str += std::format("\n{}  {:4} {}", sind, i, idTrackToString(vtx->trackParticle(i), 0, false, false));
      } // for
    }
    return str;
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

wrapLines()

std::string xAOD::BPhysTrackVertexMapTool::wrapLines ( const std::string & lines, const std::string & prefix )

static

convenience method to wrap output lines by a prefix

Definition at line 21 of file BPhysTrackVertexMapTool.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_cachedEvent

int xAOD::BPhysTrackVertexMapTool::m_cachedEvent

protected

Definition at line 176 of file BPhysTrackVertexMapTool.h.

m_cachedRun

int xAOD::BPhysTrackVertexMapTool::m_cachedRun

protected

Definition at line 175 of file BPhysTrackVertexMapTool.h.

m_debugTrkToVtxMaxEvents

int xAOD::BPhysTrackVertexMapTool::m_debugTrkToVtxMaxEvents

protected

Definition at line 160 of file BPhysTrackVertexMapTool.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dumpPrefix

std::string xAOD::BPhysTrackVertexMapTool::m_dumpPrefix

protected

Definition at line 161 of file BPhysTrackVertexMapTool.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_hypoName

std::string xAOD::BPhysTrackVertexMapTool::m_hypoName

protected

Definition at line 162 of file BPhysTrackVertexMapTool.h.

m_idTrackNameMap

TrackNameMap_t xAOD::BPhysTrackVertexMapTool::m_idTrackNameMap

private

Definition at line 186 of file BPhysTrackVertexMapTool.h.

m_idTrackToPVMap

TrackToVertexMap_t xAOD::BPhysTrackVertexMapTool::m_idTrackToPVMap

private

Definition at line 188 of file BPhysTrackVertexMapTool.h.

m_idTrackToRefPVMap

TrackToVertexMap_t xAOD::BPhysTrackVertexMapTool::m_idTrackToRefPVMap

private

Definition at line 189 of file BPhysTrackVertexMapTool.h.

m_idTrackToSVMap

TrackToVertexMap_t xAOD::BPhysTrackVertexMapTool::m_idTrackToSVMap

private

Definition at line 190 of file BPhysTrackVertexMapTool.h.

m_nEvtsSeen

unsigned int xAOD::BPhysTrackVertexMapTool::m_nEvtsSeen

protected

Definition at line 173 of file BPhysTrackVertexMapTool.h.

m_pvContainerName

std::string xAOD::BPhysTrackVertexMapTool::m_pvContainerName

protected

Definition at line 158 of file BPhysTrackVertexMapTool.h.

m_pvNameMap

VertexNameMap_t xAOD::BPhysTrackVertexMapTool::m_pvNameMap

private

Definition at line 181 of file BPhysTrackVertexMapTool.h.

m_pvtxContainer

const xAOD::VertexContainer* xAOD::BPhysTrackVertexMapTool::m_pvtxContainer

protected

Definition at line 167 of file BPhysTrackVertexMapTool.h.

m_refPVAuxContainer

const xAOD::VertexAuxContainer* xAOD::BPhysTrackVertexMapTool::m_refPVAuxContainer

protected

Definition at line 171 of file BPhysTrackVertexMapTool.h.

m_refPVContainer

const xAOD::VertexContainer* xAOD::BPhysTrackVertexMapTool::m_refPVContainer

protected

Definition at line 170 of file BPhysTrackVertexMapTool.h.

m_refPVContainerName

std::string xAOD::BPhysTrackVertexMapTool::m_refPVContainerName

protected

Definition at line 157 of file BPhysTrackVertexMapTool.h.

m_refPVNameMap

VertexNameMap_t xAOD::BPhysTrackVertexMapTool::m_refPVNameMap

private

Definition at line 182 of file BPhysTrackVertexMapTool.h.

m_svNameMap

VertexNameMap_t xAOD::BPhysTrackVertexMapTool::m_svNameMap

private

Definition at line 183 of file BPhysTrackVertexMapTool.h.

m_svtxAuxContainer

const xAOD::VertexAuxContainer* xAOD::BPhysTrackVertexMapTool::m_svtxAuxContainer

protected

Definition at line 169 of file BPhysTrackVertexMapTool.h.

m_svtxContainer

const xAOD::VertexContainer* xAOD::BPhysTrackVertexMapTool::m_svtxContainer

protected

Definition at line 168 of file BPhysTrackVertexMapTool.h.

m_trackParticleContainerName

std::string xAOD::BPhysTrackVertexMapTool::m_trackParticleContainerName

protected

Definition at line 159 of file BPhysTrackVertexMapTool.h.

m_tracks

const xAOD::TrackParticleContainer* xAOD::BPhysTrackVertexMapTool::m_tracks

protected

Definition at line 165 of file BPhysTrackVertexMapTool.h.

m_tracksAux

const xAOD::TrackParticleAuxContainer* xAOD::BPhysTrackVertexMapTool::m_tracksAux

protected

Definition at line 166 of file BPhysTrackVertexMapTool.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexContainerName

std::string xAOD::BPhysTrackVertexMapTool::m_vertexContainerName

protected

Definition at line 156 of file BPhysTrackVertexMapTool.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• BPhysTrackVertexMapTool.h
• BPhysTrackVertexMapTool.cxx