#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

PublicToolHandle< Trk::IVertexFitter >	m_iVertexFitter

PublicToolHandle< Trk::IVertexFitter >	m_iVKVertexFitter

PublicToolHandle< Trk::IVertexFitter >	m_iKshortFitter

PublicToolHandle< Trk::IVertexFitter >	m_iLambdaFitter

PublicToolHandle< Trk::IVertexFitter >	m_iLambdabarFitter

PublicToolHandle< Trk::IVertexFitter >	m_iGammaFitter

PublicToolHandle< Trk::V0Tools >	m_V0Tools

PublicToolHandle< Reco::ITrackToVertex >	m_trackToVertexTool

PublicToolHandle< Trk::ITrackSelectorTool >	m_trkSelector

PublicToolHandle< InDet::VertexPointEstimator >	m_vertexEstimator

PublicToolHandle< Trk::IExtrapolator >	m_extrapolator

const HepPDT::ParticleDataTable *	m_particleDataTable = nullptr

BooleanProperty	m_doSimpleV0 {this, "doSimpleV0", false}
	= true equivalent to the old InDetSimpleV0Finder (false) More...

BooleanProperty	m_useorigin {this, "useorigin", true}
	= true only using tracks that have no vertex association (true) More...

BooleanProperty	m_samesign {this, "AddSameSign", false}
	= true select tracks with same sign (false) More...

BooleanProperty	m_pv {this, "trkSelPV", false}
	= true select tracks wrt primary vertex (false) More...

BooleanProperty	m_use_vertColl {this, "useVertexCollection", false}
	= true select tracks wrt a vertex collection (false) More...

BooleanProperty	m_useTRTplusTRT {this, "useTRTplusTRT", false}
	= use TRT+TRT pairs (true) More...

BooleanProperty	m_useTRTplusSi {this, "useTRTplusSi", false}
	= use TRT+Si pairs (true) More...

BooleanProperty	m_useV0Fitter {this, "useV0Fitter", false}
	= true if using TrkV0Fitter, = false if using VKalVert (true) More...

IntegerProperty	m_masses {this, "masses", 1}
	= 1 if using PDG values, = 2 if user set (1) More...

DoubleProperty	m_masspi {this, "masspi", 139.57}
	pion mass (139.57 MeV) More...

DoubleProperty	m_massp {this, "massp", 938.272}
	proton mass (938.272 MeV) More...

DoubleProperty	m_masse {this, "masse", 0.510999}
	electron mass (0.510999 MeV) More...

DoubleProperty	m_massK0S {this, "massK0S", 497.672}
	Kshort mass (497.672 MeV) More...

DoubleProperty	m_massLambda {this, "massLambda", 1115.68}
	Lambda mass (1115.68 MeV) More...

