#include <InDetV0FinderTool.h>

Inheritance diagram for InDet::InDetV0FinderTool:

Collaboration diagram for InDet::InDetV0FinderTool:

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

	~InDetV0FinderTool ()

StatusCode	initialize ()

StatusCode	finalize ()

StatusCode	performSearch (xAOD::VertexContainer v0Container, xAOD::VertexContainer ksContainer, xAOD::VertexContainer laContainer, xAOD::VertexContainer lbContainer, const xAOD::Vertex vertex, const xAOD::VertexContainer vertColl, const EventContext &ctx) const

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 > &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 const InterfaceID &	interfaceID ()

Protected Member Functions
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...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	SGError (const std::string &errService) const

bool	doFit (const xAOD::TrackParticle track1, const xAOD::TrackParticle track2, Amg::Vector3D &startingPoint, const EventContext &ctx) const

bool	d0Pass (const xAOD::TrackParticle track1, const xAOD::TrackParticle track2, const xAOD::VertexContainer *vertColl, const EventContext &ctx) const

bool	d0Pass (const xAOD::TrackParticle track1, const xAOD::TrackParticle track2, const xAOD::Vertex *vertex, const EventContext &ctx) const

bool	d0Pass (const xAOD::TrackParticle track1, const xAOD::TrackParticle track2, const Amg::Vector3D &vertex, const EventContext &ctx) const

bool	pointAtVertex (const xAOD::Vertex v0, const xAOD::Vertex PV) const

bool	pointAtVertexColl (xAOD::Vertex v0, const xAOD::VertexContainer vertColl) const

bool	doMassFit (xAOD::Vertex *vxCandidate, int pdgID) const

xAOD::Vertex *	massFit (int pdgID, const std::vector< const xAOD::TrackParticle * > &pairV0, const Amg::Vector3D &vertex) const

ElementLink< xAOD::TrackParticleContainer >	makeLink (const xAOD::TrackParticle , const std::vector< const xAOD::TrackParticleContainer > &) const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

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

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

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

Static Private Member Functions
static double	invariantMass (const Trk::TrackParameters per1, const Trk::TrackParameters per2, double m1, double m2)

Private Attributes
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trackParticleKey

ToolHandle< Trk::IVertexFitter >	m_iVertexFitter

ToolHandle< Trk::IVertexFitter >	m_iVKVertexFitter

ToolHandle< Trk::IVertexFitter >	m_iKshortFitter

ToolHandle< Trk::IVertexFitter >	m_iLambdaFitter

ToolHandle< Trk::IVertexFitter >	m_iLambdabarFitter

ToolHandle< Trk::IVertexFitter >	m_iGammaFitter

ToolHandle< Trk::V0Tools >	m_V0Tools

ToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool

ToolHandle< Trk::ITrackSelectorTool >	m_trkSelector

ToolHandle< InDet::VertexPointEstimator >	m_vertexEstimator

ToolHandle< Trk::IExtrapolator >	m_extrapolator

const HepPDT::ParticleDataTable *	m_particleDataTable

bool	m_doSimpleV0
	= true equivalent to the old InDetSimpleV0Finder (false) More...

bool	m_useorigin
	= true only using tracks that have no vertex association (true) More...

bool	m_samesign
	= true select tracks with same sign (false) More...

bool	m_pv
	= true select tracks wrt primary vertex (false) More...

bool	m_use_vertColl
	= true select tracks wrt a vertex collection (false) More...

bool	m_useTRTplusTRT
	= use TRT+TRT pairs (true) More...

bool	m_useTRTplusSi
	= use TRT+Si pairs (true) More...

bool	m_useV0Fitter
	= true if using TrkV0Fitter, = false if using VKalVert (true) More...

int	m_masses
	= 1 if using PDG values, = 2 if user set (1) More...

double	m_masspi
	pion mass (139.57 MeV) More...

double	m_massp
	proton mass (938.272 MeV) More...

double	m_masse
	electron mass (0.510999 MeV) More...

double	m_massK0S
	Kshort mass (497.672 MeV) More...

double	m_massLambda
	Lambda mass (1115.68 MeV) More...

