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

#include <BPhysTrackVertexMapTool.h>

Inheritance diagram for xAOD::BPhysTrackVertexMapTool:

Collaboration diagram for xAOD::BPhysTrackVertexMapTool:

Public Member Functions
	BPhysTrackVertexMapTool (const std::string &name="BPhysTrackVertexMapTool")
	Declare the correct constructor for Athena. More...

virtual StatusCode	initialize () override
	Function initialising the tool. More...

virtual StatusCode	logEvent () override
	Function being excuted for each event. More...

virtual StatusCode	finalize () override
	Function finalizing the tool. More...

virtual bool	doLog () const override
	Function indicating whether log counter allows logging of current event. More...

virtual void	print () const
	Print the state of the tool. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

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

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

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 More...

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 More...

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. More...

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) More...

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) More...

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) More...

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> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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.

95 { 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() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

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

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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, LundVariablesTool, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

◆ TrackNameMap_t

◆ TrackToVertexMap_t

◆ VertexNameMap_t

Constructor & Destructor Documentation

◆ BPhysTrackVertexMapTool()

Member Function Documentation

◆ addVertexToTrackVertexMap()

◆ cacheEvent()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ doLog()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ getFloat()

◆ getKey()

◆ getName()

◆ getProperty()

◆ getTokens()

◆ idTrackName()

◆ idTracksToString()

◆ idTrackToString()

◆ initialize()

◆ initTrackVertexMaps()

◆ inputHandles()

◆ logEvent()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msg_level_name()

◆ msgLvl()

◆ outputHandles()

◆ print()

◆ pvName()

◆ pvsForIDTrack()

◆ pvsToString()

◆ pvToString()

◆ refPVName()

◆ refPVsForIDTrack()

◆ refPVsToString()

◆ refPVToString()

◆ renounce()

◆ renounceArray()

◆ summaryToString()

◆ svName()

◆ svsForIDTrack()

◆ svsToString()

◆ svToString()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

◆ wrapLines()

Member Data Documentation

◆ m_cachedEvent

◆ m_cachedRun

◆ m_debugTrkToVtxMaxEvents

◆ m_detStore

◆ m_dumpPrefix

◆ m_evtStore

◆ m_hypoName

◆ m_idTrackNameMap