DoubleProperty	m_ptTRT {this, "ptTRT", 700.}
	Minimum pT for TRT tracks (700. More...

DoubleProperty	m_maxsxy {this, "maxsxy", 1000.}
	Maximum Rxy of starting point (1000. More...

DoubleProperty	m_uksmin {this, "uksmin", 400.}
	min Kshort mass, unconstrained fit (400. More...

DoubleProperty	m_uksmax {this, "uksmax", 600.}
	max Kshort mass, unconstrained fit (600. More...

DoubleProperty	m_ulamin {this, "ulamin", 1000.}
	min Lambda mass, unconstrained fit (1000. More...

DoubleProperty	m_ulamax {this, "ulamax", 1200.}
	max Lambda mass, unconstrained fit (1200. More...

DoubleProperty	m_ksmin {this, "ksmin", 400.}
	min Kshort mass (400. More...

DoubleProperty	m_ksmax {this, "ksmax", 600.}
	max Kshort mass (600. More...

DoubleProperty	m_lamin {this, "lamin", 1000.}
	min Lambda mass (1000. More...

DoubleProperty	m_lamax {this, "lamax", 1200.}
	max Lambda mass (1200. More...

DoubleProperty	m_errmass {this, "errmass", 100.}
	Maximum mass error (100. More...

DoubleProperty	m_minVertProb {this, "minVertProb", 0.0001}
	Minimum vertex probability (0.0001) More...

DoubleProperty	m_minConstrVertProb {this, "minConstrVertProb", 0.0001}
	Minimum vertex probability for constrained fit (0.0001) More...

DoubleProperty	m_d0_cut {this, "d0_cut", 2.}
	track d0 significance wrt a vertex (>2.) More...

DoubleProperty	m_vert_lxy_sig {this, "vert_lxy_sig", 2.}
	V0 lxy significance wrt a vertex (>2.) More...

DoubleProperty	m_vert_lxy_cut {this, "vert_lxy_cut", 500.}
	V0 lxy V0 lxy (<500.) More...

DoubleProperty	m_vert_a0xy_cut {this, "vert_a0xy_cut", 3.}
	V0 \|a0xy\| wrt a vertex (<3.) More...

DoubleProperty	m_vert_a0z_cut {this, "vert_a0z_cut", 15.}
	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" }

ServiceHandle< IPartPropSvc >	m_partPropSvc {this, "PartPropSvc", "PartPropSvc"}

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 98 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 45 of file InDetV0FinderTool.cxx.

                      {
     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 666 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 648 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 626 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 592 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 717 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 571 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 54 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 106 of file InDetV0FinderTool.h.

106 { return IID_InDetV0FinderTool;}

◆ invariantMass()

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

staticprivate

Definition at line 705 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 794 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 748 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 180 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 683 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 697 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 586 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 223 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 222 of file InDetV0FinderTool.h.

◆ m_concreteVertexFitter

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

private

Definition at line 205 of file InDetV0FinderTool.h.

◆ m_d0_cut

DoubleProperty InDet::InDetV0FinderTool::m_d0_cut {this, "d0_cut", 2.}

private

track d0 significance wrt a vertex (>2.)

Definition at line 174 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

BooleanProperty InDet::InDetV0FinderTool::m_doSimpleV0 {this, "doSimpleV0", false}

private

= true equivalent to the old InDetSimpleV0Finder (false)

Definition at line 146 of file InDetV0FinderTool.h.

◆ m_errmass

DoubleProperty InDet::InDetV0FinderTool::m_errmass {this, "errmass", 100.}

private

Maximum mass error (100.

MeV)

Definition at line 171 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 221 of file InDetV0FinderTool.h.

◆ m_events_processed

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

mutableprivate

Definition at line 180 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

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

private

Initial value:

{

this, "Extrapolator", "Trk::Extrapolator"}

Definition at line 141 of file InDetV0FinderTool.h.

◆ m_Gamma_stored

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

mutableprivate

Definition at line 185 of file InDetV0FinderTool.h.

◆ m_iGammaFitter

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

private

Initial value:

{

this, "GammaFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 131 of file InDetV0FinderTool.h.

◆ m_iKshortFitter

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

private

Initial value:

{

this, "KshortFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 125 of file InDetV0FinderTool.h.

◆ m_iLambdabarFitter

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

private

Initial value:

{

this, "LambdabarFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 129 of file InDetV0FinderTool.h.

◆ m_iLambdaFitter

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

private

Initial value:

{

this, "LambdaFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 127 of file InDetV0FinderTool.h.

◆ m_iVertexFitter

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

private

Initial value:

{

this, "VertexFitterTool", "Trk::V0VertexFitter"}

Definition at line 121 of file InDetV0FinderTool.h.

◆ m_iVKVertexFitter

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

private

Initial value:

{

this, "VKVertexFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 123 of file InDetV0FinderTool.h.

◆ m_Kshort_stored

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

mutableprivate

Definition at line 182 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 227 of file InDetV0FinderTool.h.

◆ m_ksmax

DoubleProperty InDet::InDetV0FinderTool::m_ksmax {this, "ksmax", 600.}

private

max Kshort mass (600.

MeV)

Definition at line 168 of file InDetV0FinderTool.h.

◆ m_ksmin

DoubleProperty InDet::InDetV0FinderTool::m_ksmin {this, "ksmin", 400.}

private

min Kshort mass (400.

MeV)

Definition at line 167 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 228 of file InDetV0FinderTool.h.

◆ m_lamax

DoubleProperty InDet::InDetV0FinderTool::m_lamax {this, "lamax", 1200.}

private

max Lambda mass (1200.

MeV)

Definition at line 170 of file InDetV0FinderTool.h.

◆ m_Lambda_stored

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

mutableprivate

Definition at line 183 of file InDetV0FinderTool.h.

◆ m_Lambdabar_stored

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

mutableprivate

Definition at line 184 of file InDetV0FinderTool.h.

◆ m_lamin

DoubleProperty InDet::InDetV0FinderTool::m_lamin {this, "lamin", 1000.}

private

min Lambda mass (1000.

MeV)

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

◆ m_masse

DoubleProperty InDet::InDetV0FinderTool::m_masse {this, "masse", 0.510999}

private

electron mass (0.510999 MeV)

Definition at line 158 of file InDetV0FinderTool.h.

◆ m_masses

IntegerProperty InDet::InDetV0FinderTool::m_masses {this, "masses", 1}

private

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

Definition at line 155 of file InDetV0FinderTool.h.

◆ m_massK0S

DoubleProperty InDet::InDetV0FinderTool::m_massK0S {this, "massK0S", 497.672}

private

Kshort mass (497.672 MeV)

Definition at line 159 of file InDetV0FinderTool.h.

◆ m_massLambda

DoubleProperty InDet::InDetV0FinderTool::m_massLambda {this, "massLambda", 1115.68}

private

Lambda mass (1115.68 MeV)

Definition at line 160 of file InDetV0FinderTool.h.

◆ m_massp

DoubleProperty InDet::InDetV0FinderTool::m_massp {this, "massp", 938.272}

private

proton mass (938.272 MeV)

Definition at line 157 of file InDetV0FinderTool.h.

◆ m_masspi

DoubleProperty InDet::InDetV0FinderTool::m_masspi {this, "masspi", 139.57}

private

pion mass (139.57 MeV)

Definition at line 156 of file InDetV0FinderTool.h.

◆ m_maxPV

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

private

Definition at line 232 of file InDetV0FinderTool.h.

◆ m_maxsxy

DoubleProperty InDet::InDetV0FinderTool::m_maxsxy {this, "maxsxy", 1000.}

private

Maximum Rxy of starting point (1000.

mm)

Definition at line 162 of file InDetV0FinderTool.h.

◆ m_mDecor_gfit

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

private

Definition at line 216 of file InDetV0FinderTool.h.

◆ m_mDecor_gmass

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

private

Definition at line 217 of file InDetV0FinderTool.h.

◆ m_mDecor_gmasserr

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

private

Definition at line 218 of file InDetV0FinderTool.h.

◆ m_mDecor_gprob

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

private

Definition at line 219 of file InDetV0FinderTool.h.

◆ m_minConstrVertProb

DoubleProperty InDet::InDetV0FinderTool::m_minConstrVertProb {this, "minConstrVertProb", 0.0001}

private

Minimum vertex probability for constrained fit (0.0001)

Definition at line 173 of file InDetV0FinderTool.h.

◆ m_minVertProb

DoubleProperty InDet::InDetV0FinderTool::m_minVertProb {this, "minVertProb", 0.0001}

private

Minimum vertex probability (0.0001)

Definition at line 172 of file InDetV0FinderTool.h.

◆ m_particleDataTable

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

private

Definition at line 144 of file InDetV0FinderTool.h.

◆ m_partPropSvc

ServiceHandle<IPartPropSvc> InDet::InDetV0FinderTool::m_partPropSvc {this, "PartPropSvc", "PartPropSvc"}

private

Definition at line 236 of file InDetV0FinderTool.h.

◆ m_ptTRT

DoubleProperty InDet::InDetV0FinderTool::m_ptTRT {this, "ptTRT", 700.}

private

Minimum pT for TRT tracks (700.

MeV)

Definition at line 161 of file InDetV0FinderTool.h.

◆ m_pv

BooleanProperty InDet::InDetV0FinderTool::m_pv {this, "trkSelPV", false}

private

= true select tracks wrt primary vertex (false)

Definition at line 149 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 233 of file InDetV0FinderTool.h.

◆ m_samesign

BooleanProperty InDet::InDetV0FinderTool::m_samesign {this, "AddSameSign", false}

private

= true select tracks with same sign (false)

Definition at line 148 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 118 of file InDetV0FinderTool.h.

◆ m_trackToVertexTool

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

private

Initial value:

{

this, "TrackToVertexTool", "Reco::TrackToVertex"}

Definition at line 135 of file InDetV0FinderTool.h.

◆ m_trkSelector

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

private

Initial value:

{

this, "TrackSelectorTool", "InDet::TrackSelectorTool"}

Definition at line 137 of file InDetV0FinderTool.h.

◆ m_uksmax

DoubleProperty InDet::InDetV0FinderTool::m_uksmax {this, "uksmax", 600.}

private

max Kshort mass, unconstrained fit (600.

MeV)

Definition at line 164 of file InDetV0FinderTool.h.

◆ m_uksmin

DoubleProperty InDet::InDetV0FinderTool::m_uksmin {this, "uksmin", 400.}

private

min Kshort mass, unconstrained fit (400.

MeV)

Definition at line 163 of file InDetV0FinderTool.h.

◆ m_ulamax

DoubleProperty InDet::InDetV0FinderTool::m_ulamax {this, "ulamax", 1200.}

private

max Lambda mass, unconstrained fit (1200.

MeV)

Definition at line 166 of file InDetV0FinderTool.h.

◆ m_ulamin

DoubleProperty InDet::InDetV0FinderTool::m_ulamin {this, "ulamin", 1000.}

private

min Lambda mass, unconstrained fit (1000.

MeV)

Definition at line 165 of file InDetV0FinderTool.h.

◆ m_use_vertColl

BooleanProperty InDet::InDetV0FinderTool::m_use_vertColl {this, "useVertexCollection", false}

private

= true select tracks wrt a vertex collection (false)

Definition at line 150 of file InDetV0FinderTool.h.

◆ m_useBeamSpotCond

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

private

Definition at line 224 of file InDetV0FinderTool.h.

◆ m_useorigin

BooleanProperty InDet::InDetV0FinderTool::m_useorigin {this, "useorigin", true}

private

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

Definition at line 147 of file InDetV0FinderTool.h.

◆ m_useTRTplusSi

BooleanProperty InDet::InDetV0FinderTool::m_useTRTplusSi {this, "useTRTplusSi", false}

private

= use TRT+Si pairs (true)

Definition at line 152 of file InDetV0FinderTool.h.

◆ m_useTRTplusTRT

BooleanProperty InDet::InDetV0FinderTool::m_useTRTplusTRT {this, "useTRTplusTRT", false}

private

= use TRT+TRT pairs (true)

Definition at line 151 of file InDetV0FinderTool.h.

◆ m_useV0Fitter

BooleanProperty InDet::InDetV0FinderTool::m_useV0Fitter {this, "useV0Fitter", false}

private

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

Definition at line 153 of file InDetV0FinderTool.h.

◆ m_v0_ksLinksDecorkey

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

private

Definition at line 212 of file InDetV0FinderTool.h.

◆ m_v0_laLinksDecorkey

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

private

Definition at line 213 of file InDetV0FinderTool.h.

◆ m_v0_lbLinksDecorkey

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

private

Definition at line 214 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 226 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeyks

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

private

Definition at line 209 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeylb

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

private

Definition at line 210 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeylbb

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

private

Definition at line 211 of file InDetV0FinderTool.h.

◆ m_V0s_stored

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

mutableprivate

Definition at line 181 of file InDetV0FinderTool.h.

◆ m_V0Tools

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

private

Initial value:

{

this, "V0Tools", "Trk::V0Tools"}

Definition at line 133 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

DoubleProperty InDet::InDetV0FinderTool::m_vert_a0xy_cut {this, "vert_a0xy_cut", 3.}

private

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

Definition at line 177 of file InDetV0FinderTool.h.

◆ m_vert_a0z_cut

DoubleProperty InDet::InDetV0FinderTool::m_vert_a0z_cut {this, "vert_a0z_cut", 15.}

private

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

Definition at line 178 of file InDetV0FinderTool.h.

◆ m_vert_lxy_cut

DoubleProperty InDet::InDetV0FinderTool::m_vert_lxy_cut {this, "vert_lxy_cut", 500.}

private

V0 lxy V0 lxy (<500.)

Definition at line 176 of file InDetV0FinderTool.h.

◆ m_vert_lxy_sig

DoubleProperty InDet::InDetV0FinderTool::m_vert_lxy_sig {this, "vert_lxy_sig", 2.}

private

V0 lxy significance wrt a vertex (>2.)

Definition at line 175 of file InDetV0FinderTool.h.

◆ m_vertexEstimator

PublicToolHandle<InDet::VertexPointEstimator> InDet::InDetV0FinderTool::m_vertexEstimator

private

Initial value:

{

this, "VertexPointEstimator", "InDet::VertexPointEstimator"}

Definition at line 139 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 207 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