double	m_ptTRT
	Minimum pT for TRT tracks (700. More...

double	m_maxsxy
	Maximum Rxy of starting point (1000. More...

double	m_uksmin
	min Kshort mass, unconstrained fit (400. More...

double	m_uksmax
	max Kshort mass, unconstrained fit (600. More...

double	m_ulamin
	min Lambda mass, unconstrained fit (1000. More...

double	m_ulamax
	max Lambda mass, unconstrained fit (1200. More...

double	m_ksmin
	min Kshort mass (400. More...

double	m_ksmax
	max Kshort mass (600. More...

double	m_lamin
	min Lambda mass (1000. More...

double	m_lamax
	max Lambda mass (1200. More...

double	m_errmass
	Maximum mass error (100. More...

double	m_minVertProb
	Minimum vertex probability (0.0001) More...

double	m_minConstrVertProb
	Minimum vertex probability for constrained fit (0.0001) More...

double	m_d0_cut
	track d0 significance wrt a vertex (>2.) More...

double	m_vert_lxy_sig
	V0 lxy significance wrt a vertex (>2.) More...

double	m_vert_lxy_cut
	V0 lxy V0 lxy (<500.) More...

double	m_vert_a0xy_cut
	V0 \|a0xy\| wrt a vertex (<3.) More...

double	m_vert_a0z_cut
	V0 \|a0z\| wrt a vertex (<15.) More...

std::atomic< unsigned int >	m_events_processed {}

std::atomic< unsigned int >	m_V0s_stored {}

std::atomic< unsigned int >	m_Kshort_stored {}

std::atomic< unsigned int >	m_Lambda_stored {}

std::atomic< unsigned int >	m_Lambdabar_stored {}

std::atomic< unsigned int >	m_Gamma_stored {}

const Trk::TrkV0VertexFitter *	m_concreteVertexFitter = nullptr

SG::ReadHandleKey< xAOD::VertexContainer >	m_vertexKey

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_v0LinksDecorkeyks

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_v0LinksDecorkeylb

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_v0LinksDecorkeylbb

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_v0_ksLinksDecorkey

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_v0_laLinksDecorkey

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_v0_lbLinksDecorkey

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_mDecor_gfit

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_mDecor_gmass

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_mDecor_gmasserr

SG::WriteDecorHandleKey< xAOD::VertexContainer >	m_mDecor_gprob

SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}

SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

SG::ReadDecorHandleKeyArray< xAOD::EventInfo >	m_beamSpotDecoKey {this, "BeamSpotDecoKeys" ,{}, "Add the scheduler dependencies on the beamspot information"}

Gaudi::Property< bool >	m_useBeamSpotCond { this, "UseBeamSpotCond", false }

Gaudi::Property< std::string >	m_v0Key { this, "V0ContainerName", "V0Candidates", "V0 container name (same calling alg)" }

Gaudi::Property< std::string >	m_ksKey { this, "KshortContainerName", "KshortCandidates", "Ks container name (same calling alg)" }

Gaudi::Property< std::string >	m_laKey

Gaudi::Property< std::string >	m_lbKey

Gaudi::Property< int >	m_maxPV { this, "MaxPV", 999999 }

SG::ReadHandleKeyArray< xAOD::TrackParticleContainer >	m_RelinkContainers {this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" }

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

Definition at line 99 of file InDetV0FinderTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ InDetV0FinderTool()

InDet::InDetV0FinderTool::InDetV0FinderTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 55 of file InDetV0FinderTool.cxx.

 {
   declareInterface<InDetV0FinderTool>(this);
   declareProperty("VertexFitterTool", m_iVertexFitter);
   declareProperty("VKVertexFitterTool", m_iVKVertexFitter);
   declareProperty("KshortFitterTool", m_iKshortFitter);
   declareProperty("LambdaFitterTool", m_iLambdaFitter);
   declareProperty("LambdabarFitterTool", m_iLambdabarFitter);
   declareProperty("GammaFitterTool", m_iGammaFitter);
   declareProperty("V0Tools",m_V0Tools);
   declareProperty("TrackToVertexTool",m_trackToVertexTool);
   declareProperty("TrackSelectorTool", m_trkSelector);
   declareProperty("VertexPointEstimator", m_vertexEstimator);
   declareProperty("Extrapolator", m_extrapolator);
   declareProperty("doSimpleV0", m_doSimpleV0);
   declareProperty("useorigin", m_useorigin);
   declareProperty("AddSameSign", m_samesign);
   declareProperty("trkSelPV", m_pv);
   declareProperty("useVertexCollection", m_use_vertColl);
   declareProperty("useTRTplusTRT", m_useTRTplusTRT);
   declareProperty("useTRTplusSi", m_useTRTplusSi);
   declareProperty("useV0Fitter", m_useV0Fitter);
   declareProperty("masses", m_masses);
   declareProperty("masspi", m_masspi);
   declareProperty("massp", m_massp);
   declareProperty("masse", m_masse);
   declareProperty("massK0S", m_massK0S);
   declareProperty("massLambda", m_massLambda);
   declareProperty("ptTRT", m_ptTRT);
   declareProperty("maxsxy", m_maxsxy);
   declareProperty("uksmin", m_uksmin);
   declareProperty("uksmax", m_uksmax);
   declareProperty("ulamin", m_ulamin);
   declareProperty("ulamax", m_ulamax);
   declareProperty("ksmin", m_ksmin);
   declareProperty("ksmax", m_ksmax);
   declareProperty("lamin", m_lamin);
   declareProperty("lamax", m_lamax);
   declareProperty("errmass", m_errmass);
   declareProperty("minVertProb", m_minVertProb);
   declareProperty("minConstrVertProb", m_minConstrVertProb);
   declareProperty("d0_cut", m_d0_cut );
   declareProperty("vert_lxy_sig", m_vert_lxy_sig );
   declareProperty("vert_lxy_cut", m_vert_lxy_cut );
   declareProperty("vert_a0xy_cut", m_vert_a0xy_cut );
   declareProperty("vert_a0z_cut", m_vert_a0z_cut );
  
   declareProperty("V0Linkks", m_v0LinksDecorkeyks);
   declareProperty("V0Linklb", m_v0LinksDecorkeylb);
   declareProperty("V0Linklbb", m_v0LinksDecorkeylbb);
   declareProperty("KshortLink", m_v0_ksLinksDecorkey);
   declareProperty("LambdaLink", m_v0_laLinksDecorkey);
   declareProperty("LambdabarLink", m_v0_lbLinksDecorkey);
  
   declareProperty("gamma_fit", m_mDecor_gfit);
   declareProperty("gamma_mass", m_mDecor_gmass);
   declareProperty("gamma_massError", m_mDecor_gmasserr);
   declareProperty("gamma_probability", m_mDecor_gprob);  
 }
  
 InDetV0FinderTool::~InDetV0FinderTool() = default;
  
 StatusCode InDetV0FinderTool::initialize()
 {
   ATH_CHECK( m_trackParticleKey.initialize() );
  
   // Get the right vertex fitting tool from ToolSvc
   if (m_useV0Fitter) {
     ATH_CHECK( m_iVertexFitter.retrieve() );
     ATH_MSG_DEBUG( "Retrieved tool " << m_iVertexFitter);

◆ ~InDetV0FinderTool()

InDet::InDetV0FinderTool::~InDetV0FinderTool ( )

default

Member Function Documentation

◆ d0Pass() [1/3]

bool InDet::InDetV0FinderTool::d0Pass	(	const xAOD::TrackParticle *	track1,
		const xAOD::TrackParticle *	track2,
		const Amg::Vector3D &	vertex,
		const EventContext &	ctx
	)		const

private

Definition at line 776 of file InDetV0FinderTool.cxx.

 {
   bool pass = false;
   double v0lxy = m_V0Tools->lxy(v0,PV);
   double v0lxyError = m_V0Tools->lxyError(v0,PV);
   double cos = m_V0Tools->cosTheta(v0,PV);
   double v0a0xy = m_V0Tools->a0xy(v0,PV);
   double v0a0z = m_V0Tools->a0z(v0,PV);
   if (v0lxy/v0lxyError > m_vert_lxy_sig && cos > 0. &&
       std::abs(v0a0xy) < m_vert_a0xy_cut && std::abs(v0a0z) < m_vert_a0z_cut &&

◆ d0Pass() [2/3]

bool InDet::InDetV0FinderTool::d0Pass	(	const xAOD::TrackParticle *	track1,
		const xAOD::TrackParticle *	track2,
		const xAOD::Vertex *	vertex,
		const EventContext &	ctx
	)		const

private

Definition at line 758 of file InDetV0FinderTool.cxx.

 {
   bool pass = false;
   auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV );
   if (per1 == nullptr) return pass;
   auto per2 = m_trackToVertexTool->perigeeAtVertex(ctx, *track2, PV );
   if (per2 == nullptr) {
     return pass;
   }
   double d0_1 = per1->parameters()[Trk::d0];

◆ d0Pass() [3/3]

bool InDet::InDetV0FinderTool::d0Pass	(	const xAOD::TrackParticle *	track1,
		const xAOD::TrackParticle *	track2,
		const xAOD::VertexContainer *	vertColl,
		const EventContext &	ctx
	)		const

private

Definition at line 736 of file InDetV0FinderTool.cxx.

 {
   bool pass = false;
   auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV->position() );
   if (per1 == nullptr) return pass;
   auto per2 = m_trackToVertexTool->perigeeAtVertex(ctx, *track2, PV->position() );
   if (per2 == nullptr) {
     return pass;
   }
   double d0_1 = per1->parameters()[Trk::d0];

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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 > &	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 > &	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 > &	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 > & 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; }

◆ doFit()

bool InDet::InDetV0FinderTool::doFit	(	const xAOD::TrackParticle *	track1,
		const xAOD::TrackParticle *	track2,
		Amg::Vector3D &	startingPoint,
		const EventContext &	ctx
	)		const

private

Definition at line 702 of file InDetV0FinderTool.cxx.

                                                                             {
       massKshort_i = invariantMass(extrapolatedPerigee1,extrapolatedPerigee2,m_masspi,m_masspi);
       massLambda_i = invariantMass(extrapolatedPerigee1,extrapolatedPerigee2,m_massp,m_masspi);
       massLambdabar_i = invariantMass(extrapolatedPerigee1,extrapolatedPerigee2,m_masspi,m_massp);
       if ( ((massKshort_i >= m_uksmin && massKshort_i <= m_uksmax) ||
             (massLambda_i >= m_ulamin && massLambda_i <= m_ulamax) ||
             (massLambdabar_i >= m_ulamin && massLambdabar_i <= m_ulamax)) ) pass = true;
     }
   }
  
   return pass;
 }
  
 bool InDetV0FinderTool::d0Pass(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2, const xAOD::VertexContainer * vertColl, const EventContext& ctx) const
 {
   bool pass = false;
   int count = 0;
   for (auto vItr=vertColl->begin(); vItr!=vertColl->end(); ++vItr )
   {
     const xAOD::Vertex* PV = (*vItr);
     auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV->position() );
     if (per1 == nullptr) continue;
     auto per2 = m_trackToVertexTool->perigeeAtVertex(ctx, *track2, PV->position() );

◆ doMassFit()

bool InDet::InDetV0FinderTool::doMassFit	(	xAOD::Vertex *	vxCandidate,
		int	pdgID
	)		const

private

Definition at line 827 of file InDetV0FinderTool.cxx.

                                               {
     winmass_min = m_lamin;
     winmass_max = m_lamax;
     if (pdgID == 3122) {
       mass = m_V0Tools->invariantMass(vxCandidate,m_massp,m_masspi);
       error = m_V0Tools->invariantMassError(vxCandidate,m_massp,m_masspi);
     } else if (pdgID == -3122) {
       mass = m_V0Tools->invariantMass(vxCandidate,m_masspi,m_massp);
       error = m_V0Tools->invariantMassError(vxCandidate,m_masspi,m_massp);
     }
     if (mass >= winmass_min && mass <= winmass_max && error <= m_errmass) in_mass_window = true;
   }
   if (in_mass_window) pass = true;
  
   return pass;
 }
  
 xAOD::Vertex* InDetV0FinderTool::massFit(int pdgID, const std::vector<const xAOD::TrackParticle*> &pairV0, const Amg::Vector3D &vertex) const
 {
   xAOD::Vertex* vxCandidate(nullptr);
   std::vector<double> masses;
   if (pdgID == 310) {
     masses.push_back(m_masspi);
     masses.push_back(m_masspi);
   } else if (pdgID == 3122) {
     masses.push_back(m_massp);
     masses.push_back(m_masspi);

◆ 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 InDet::InDetV0FinderTool::finalize ( )

Definition at line 681 of file InDetV0FinderTool.cxx.

 {
   ATH_MSG_FATAL(errService << " not found. Exiting !");
 }
  
  
 bool InDetV0FinderTool::doFit(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2,
                                  Amg::Vector3D &startingPoint, const EventContext& ctx) const
 {
   bool pass = false;

◆ initialize()

StatusCode InDet::InDetV0FinderTool::initialize ( )

Definition at line 163 of file InDetV0FinderTool.cxx.

                         {
     for (const std::string beam : {"beamPosX", "beamPosY", "beamPosZ"}) {
         m_beamSpotDecoKey.emplace_back(m_eventInfo_key.key() + "."+beam);
     }
   }
   ATH_CHECK( m_beamSpotDecoKey.initialize(!m_useBeamSpotCond));
  
 // Get the track selector tool from ToolSvc
   ATH_CHECK( m_trkSelector.retrieve() );
   ATH_MSG_DEBUG("Retrieved tool " << m_trkSelector);
  
 // Get the vertex point estimator tool from ToolSvc
   ATH_CHECK( m_vertexEstimator.retrieve() );
   ATH_MSG_DEBUG("Retrieved tool " << m_vertexEstimator);
  
   const HepPDT::ParticleData* pd_pi = m_particleDataTable->particle(MC::PIPLUS);
   const HepPDT::ParticleData* pd_p  = m_particleDataTable->particle(MC::PROTON);
   const HepPDT::ParticleData* pd_e  = m_particleDataTable->particle(MC::ELECTRON);
   const HepPDT::ParticleData* pd_K  = m_particleDataTable->particle(MC::K0S);
   const HepPDT::ParticleData* pd_L  = m_particleDataTable->particle(MC::LAMBDA0);
   if (m_masses == 1) {
    m_masspi     = pd_pi->mass();
    m_massp      = pd_p->mass();
    m_masse      = pd_e->mass();
    m_massK0S    = pd_K->mass();
    m_massLambda = pd_L->mass();
   }
  
   m_events_processed = 0;
   m_V0s_stored       = 0;
   m_Kshort_stored    = 0;
   m_Lambdabar_stored = 0;
   m_Lambda_stored    = 0;
   m_Gamma_stored     = 0;
  
 // making a concrete fitter for the V0Fitter
   m_concreteVertexFitter = nullptr;
   if (m_useV0Fitter) {
     m_concreteVertexFitter = dynamic_cast<Trk::TrkV0VertexFitter * >(&(*m_iVertexFitter));
     if (m_concreteVertexFitter == nullptr) {
       ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
       return StatusCode::FAILURE;
     }
   }
  
   ATH_CHECK(m_RelinkContainers.initialize());
  
   ATH_MSG_DEBUG( "Initialization successful" );
  
   return StatusCode::SUCCESS;
 }
  
 StatusCode InDetV0FinderTool::performSearch(xAOD::VertexContainer* v0Container,
                                             xAOD::VertexContainer* ksContainer,
                                             xAOD::VertexContainer* laContainer,
                                             xAOD::VertexContainer* lbContainer,
                                             const xAOD::Vertex* primaryVertex,
                         const xAOD::VertexContainer* vertColl,
                                             const EventContext& ctx
                         ) const
 {
  

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

◆ interfaceID()

static const InterfaceID& InDet::InDetV0FinderTool::interfaceID ( )

inlinestatic

Definition at line 107 of file InDetV0FinderTool.h.

107 { return IID_InDetV0FinderTool;}

◆ invariantMass()

double InDet::InDetV0FinderTool::invariantMass	(	const Trk::TrackParameters *	per1,
		const Trk::TrackParameters *	per2,
		double	m1,
		double	m2
	)

staticprivate

Definition at line 815 of file InDetV0FinderTool.cxx.

 {
   bool pass = false;
   double mass = 1000000000.;
   double error = 1000000001.;
   bool in_mass_window = false;
   double winmass_min = 0., winmass_max = 0.;
  
   if (pdgID == 310) {
     winmass_min = m_ksmin;

◆ makeLink()

ElementLink< xAOD::TrackParticleContainer > InDet::InDetV0FinderTool::makeLink	(	const xAOD::TrackParticle *	tp,
		const std::vector< const xAOD::TrackParticleContainer * > &	trackcols
	)		const

private

Definition at line 904 of file InDetV0FinderTool.cxx.

                                   {
             Link.setStorableObject(*trkcol, true);
             elementSet = true;
             break;
           }
       }
     }
     if(!elementSet) ATH_MSG_ERROR("Track was not found when linking");
     return Link;
 }
  
  
 }//end of namespace InDet
  

◆ massFit()

xAOD::Vertex * InDet::InDetV0FinderTool::massFit	(	int	pdgID,
		const std::vector< const xAOD::TrackParticle * > &	pairV0,
		const Amg::Vector3D &	vertex
	)		const

private

Definition at line 858 of file InDetV0FinderTool.cxx.

                           {
     masses.push_back(m_masse);
     masses.push_back(m_masse);
   }
  
   if (pdgID == 22) {
     vxCandidate = m_iGammaFitter->fit(pairV0, vertex);
   }
   if (pdgID ==   310) {
     if (m_useV0Fitter) {
       vxCandidate = m_concreteVertexFitter->fit(pairV0, masses, m_massK0S, nullptr, vertex);
     } else {
       vxCandidate = m_iKshortFitter->fit(pairV0, vertex);
     }
   }
   if (pdgID ==  3122) {
     if (m_useV0Fitter) {
       vxCandidate = m_concreteVertexFitter->fit(pairV0, masses, m_massLambda, nullptr, vertex);
     } else {
       vxCandidate = m_iLambdaFitter->fit(pairV0, vertex);
     }
   }
   if (pdgID == -3122) {
     if (m_useV0Fitter) {
       vxCandidate = m_concreteVertexFitter->fit(pairV0, masses, m_massLambda, nullptr, vertex);
     } else {
       vxCandidate = m_iLambdabarFitter->fit(pairV0, vertex);
     }
   }
  
   return vxCandidate;
 }
  
 ElementLink<xAOD::TrackParticleContainer> InDetV0FinderTool::makeLink(const xAOD::TrackParticle* tp,
           const std::vector<const xAOD::TrackParticleContainer*>& trackcols) const 
 {
     ElementLink<xAOD::TrackParticleContainer> Link;
     Link.setElement(tp);
     bool elementSet = false;
     if(trackcols.empty()){
        Link.setStorableObject( *dynamic_cast<const xAOD::TrackParticleContainer*>( tp->container()  ) );
        elementSet = true;
     } else {

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

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

◆ performSearch()

StatusCode InDet::InDetV0FinderTool::performSearch	(	xAOD::VertexContainer *	v0Container,
		xAOD::VertexContainer *	ksContainer,
		xAOD::VertexContainer *	laContainer,
		xAOD::VertexContainer *	lbContainer,
		const xAOD::Vertex *	vertex,
		const xAOD::VertexContainer *	vertColl,
		const EventContext &	ctx
	)		const

Definition at line 290 of file InDetV0FinderTool.cxx.

                       : m_RelinkContainers){
     SG::ReadHandle<xAOD::TrackParticleContainer> handle(str,ctx);
     trackCols.push_back(handle.cptr());
   }
  
   m_events_processed ++;
  
 // Retrieve track particles from StoreGate
   SG::ReadHandle<xAOD::TrackParticleContainer> TPC( m_trackParticleKey, ctx );
   if ( !TPC.isValid() )
   {
       ATH_MSG_ERROR("Input TrackParticle collection is invalid!");
       return StatusCode::SUCCESS;
   }
   ATH_MSG_DEBUG("Track particle container size " <<  TPC->size());
  
   if (m_use_vertColl) {
     ATH_MSG_DEBUG("Vertex  container size " << vertColl->size());
   }
   Amg::Vector3D beamspot;
   if(m_useBeamSpotCond){
      auto beamSpotHandle = SG::ReadCondHandle(m_beamSpotKey, ctx);
      beamspot = beamSpotHandle->beamPos();
   }else{
      SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosX(m_beamSpotDecoKey[0], ctx);
      SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosY(m_beamSpotDecoKey[1], ctx);
      SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosZ(m_beamSpotDecoKey[2], ctx);
      beamspot = Amg::Vector3D(beamPosX(0), beamPosY(0), beamPosZ(0));
   }
 // track preselection
   std::vector<const xAOD::TrackParticle*> posTracks; posTracks.clear();
   std::vector<const xAOD::TrackParticle*> negTracks; negTracks.clear();
   const xAOD::Vertex* vx = nullptr;
   if (m_pv && primaryVertex) vx = primaryVertex;
  
   if (TPC->size() > 1) {
     xAOD::TrackParticleContainer::const_iterator tpIt;
     for ( tpIt=TPC->begin(); tpIt!=TPC->end(); ++tpIt )
     {
       const xAOD::TrackParticle* TP = (*tpIt);
       double charge = TP->charge();
  
       if (m_trkSelector->decision(*TP, vx))
       {
         if (m_samesign) {
           posTracks.push_back(TP);
           negTracks.push_back(TP);
         } else {
           if (charge > 0) {
             posTracks.push_back(*tpIt);
           } else {
             negTracks.push_back(*tpIt);
           }
         }
       }
     }
   }
   ATH_MSG_DEBUG("number of tracks passing preselection, positive " << posTracks.size() << " negative " << negTracks.size());
  
   if (!posTracks.empty() && !negTracks.empty())
   {
   SG::ReadHandle<xAOD::VertexContainer> vertices { m_vertexKey, ctx };
   if (!vertices.isValid())
   {
     ATH_MSG_WARNING("Primary vertex container with key " << m_vertexKey.key() << " not found");
     return StatusCode::SUCCESS;
   }
  
   SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0LinksDecorks(m_v0LinksDecorkeyks, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0LinksDecorlb(m_v0LinksDecorkeylb, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0LinksDecorlbb(m_v0LinksDecorkeylbb, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0_ksLinksDecor(m_v0_ksLinksDecorkey, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0_laLinksDecor(m_v0_laLinksDecorkey, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0_lbLinksDecor(m_v0_lbLinksDecorkey, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, int> mDecor_gfit(m_mDecor_gfit, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, float> mDecor_gmass(m_mDecor_gmass, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, float> mDecor_gmasserr(m_mDecor_gmasserr, ctx);
   SG::WriteDecorHandle<xAOD::VertexContainer, float> mDecor_gprob(m_mDecor_gprob, ctx);
  
   std::vector<const xAOD::TrackParticle*>::const_iterator tpIt1;
   std::vector<const xAOD::TrackParticle*>::const_iterator tpIt2;
   unsigned int i1 = 0;
   for (tpIt1 = posTracks.begin(); tpIt1 != posTracks.end(); ++tpIt1)
   {
     const xAOD::TrackParticle* TP1 = (*tpIt1);
     uint8_t temp1(0);
     uint8_t nclus1(0);
     if ( TP1->summaryValue( temp1 , xAOD::numberOfPixelHits) ) nclus1 += temp1;
     if ( TP1->summaryValue( temp1 , xAOD::numberOfSCTHits)   ) nclus1 += temp1; 
     double pt1 = TP1->pt();
  
     const xAOD::Vertex* foundVertex1 { nullptr };
     if (m_useorigin)
     {
       for (const auto *const vx : *vertices)
       {
     for (const auto& tpLink : vx->trackParticleLinks())
     {
       if (*tpLink == TP1)
       {
         foundVertex1 = vx;
         break;
       }
     }
     if (foundVertex1) break;
       }
     }
     unsigned int i2 = 0;
     for (tpIt2 = negTracks.begin(); tpIt2 != negTracks.end(); ++tpIt2)
     {
       if (*tpIt1 == *tpIt2) continue;
       if (m_samesign && i1 <= i2) continue;
  
       const xAOD::TrackParticle* TP2 = (*tpIt2);
       uint8_t temp2(0);
       uint8_t nclus2(0);
       if ( TP2->summaryValue( temp2 , xAOD::numberOfPixelHits) ) nclus2 += temp2;
       if ( TP2->summaryValue( temp2 , xAOD::numberOfSCTHits)   ) nclus2 += temp2; 
       ATH_MSG_DEBUG("nclus1 " << (int)nclus1 << " nclus2 " << (int)nclus2);
  
       if (!m_useTRTplusTRT && nclus1 == 0 && nclus2 == 0) continue;
       if (!m_useTRTplusSi && (nclus1 == 0 || nclus2 == 0)) continue;
  
       double pt2 = TP2->pt();
  
       const xAOD::Vertex* foundVertex2 { nullptr };
       if (m_useorigin)
       {
     for (const auto *const vx : *vertices)
     {
       for (const auto& tpLink : vx->trackParticleLinks())
       {
         if (*tpLink == TP2)
         {
           foundVertex2 = vx;
           break;
         }
       }
       if (foundVertex2) break;
     }
       }
       bool usepair = false;
       if (!m_useorigin) usepair = true;
       if (m_useorigin && foundVertex1 == nullptr && foundVertex2 == nullptr) usepair = true;
       if (!usepair) continue;
  
       bool trk_cut1 = false;
       bool trk_cut2 = false;
       if (nclus1 != 0) trk_cut1 = true;
       if (nclus1 == 0 && pt1 >= m_ptTRT) trk_cut1 = true;
       if (!trk_cut1) continue;      
       if (nclus2 != 0) trk_cut2 = true;
       if (nclus2 == 0 && pt2 >= m_ptTRT) trk_cut2 = true;
       if (!trk_cut2) continue;      
  
 // find a starting point
       const Trk::Perigee& aPerigee1 = TP1->perigeeParameters();
       const Trk::Perigee& aPerigee2 = TP2->perigeeParameters();
       int sflag = 0;
       int errorcode = 0;
       Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
       if (errorcode != 0) {startingPoint(0) = 0.0; startingPoint(1) = 0.0; startingPoint(2) = 0.0;}
       bool errorCode = false;
       if (errorcode == 0 || errorcode == 5 || errorcode == 6 || errorcode == 8) errorCode = true;
       if (!errorCode) continue;
  
       bool d0wrtVertex = true;
       if (m_use_vertColl) {
         if ( !d0Pass(TP1,TP2,vertColl, ctx) ) d0wrtVertex = false;
       }
       if (!m_use_vertColl && m_pv) {
         if (primaryVertex) {
           if ( !d0Pass(TP1,TP2,primaryVertex, ctx) ) d0wrtVertex = false;
         } else {
           if ( !d0Pass(TP1,TP2,beamspot, ctx) ) d0wrtVertex = false;
         }
       }
       if (!d0wrtVertex) continue;
  
  
 // pair pre-selection cuts
           if ( doFit(TP1,TP2,startingPoint, ctx) )
           {
             std::vector<const xAOD::TrackParticle*> pairV0;
             pairV0.clear();
             pairV0.push_back(TP1);
             pairV0.push_back(TP2);
  
 // vertex fit
             ATH_MSG_DEBUG("unconstrained fit now");
  
             std::unique_ptr<xAOD::Vertex> myVxCandidate;
             if (m_useV0Fitter) {
               myVxCandidate = std::unique_ptr<xAOD::Vertex>( m_concreteVertexFitter->fit(pairV0, startingPoint) );
             } else {
               myVxCandidate = std::unique_ptr<xAOD::Vertex>(  m_iVKVertexFitter->fit(pairV0, startingPoint) );
             }
       
               if (myVxCandidate)
               {
                 myVxCandidate->setVertexType(xAOD::VxType::V0Vtx);
                 if ( m_V0Tools->vertexProbability(myVxCandidate.get()) >= m_minVertProb )
                 {
                   bool doKshortFit = false;
                   doKshortFit = doMassFit(myVxCandidate.get(),310);
                   bool doLambdaFit = false;
                   doLambdaFit = doMassFit(myVxCandidate.get(),3122);
                   bool doLambdabarFit = false;
                   doLambdabarFit = doMassFit(myVxCandidate.get(),-3122);
                   if (doKshortFit || doLambdaFit || doLambdabarFit)
                   {
                     bool pointAtVert = true;
                     if (m_use_vertColl) {
                       if ( !pointAtVertexColl(myVxCandidate.get(),vertColl) ) pointAtVert = false;
                     }
                     if (!m_use_vertColl && m_pv && primaryVertex) {
                       if ( !pointAtVertex(myVxCandidate.get(),primaryVertex) ) pointAtVert = false;
                     }
                     if (m_doSimpleV0) pointAtVert = true;
                     if (pointAtVert)
                     {
                       Amg::Vector3D vertex = m_V0Tools->vtx(myVxCandidate.get());
  
                       std::unique_ptr<xAOD::Vertex> myKshort;
                       std::unique_ptr<xAOD::Vertex> myLambda;
                       std::unique_ptr<xAOD::Vertex> myLambdabar;
               std::unique_ptr<xAOD::Vertex> myGamma;
                       bool foundKshort = false;
                       bool foundLambda = false;
                       bool foundLambdabar = false;
  
                       if (doKshortFit && !m_doSimpleV0) {
                         myKshort = std::unique_ptr<xAOD::Vertex>( massFit(310, pairV0, vertex) );
                         if (myKshort) {
                           if (m_V0Tools->vertexProbability(myKshort.get()) >= m_minConstrVertProb) {
                             myKshort->setVertexType(xAOD::VxType::V0Vtx);
                             foundKshort = true;
                           }
                         }
                       }
  
                       if (doLambdaFit && !m_doSimpleV0) {
                         myLambda = std::unique_ptr<xAOD::Vertex>( massFit(3122, pairV0, vertex) );
                         if (myLambda) {
                           if (m_V0Tools->vertexProbability(myLambda.get()) >= m_minConstrVertProb) {
                             myLambda->setVertexType(xAOD::VxType::V0Vtx);
                             foundLambda = true;
                           }
                         }
                       }
  
                       if (doLambdabarFit && !m_doSimpleV0) {
                         myLambdabar = std::unique_ptr<xAOD::Vertex>( massFit(-3122, pairV0, vertex));
                         if (myLambdabar) {
                           if (m_V0Tools->vertexProbability(myLambdabar.get()) >= m_minConstrVertProb) {
                             myLambdabar->setVertexType(xAOD::VxType::V0Vtx);
                             foundLambdabar = true;
                           }
                         }
                       }
  
                       bool doGamma = false;
                       int gamma_fit = 0;
                       double gamma_prob = -1., gamma_mass = -1., gamma_massErr = -1.;
                       if (foundKshort || foundLambda || foundLambdabar) doGamma = true;
  
                       ElementLink<xAOD::VertexContainer> v0Link;
                       ElementLink<xAOD::VertexContainer> ksLink;
                       ElementLink<xAOD::VertexContainer> laLink;
                       ElementLink<xAOD::VertexContainer> lbLink;
  
                       if (m_doSimpleV0 || (!m_doSimpleV0 && doGamma)) {
                         m_V0s_stored++;
                         myVxCandidate->clearTracks();
                         ElementLink<xAOD::TrackParticleContainer> newLink1 = makeLink(*tpIt1, trackCols);
                         ElementLink<xAOD::TrackParticleContainer> newLink2 = makeLink(*tpIt2, trackCols);
                         myVxCandidate->addTrackAtVertex(newLink1);
                         myVxCandidate->addTrackAtVertex(newLink2);
                         v0Container->push_back(myVxCandidate.release());
  
                         if (foundKshort && !m_doSimpleV0) {
                           m_Kshort_stored++;
                           myKshort->clearTracks();
                           ElementLink<xAOD::TrackParticleContainer> ksLink1 = makeLink(*tpIt1, trackCols);
                           ElementLink<xAOD::TrackParticleContainer> ksLink2 = makeLink(*tpIt2, trackCols);
                           myKshort->addTrackAtVertex(ksLink1);
                           myKshort->addTrackAtVertex(ksLink2);
                           ksContainer->push_back(myKshort.release());
  
                           v0Link.setElement(v0Container->back());
                           v0Link.setStorableObject(*v0Container);
                           v0LinksDecorks(*(ksContainer->back())) = v0Link;
  
                           ksLink.setElement(ksContainer->back());
                           ksLink.setStorableObject(*ksContainer);
                           v0_ksLinksDecor(*(v0Container->back())) = ksLink;
                         } else {
                           v0_ksLinksDecor(*(v0Container->back())) = ksLink;
                         }
                         if (foundLambda && !m_doSimpleV0) {
                           m_Lambda_stored++;
                           myLambda->clearTracks();
                           ElementLink<xAOD::TrackParticleContainer> laLink1 = makeLink(*tpIt1, trackCols);
                           ElementLink<xAOD::TrackParticleContainer> laLink2 = makeLink(*tpIt2, trackCols);
                           myLambda->addTrackAtVertex(laLink1);
                           myLambda->addTrackAtVertex(laLink2);
                           laContainer->push_back(myLambda.release());
  
                           v0Link.setElement(v0Container->back());
                           v0Link.setStorableObject(*v0Container);
                           v0LinksDecorlb(*(laContainer->back())) = v0Link;
  
                           laLink.setElement(laContainer->back());
                           laLink.setStorableObject(*laContainer);
                           v0_laLinksDecor(*(v0Container->back())) = laLink;
                         } else {
                           v0_laLinksDecor(*(v0Container->back())) = laLink;
                         }
                         if (foundLambdabar && !m_doSimpleV0) {
                           m_Lambdabar_stored++;
                           myLambdabar->clearTracks();
                           ElementLink<xAOD::TrackParticleContainer> lbLink1 = makeLink(*tpIt1, trackCols);
                           ElementLink<xAOD::TrackParticleContainer> lbLink2 = makeLink(*tpIt2, trackCols);
                           myLambdabar->addTrackAtVertex(lbLink1);
                           myLambdabar->addTrackAtVertex(lbLink2);
                           lbContainer->push_back(myLambdabar.release());
  
                           v0Link.setElement(v0Container->back());
                           v0Link.setStorableObject(*v0Container);
                           v0LinksDecorlbb(*(lbContainer->back())) = v0Link;
  
                           lbLink.setElement(lbContainer->back());
                           lbLink.setStorableObject(*lbContainer);
                           v0_lbLinksDecor(*(v0Container->back())) = lbLink;
                         } else {
                           v0_lbLinksDecor(*(v0Container->back())) = lbLink;
                         }
                         if (doGamma && !m_doSimpleV0) {
                   myGamma = std::unique_ptr<xAOD::Vertex>( massFit(22, pairV0, vertex) );
                           if (myGamma && m_V0Tools->vertexProbability(myGamma.get()) >= m_minConstrVertProb) {
                             gamma_fit = 1;
                             gamma_prob = m_V0Tools->vertexProbability(myGamma.get());
                             gamma_mass = m_V0Tools->invariantMass(myGamma.get(),m_masse,m_masse);
                             gamma_massErr = m_V0Tools->invariantMassError(myGamma.get(),m_masse,m_masse);
                           }
  
                           mDecor_gfit( *(v0Container->back()) ) = gamma_fit;
                           mDecor_gmass( *(v0Container->back()) ) = gamma_mass;
                           mDecor_gmasserr( *(v0Container->back()) ) = gamma_massErr;
                           mDecor_gprob( *(v0Container->back()) ) = gamma_prob;
                         }
                       }
  
                     } // pointAtVert
  
                   } // in mass window (doMassFit)
  
                 } // chi2 cut failed
               } else { // unconstrained fit failed
                 ATH_MSG_DEBUG("Fitter failed!");
               }
  
           }  // doFit
  
       i2++;
     }  // loop over negative tracks
     i1++;
   }  // loop over positive tracks
  
   }  // posTracks.size() > 0 && negTracks.size() > 0
  
   if (v0Container->empty()) ATH_MSG_DEBUG("No Candidates found. Empty container returned");
   if (ksContainer->empty()) ATH_MSG_DEBUG("No Kshort Candidates found. Empty container returned");
   if (laContainer->empty()) ATH_MSG_DEBUG("No Lambda Candidates found. Empty container returned");
   if (lbContainer->empty()) ATH_MSG_DEBUG("No Lambdabar Candidates found. Empty container returned");
  
   return StatusCode::SUCCESS;
 }
  
 StatusCode InDetV0FinderTool::finalize()
 {
   msg(MSG::DEBUG)
     << "----------------------------------------------------------------------------------------------------------------------------------------------" << endmsg
     << "\tSummary" << endmsg 
     << "\tProcessed              : " << m_events_processed            << " events" << endmsg
     << "\tStored                 : " << m_V0s_stored                  << " V0s" << endmsg
     << "\tof which               : " << m_Kshort_stored               << " Kshorts" << endmsg
     << "\t                       : " << m_Lambda_stored               << " Lambdas" << endmsg
     << "\t                       : " << m_Lambdabar_stored            << " Lambdabars" << endmsg;

◆ pointAtVertex()

bool InDet::InDetV0FinderTool::pointAtVertex	(	const xAOD::Vertex *	v0,
		const xAOD::Vertex *	PV
	)		const

private

Definition at line 793 of file InDetV0FinderTool.cxx.

 {
   bool pass = false;
   xAOD::VertexContainer::const_iterator vItr = vertColl->begin();
   for ( vItr=vertColl->begin(); vItr!=vertColl->end(); ++vItr ) { if (pointAtVertex(v0,(*vItr))) return true; }
   return pass;
 }
  
 double InDetV0FinderTool::invariantMass(const Trk::TrackParameters* per1, const Trk::TrackParameters* per2, double m1, double m2) 
 {

◆ pointAtVertexColl()

bool InDet::InDetV0FinderTool::pointAtVertexColl	(	xAOD::Vertex *	v0,
		const xAOD::VertexContainer *	vertColl
	)		const

private

Definition at line 807 of file InDetV0FinderTool.cxx.

                                      : 0.;
   double e2sq = per2->momentum().mag2() + m2*m2;
   double e2 = (e2sq>0.) ? sqrt(e2sq) : 0.;
   double p = (per1->momentum()+per2->momentum()).mag();
   double msq = (e1+e2+p)*(e1+e2-p);
   double mass = (msq>0.) ? sqrt(msq) : 0.;
   return mass;

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

◆ SGError()

void InDet::InDetV0FinderTool::SGError ( const std::string & errService ) const

private

Definition at line 696 of file InDetV0FinderTool.cxx.

   {
     double massKshort_i=2000001., massLambda_i=2000001., massLambdabar_i=2000001.;
     const Amg::Vector3D& globalPosition = startingPoint;

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

Member Data Documentation

◆ m_beamSpotDecoKey

SG::ReadDecorHandleKeyArray<xAOD::EventInfo> InDet::InDetV0FinderTool::m_beamSpotDecoKey {this, "BeamSpotDecoKeys" ,{}, "Add the scheduler dependencies on the beamspot information"}

private

Definition at line 212 of file InDetV0FinderTool.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> InDet::InDetV0FinderTool::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }

private

Definition at line 211 of file InDetV0FinderTool.h.

◆ m_concreteVertexFitter

const Trk::TrkV0VertexFitter* InDet::InDetV0FinderTool::m_concreteVertexFitter = nullptr

private

Definition at line 194 of file InDetV0FinderTool.h.

◆ m_d0_cut

double InDet::InDetV0FinderTool::m_d0_cut

private

track d0 significance wrt a vertex (>2.)

Definition at line 163 of file InDetV0FinderTool.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_doSimpleV0

bool InDet::InDetV0FinderTool::m_doSimpleV0

private

= true equivalent to the old InDetSimpleV0Finder (false)

Definition at line 136 of file InDetV0FinderTool.h.

◆ m_errmass

double InDet::InDetV0FinderTool::m_errmass

private

Maximum mass error (100.

MeV)

Definition at line 160 of file InDetV0FinderTool.h.

◆ m_eventInfo_key

SG::ReadHandleKey<xAOD::EventInfo> InDet::InDetV0FinderTool::m_eventInfo_key {this, "EventInfo", "EventInfo", "Input event information"}

private

Definition at line 210 of file InDetV0FinderTool.h.

◆ m_events_processed

std::atomic<unsigned int> InDet::InDetV0FinderTool::m_events_processed {}

mutableprivate

Definition at line 169 of file InDetV0FinderTool.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_extrapolator

ToolHandle< Trk::IExtrapolator > InDet::InDetV0FinderTool::m_extrapolator

private

Definition at line 132 of file InDetV0FinderTool.h.

◆ m_Gamma_stored

std::atomic<unsigned int> InDet::InDetV0FinderTool::m_Gamma_stored {}

mutableprivate

Definition at line 174 of file InDetV0FinderTool.h.

◆ m_iGammaFitter

ToolHandle< Trk::IVertexFitter > InDet::InDetV0FinderTool::m_iGammaFitter

private

Definition at line 127 of file InDetV0FinderTool.h.

◆ m_iKshortFitter

ToolHandle< Trk::IVertexFitter > InDet::InDetV0FinderTool::m_iKshortFitter

private

Definition at line 124 of file InDetV0FinderTool.h.

◆ m_iLambdabarFitter

ToolHandle< Trk::IVertexFitter > InDet::InDetV0FinderTool::m_iLambdabarFitter

private

Definition at line 126 of file InDetV0FinderTool.h.

◆ m_iLambdaFitter

ToolHandle< Trk::IVertexFitter > InDet::InDetV0FinderTool::m_iLambdaFitter

private

Definition at line 125 of file InDetV0FinderTool.h.

◆ m_iVertexFitter

ToolHandle< Trk::IVertexFitter > InDet::InDetV0FinderTool::m_iVertexFitter

private

Definition at line 122 of file InDetV0FinderTool.h.

◆ m_iVKVertexFitter

ToolHandle< Trk::IVertexFitter > InDet::InDetV0FinderTool::m_iVKVertexFitter

private

Definition at line 123 of file InDetV0FinderTool.h.

◆ m_Kshort_stored

std::atomic<unsigned int> InDet::InDetV0FinderTool::m_Kshort_stored {}

mutableprivate

Definition at line 171 of file InDetV0FinderTool.h.

◆ m_ksKey

Gaudi::Property<std::string> InDet::InDetV0FinderTool::m_ksKey { this, "KshortContainerName", "KshortCandidates", "Ks container name (same calling alg)" }

private

Definition at line 216 of file InDetV0FinderTool.h.

◆ m_ksmax

double InDet::InDetV0FinderTool::m_ksmax

private

max Kshort mass (600.

MeV)

Definition at line 157 of file InDetV0FinderTool.h.

◆ m_ksmin

double InDet::InDetV0FinderTool::m_ksmin

private

min Kshort mass (400.

MeV)

Definition at line 156 of file InDetV0FinderTool.h.

◆ m_laKey

Gaudi::Property<std::string> InDet::InDetV0FinderTool::m_laKey

private

Initial value:

{ this, "LambdaContainerName", "LambdaCandidates",

"Lambda container name (same calling alg)" }

Definition at line 217 of file InDetV0FinderTool.h.

◆ m_lamax

double InDet::InDetV0FinderTool::m_lamax

private

max Lambda mass (1200.

MeV)

Definition at line 159 of file InDetV0FinderTool.h.

◆ m_Lambda_stored

std::atomic<unsigned int> InDet::InDetV0FinderTool::m_Lambda_stored {}

mutableprivate

Definition at line 172 of file InDetV0FinderTool.h.

◆ m_Lambdabar_stored

std::atomic<unsigned int> InDet::InDetV0FinderTool::m_Lambdabar_stored {}

mutableprivate

Definition at line 173 of file InDetV0FinderTool.h.

◆ m_lamin

double InDet::InDetV0FinderTool::m_lamin

private

min Lambda mass (1000.

MeV)

Definition at line 158 of file InDetV0FinderTool.h.

◆ m_lbKey

Gaudi::Property<std::string> InDet::InDetV0FinderTool::m_lbKey

private

Initial value:

{ this, "LambdabarContainerName", "LambdabarCandidates",

"Lambdabar container name (same calling alg)" }

Definition at line 219 of file InDetV0FinderTool.h.

◆ m_masse

double InDet::InDetV0FinderTool::m_masse

private

electron mass (0.510999 MeV)

Definition at line 147 of file InDetV0FinderTool.h.

◆ m_masses

int InDet::InDetV0FinderTool::m_masses

private

= 1 if using PDG values, = 2 if user set (1)

Definition at line 144 of file InDetV0FinderTool.h.

◆ m_massK0S

double InDet::InDetV0FinderTool::m_massK0S

private

Kshort mass (497.672 MeV)

Definition at line 148 of file InDetV0FinderTool.h.

◆ m_massLambda

double InDet::InDetV0FinderTool::m_massLambda

private

Lambda mass (1115.68 MeV)

Definition at line 149 of file InDetV0FinderTool.h.

◆ m_massp

double InDet::InDetV0FinderTool::m_massp

private

proton mass (938.272 MeV)

Definition at line 146 of file InDetV0FinderTool.h.

◆ m_masspi

double InDet::InDetV0FinderTool::m_masspi

private

pion mass (139.57 MeV)

Definition at line 145 of file InDetV0FinderTool.h.

◆ m_maxPV

Gaudi::Property<int> InDet::InDetV0FinderTool::m_maxPV { this, "MaxPV", 999999 }

private

Definition at line 221 of file InDetV0FinderTool.h.

◆ m_maxsxy

double InDet::InDetV0FinderTool::m_maxsxy

private

Maximum Rxy of starting point (1000.

mm)

Definition at line 151 of file InDetV0FinderTool.h.

◆ m_mDecor_gfit

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_mDecor_gfit

private

Definition at line 205 of file InDetV0FinderTool.h.

◆ m_mDecor_gmass

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_mDecor_gmass

private

Definition at line 206 of file InDetV0FinderTool.h.

◆ m_mDecor_gmasserr

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_mDecor_gmasserr

private

Definition at line 207 of file InDetV0FinderTool.h.

◆ m_mDecor_gprob

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_mDecor_gprob

private

Definition at line 208 of file InDetV0FinderTool.h.

◆ m_minConstrVertProb

double InDet::InDetV0FinderTool::m_minConstrVertProb

private

Minimum vertex probability for constrained fit (0.0001)

Definition at line 162 of file InDetV0FinderTool.h.

◆ m_minVertProb

double InDet::InDetV0FinderTool::m_minVertProb

private

Minimum vertex probability (0.0001)

Definition at line 161 of file InDetV0FinderTool.h.

◆ m_particleDataTable

const HepPDT::ParticleDataTable* InDet::InDetV0FinderTool::m_particleDataTable

private

Definition at line 134 of file InDetV0FinderTool.h.

◆ m_ptTRT

double InDet::InDetV0FinderTool::m_ptTRT

private

Minimum pT for TRT tracks (700.

MeV)

Definition at line 150 of file InDetV0FinderTool.h.

◆ m_pv

bool InDet::InDetV0FinderTool::m_pv

private

= true select tracks wrt primary vertex (false)

Definition at line 139 of file InDetV0FinderTool.h.

◆ m_RelinkContainers

SG::ReadHandleKeyArray<xAOD::TrackParticleContainer> InDet::InDetV0FinderTool::m_RelinkContainers {this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" }

private

Definition at line 222 of file InDetV0FinderTool.h.

◆ m_samesign

bool InDet::InDetV0FinderTool::m_samesign

private

= true select tracks with same sign (false)

Definition at line 138 of file InDetV0FinderTool.h.

◆ m_trackParticleKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> InDet::InDetV0FinderTool::m_trackParticleKey

private

Initial value:

{ this, "TrackParticleCollection", "InDetTrackParticles",

"key for retrieval of TrackParticles" }

Definition at line 119 of file InDetV0FinderTool.h.

◆ m_trackToVertexTool

ToolHandle< Reco::ITrackToVertex > InDet::InDetV0FinderTool::m_trackToVertexTool

private

Definition at line 129 of file InDetV0FinderTool.h.

◆ m_trkSelector

ToolHandle< Trk::ITrackSelectorTool > InDet::InDetV0FinderTool::m_trkSelector

private

Definition at line 130 of file InDetV0FinderTool.h.

◆ m_uksmax

double InDet::InDetV0FinderTool::m_uksmax

private

max Kshort mass, unconstrained fit (600.

MeV)

Definition at line 153 of file InDetV0FinderTool.h.

◆ m_uksmin

double InDet::InDetV0FinderTool::m_uksmin

private

min Kshort mass, unconstrained fit (400.

MeV)

Definition at line 152 of file InDetV0FinderTool.h.

◆ m_ulamax

double InDet::InDetV0FinderTool::m_ulamax

private

max Lambda mass, unconstrained fit (1200.

MeV)

Definition at line 155 of file InDetV0FinderTool.h.

◆ m_ulamin

double InDet::InDetV0FinderTool::m_ulamin

private

min Lambda mass, unconstrained fit (1000.

MeV)

Definition at line 154 of file InDetV0FinderTool.h.

◆ m_use_vertColl

bool InDet::InDetV0FinderTool::m_use_vertColl

private

= true select tracks wrt a vertex collection (false)

Definition at line 140 of file InDetV0FinderTool.h.

◆ m_useBeamSpotCond

Gaudi::Property<bool> InDet::InDetV0FinderTool::m_useBeamSpotCond { this, "UseBeamSpotCond", false }

private

Definition at line 213 of file InDetV0FinderTool.h.

◆ m_useorigin

bool InDet::InDetV0FinderTool::m_useorigin

private

= true only using tracks that have no vertex association (true)

Definition at line 137 of file InDetV0FinderTool.h.

◆ m_useTRTplusSi

bool InDet::InDetV0FinderTool::m_useTRTplusSi

private

= use TRT+Si pairs (true)

Definition at line 142 of file InDetV0FinderTool.h.

◆ m_useTRTplusTRT

bool InDet::InDetV0FinderTool::m_useTRTplusTRT

private

= use TRT+TRT pairs (true)

Definition at line 141 of file InDetV0FinderTool.h.

◆ m_useV0Fitter

bool InDet::InDetV0FinderTool::m_useV0Fitter

private

= true if using TrkV0Fitter, = false if using VKalVert (true)

Definition at line 143 of file InDetV0FinderTool.h.

◆ m_v0_ksLinksDecorkey

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_v0_ksLinksDecorkey

private

Definition at line 201 of file InDetV0FinderTool.h.

◆ m_v0_laLinksDecorkey

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_v0_laLinksDecorkey

private

Definition at line 202 of file InDetV0FinderTool.h.

◆ m_v0_lbLinksDecorkey

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_v0_lbLinksDecorkey

private

Definition at line 203 of file InDetV0FinderTool.h.

◆ m_v0Key

Gaudi::Property<std::string> InDet::InDetV0FinderTool::m_v0Key { this, "V0ContainerName", "V0Candidates", "V0 container name (same calling alg)" }

private

Definition at line 215 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeyks

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_v0LinksDecorkeyks

private

Definition at line 198 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeylb

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_v0LinksDecorkeylb

private

Definition at line 199 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeylbb

SG::WriteDecorHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_v0LinksDecorkeylbb

private

Definition at line 200 of file InDetV0FinderTool.h.

◆ m_V0s_stored

std::atomic<unsigned int> InDet::InDetV0FinderTool::m_V0s_stored {}

mutableprivate

Definition at line 170 of file InDetV0FinderTool.h.

◆ m_V0Tools

ToolHandle< Trk::V0Tools > InDet::InDetV0FinderTool::m_V0Tools

private

Definition at line 128 of file InDetV0FinderTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vert_a0xy_cut

double InDet::InDetV0FinderTool::m_vert_a0xy_cut

private

V0 |a0xy| wrt a vertex (<3.)

Definition at line 166 of file InDetV0FinderTool.h.

◆ m_vert_a0z_cut

double InDet::InDetV0FinderTool::m_vert_a0z_cut

private

V0 |a0z| wrt a vertex (<15.)

Definition at line 167 of file InDetV0FinderTool.h.

◆ m_vert_lxy_cut

double InDet::InDetV0FinderTool::m_vert_lxy_cut

private

V0 lxy V0 lxy (<500.)

Definition at line 165 of file InDetV0FinderTool.h.

◆ m_vert_lxy_sig

double InDet::InDetV0FinderTool::m_vert_lxy_sig

private

V0 lxy significance wrt a vertex (>2.)

Definition at line 164 of file InDetV0FinderTool.h.

◆ m_vertexEstimator

ToolHandle< InDet::VertexPointEstimator > InDet::InDetV0FinderTool::m_vertexEstimator

private

Definition at line 131 of file InDetV0FinderTool.h.

◆ m_vertexKey

SG::ReadHandleKey<xAOD::VertexContainer> InDet::InDetV0FinderTool::m_vertexKey

private

Initial value:

{ this, "VertexContainer", "PrimaryVertices",

"primary vertex container" }

Definition at line 196 of file InDetV0FinderTool.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

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ InDetV0FinderTool()

◆ ~InDetV0FinderTool()

Member Function Documentation

◆ d0Pass() [1/3]

◆ d0Pass() [2/3]

◆ d0Pass() [3/3]

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

◆ doFit()

◆ doMassFit()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ invariantMass()

◆ makeLink()

◆ massFit()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ performSearch()

◆ pointAtVertex()

◆ pointAtVertexColl()

◆ renounce()

◆ renounceArray()

◆ SGError()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_beamSpotDecoKey

◆ m_beamSpotKey

◆ m_concreteVertexFitter

◆ m_d0_cut

◆ m_detStore

◆ m_doSimpleV0

◆ m_errmass

◆ m_eventInfo_key

◆ m_events_processed

◆ m_evtStore

◆ m_extrapolator

◆ m_Gamma_stored

◆ m_iGammaFitter

◆ m_iKshortFitter

◆ m_iLambdabarFitter

◆ m_iLambdaFitter

◆ m_iVertexFitter

◆ m_iVKVertexFitter

◆ m_Kshort_stored

◆ m_ksKey

◆ m_ksmax

◆ m_ksmin

◆ m_laKey

◆ m_lamax

◆ m_Lambda_stored

◆ m_Lambdabar_stored