#include <InDetV0FinderTool.h>

Inheritance 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`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

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::VertexContainer vertColl, const EventContext &ctx) const
bool	d0Pass (const xAOD::TrackParticle track1, const xAOD::Vertex vertex, const EventContext &ctx) const
bool	d0Pass (const xAOD::TrackParticle *track1, const Amg::Vector3D &vertex, const EventContext &ctx) const
bool	pointAtVertex (const xAOD::Vertex v0, const xAOD::Vertex PV, float &score) const
bool	pointAtVertexColl (xAOD::Vertex v0, const xAOD::VertexContainer vertColl, float &score) 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, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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)
BooleanProperty	m_useorigin {this, "useorigin", true}
	= true only using tracks that have no vertex association (true)
BooleanProperty	m_samesign {this, "AddSameSign", false}
	= true select tracks with same sign (false)
BooleanProperty	m_pv {this, "trkSelPV", false}
	= true select tracks wrt primary vertex (false)
BooleanProperty	m_use_vertColl {this, "useVertexCollection", false}
	= true select tracks wrt a vertex collection (false)
BooleanProperty	m_useTRTplusTRT {this, "useTRTplusTRT", false}
	= use TRT+TRT pairs (true)
BooleanProperty	m_useTRTplusSi {this, "useTRTplusSi", false}
	= use TRT+Si pairs (true)
BooleanProperty	m_useV0Fitter {this, "useV0Fitter", false}
	= true if using TrkV0Fitter, = false if using VKalVert (true)
BooleanProperty	m_use_innerPixHits {this, "use_innerPixHits", false}
	= true select allows tracks with no innermost pixel layer hits to always pass d0 significance cut (false)
BooleanProperty	m_useBDT {this, "useBDT", false}
	= true uses BDT selections in place of rectangular pointAtVertex + minVertProb
BooleanProperty	m_useTrkSel {this, "use_TrackSelector", true}
	= true uses TrackSelectorTool
IntegerProperty	m_masses {this, "masses", 1}
	= 1 if using PDG values, = 2 if user set (1)
DoubleProperty	m_masspi {this, "masspi", ParticleConstants::chargedPionMassInMeV}
	pion mass (139.57 MeV)
DoubleProperty	m_massp {this, "massp", ParticleConstants::protonMassInMeV}
	proton mass (938.272 MeV)
DoubleProperty	m_masse {this, "masse", ParticleConstants::electronMassInMeV}
	electron mass (0.510999 MeV)
DoubleProperty	m_massK0S {this, "massK0S", ParticleConstants::KZeroMassInMeV}
	Kshort mass (497.672 MeV)
DoubleProperty	m_massLambda {this, "massLambda", ParticleConstants::lambdaMassInMeV}
	Lambda mass (1115.68 MeV)
DoubleProperty	m_ptTRT {this, "ptTRT", 700.}
	Minimum pT for TRT tracks (700.
DoubleProperty	m_maxsxy {this, "maxsxy", 1000.}
	Maximum Rxy of starting point (1000.
DoubleProperty	m_uksmin {this, "uksmin", 400.}
	min Kshort mass, unconstrained fit (400.
DoubleProperty	m_uksmax {this, "uksmax", 600.}
	max Kshort mass, unconstrained fit (600.
DoubleProperty	m_ulamin {this, "ulamin", 1000.}
	min Lambda mass, unconstrained fit (1000.
DoubleProperty	m_ulamax {this, "ulamax", 1200.}
	max Lambda mass, unconstrained fit (1200.
DoubleProperty	m_ksmin {this, "ksmin", 400.}
	min Kshort mass (400.
DoubleProperty	m_ksmax {this, "ksmax", 600.}
	max Kshort mass (600.
DoubleProperty	m_lamin {this, "lamin", 1000.}
	min Lambda mass (1000.
DoubleProperty	m_lamax {this, "lamax", 1200.}
	max Lambda mass (1200.
DoubleProperty	m_errmass {this, "errmass", 100.}
	Maximum mass error (100.
DoubleProperty	m_minVertProb {this, "minVertProb", 0.0001}
	Minimum vertex probability (0.0001)
DoubleProperty	m_minConstrVertProb {this, "minConstrVertProb", 0.0001}
	Minimum vertex probability for constrained fit (0.0001)
DoubleProperty	m_d0_cut {this, "d0_cut", 2.}
	track d0 significance wrt a vertex (>2.)
DoubleProperty	m_max_d0_cut {this, "max_d0_cut", 999999.}
	track \|d0\| wrt a vertex (<999999.)
DoubleProperty	m_max_z0_cut {this, "max_z0_cut", 999999.}
	track \|z0\| wrt a vertex (<999999.)
DoubleProperty	m_vert_lxy_sig {this, "vert_lxy_sig", 2.}
	V0 lxy significance wrt a vertex (>2.)
DoubleProperty	m_vert_lxy_cut {this, "vert_lxy_cut", 500.}
	V0 lxy V0 lxy (<500.)
DoubleProperty	m_vert_a0xy_cut {this, "vert_a0xy_cut", 3.}
	V0 \|a0xy\| wrt a vertex (<3.)
DoubleProperty	m_vert_a0z_cut {this, "vert_a0z_cut", 15.}
	V0 \|a0z\| wrt a vertex (<15.)
DoubleProperty	m_vert_cos_cut {this, "vert_cos_cut", 0.}
	V0 cos(theta) angle between displacement and momentum (>0.)
DoubleProperty	m_BDTCut {this, "BDTCut", -1}
	BDT Score threshold.
StringProperty	m_BDTFile {this, "BDTFile", "XGBModelBetterVertex.root"}
	Filename of mvaUtils model file, located in /InDetV0FinderTool/BDT/v1/.
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::WriteDecorHandleKey< xAOD::VertexContainer >	m_v0_BDTScore
std::unique_ptr< MVAUtils::BDT >	m_BDT
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", m_eventInfo_key, {"beamPosX", "beamPosY", "beamPosZ"}, "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)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 102 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 34 of file InDetV0FinderTool.cxx.

  :
  AthAlgTool(t,n,p)
{
  declareInterface<InDetV0FinderTool>(this);
}

◆ ~InDetV0FinderTool()

InDet::InDetV0FinderTool::~InDetV0FinderTool ( )

default

Member Function Documentation

◆ d0Pass() [1/4]

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

private

Definition at line 714 of file InDetV0FinderTool.cxx.

{
  bool pass = false;
  bool hasInnerPixHit1 = true;
  if (m_use_innerPixHits){
    SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
    uint8_t  nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
    if (nInnerHits1 == 0) hasInnerPixHit1 = false;
  }
  auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV );
  if (per1 == nullptr) return pass;
  double d0_1 = per1->parameters()[Trk::d0];
  double sig_d0_1 = sqrt((*per1->covariance())(0,0));
  double delta_z0_1 = track1->z0() + track1->vz() - PV.z();
  if (((std::abs(d0_1/sig_d0_1) > m_d0_cut) ||
       (!hasInnerPixHit1)) && 
      (std::abs(d0_1) < m_max_d0_cut) &&
      (std::abs(delta_z0_1) < m_max_z0_cut)) pass = true;
  return pass;
}

◆ d0Pass() [2/4]

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

private

Definition at line 628 of file InDetV0FinderTool.cxx.

{
  bool pass = false;
  int count = 0;
  bool hasInnerPixHit1 = true;
  bool hasInnerPixHit2 = true;
  if (m_use_innerPixHits){
    SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
    uint8_t  nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
    if (nInnerHits1 == 0) hasInnerPixHit1 = false;
    uint8_t  nInnerHits2 = numberOfInnermostPixelLayerHits(*track2);
    if (nInnerHits2 == 0) hasInnerPixHit2 = false;
  }
  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() );
    if (per2 == nullptr) continue;
    double d0_1 = per1->parameters()[Trk::d0];
    double sig_d0_1 = sqrt((*per1->covariance())(0,0));
    double delta_z0_1 = track1->z0() + track1->vz() - PV->z();
    double d0_2 = per2->parameters()[Trk::d0];
    double sig_d0_2 = sqrt((*per2->covariance())(0,0));
    double delta_z0_2 = track2->z0() + track2->vz() - PV->z();
    bool IP_check1 = (std::abs(d0_1/sig_d0_1) > m_d0_cut) || !hasInnerPixHit1;
    IP_check1 &= std::abs(d0_1) < m_max_d0_cut;
    IP_check1 &= std::abs(delta_z0_1) < m_max_z0_cut;
    bool IP_check2 = (std::abs(d0_2/sig_d0_2) > m_d0_cut) || !hasInnerPixHit2;
    IP_check2 &= std::abs(d0_2) < m_max_d0_cut;
    IP_check2 &= std::abs(delta_z0_2) < m_max_z0_cut;
    if (IP_check1 && IP_check2) return true;
    if (++count >= m_maxPV) break;
  }
  return pass;
}

◆ d0Pass() [3/4]

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

private

Definition at line 693 of file InDetV0FinderTool.cxx.

{
  bool pass = false;
  bool hasInnerPixHit1 = true;
  if (m_use_innerPixHits){
    SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
    uint8_t  nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
    if (nInnerHits1 == 0) hasInnerPixHit1 = false;
  }
  auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV->position() );
  if (per1 == nullptr) return pass;
  double d0_1 = per1->parameters()[Trk::d0];
  double sig_d0_1 = sqrt((*per1->covariance())(0,0));
  double delta_z0_1 = track1->z0() + track1->vz() - PV->z();
  if (((std::abs(d0_1/sig_d0_1) > m_d0_cut) ||
       (!hasInnerPixHit1)) && 
      (std::abs(d0_1) < m_max_d0_cut) &&
      (std::abs(delta_z0_1) < m_max_z0_cut)) pass = true;
  return pass;
}

◆ d0Pass() [4/4]

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

private

Definition at line 666 of file InDetV0FinderTool.cxx.

{
  bool pass = false;
  int count = 0;
  bool hasInnerPixHit1 = true;
  if (m_use_innerPixHits){
    SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
    uint8_t  nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
    if (nInnerHits1 == 0) hasInnerPixHit1 = false;
  }
  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;
    double d0_1 = per1->parameters()[Trk::d0];
    double sig_d0_1 = sqrt((*per1->covariance())(0,0));
    double delta_z0_1 = track1->z0() + track1->vz() - PV->z();
    if (((std::abs(d0_1/sig_d0_1) > m_d0_cut) ||
         (!hasInnerPixHit1)) &&
        (std::abs(d0_1) < m_max_d0_cut) &&
        (std::abs(delta_z0_1) < m_max_z0_cut)) return true;
    if (++count >= m_maxPV) break;
  }
  return pass;
}

◆ declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ doFit()

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

private

Definition at line 594 of file InDetV0FinderTool.cxx.

{
  bool pass = false;
  double srxy = startingPoint.perp();
  if (srxy <= m_maxsxy)
  {
    double massKshort_i=2000001., massLambda_i=2000001., massLambdabar_i=2000001.;
    const Amg::Vector3D& globalPosition = startingPoint;
    Trk::PerigeeSurface perigeeSurface(globalPosition);
    std::vector<std::unique_ptr<const Trk::TrackParameters> >  cleanup;
    const Trk::TrackParameters* extrapolatedPerigee1(nullptr);
    const Trk::TrackParameters* extrapolatedPerigee2(nullptr);
    extrapolatedPerigee1 = m_extrapolator->extrapolate(ctx,track1->perigeeParameters(), perigeeSurface).release();
    if (extrapolatedPerigee1 == nullptr) extrapolatedPerigee1 = &track1->perigeeParameters();
    else cleanup.push_back(std::unique_ptr<const Trk::TrackParameters>(extrapolatedPerigee1));
 
    extrapolatedPerigee2 = m_extrapolator->extrapolate(ctx,track2->perigeeParameters(), perigeeSurface).release();
    if (extrapolatedPerigee2 == nullptr) extrapolatedPerigee2 = &track2->perigeeParameters();
    else cleanup.push_back(std::unique_ptr<const Trk::TrackParameters>(extrapolatedPerigee2));
 
    if (extrapolatedPerigee1 != nullptr && extrapolatedPerigee2 != nullptr) {
      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;
}

◆ doMassFit()

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

private

Definition at line 788 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;
    winmass_max = m_ksmax;
    mass = m_V0Tools->invariantMass(vxCandidate,m_masspi,m_masspi);
    error = m_V0Tools->invariantMassError(vxCandidate,m_masspi,m_masspi);
    if (mass >= winmass_min && mass <= winmass_max && error <= m_errmass) in_mass_window = true;
  } else if (pdgID == 3122 || pdgID == -3122) {
    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;
}

◆ evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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 573 of file InDetV0FinderTool.cxx.

{
  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;
  msg(MSG::DEBUG) << "----------------------------------------------------------------------------------------------------------------------------------------------" << endmsg;
 
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode InDet::InDetV0FinderTool::initialize ( )

Definition at line 43 of file InDetV0FinderTool.cxx.

{
  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);
  } else {
    ATH_CHECK( m_iVKVertexFitter.retrieve() );
    ATH_MSG_DEBUG("Retrieved tool " << m_iVKVertexFitter);
 
    // Get the VKalVrt Ks vertex fitting tool from ToolSvc
    ATH_CHECK( m_iKshortFitter.retrieve() );
    ATH_MSG_DEBUG("Retrieved tool " << m_iKshortFitter);
 
    // Get the VKalVrt Lambda vertex fitting tool from ToolSvc
    ATH_CHECK( m_iLambdaFitter.retrieve() );
    ATH_MSG_DEBUG( "Retrieved tool " << m_iLambdaFitter);
 
    // Get the VKalVrt Lambdabar vertex fitting tool from ToolSvc
    ATH_CHECK( m_iLambdabarFitter.retrieve() );
    ATH_MSG_DEBUG("Retrieved tool " << m_iLambdabarFitter);
  }
 
  ATH_CHECK( m_iGammaFitter.retrieve() );
  ATH_MSG_DEBUG("Retrieved tool " << m_iGammaFitter);
 
  // get the Particle Properties Service
  ATH_CHECK(m_partPropSvc.retrieve());
  m_particleDataTable = m_partPropSvc->PDT();
 
  // uploading the V0 tools
  ATH_CHECK( m_V0Tools.retrieve() );
  ATH_MSG_DEBUG("Retrieved tool " << m_V0Tools);
 
  // Get the TrackToVertex extrapolator tool
  ATH_CHECK( m_trackToVertexTool.retrieve() );
 
  // Get the extrapolator
  ATH_CHECK( m_extrapolator.retrieve() );
  ATH_MSG_DEBUG("Retrieved tool ");
 
  // Initialize vertex container key
  ATH_CHECK( m_vertexKey.initialize() );
 
  m_v0LinksDecorkeyks = m_ksKey + ".V0Link";
  m_v0LinksDecorkeylb = m_laKey + ".V0Link";
  m_v0LinksDecorkeylbb = m_lbKey + ".V0Link";
  m_v0_ksLinksDecorkey = m_v0Key + ".KshortLink";
  m_v0_laLinksDecorkey = m_v0Key + ".LambdaLink";
  m_v0_lbLinksDecorkey = m_v0Key + ".LambdabarLink";
  ATH_MSG_DEBUG("m_v0_lbLinksDecorkey = " << m_v0_lbLinksDecorkey.key());
  ATH_MSG_DEBUG("m_v0_laLinksDecorkey = " << m_v0_laLinksDecorkey.key());
  ATH_MSG_DEBUG("m_v0_ksLinksDecorkey = " << m_v0_ksLinksDecorkey.key());
  ATH_MSG_DEBUG("m_v0LinksDecorkeyks = " << m_v0LinksDecorkeyks.key());
  ATH_CHECK( m_v0LinksDecorkeyks.initialize());
  ATH_CHECK( m_v0LinksDecorkeylb.initialize());
  ATH_CHECK( m_v0LinksDecorkeylbb.initialize());
  ATH_CHECK( m_v0_ksLinksDecorkey.initialize());
  ATH_CHECK( m_v0_laLinksDecorkey.initialize());
  ATH_CHECK( m_v0_lbLinksDecorkey.initialize());
 
  m_mDecor_gfit = m_v0Key + ".gamma_fit"; 
  m_mDecor_gmass = m_v0Key + ".gamma_mass";
  m_mDecor_gmasserr = m_v0Key + ".gamma_massError";
  m_mDecor_gprob = m_v0Key + ".gamma_probability";
  ATH_CHECK( m_mDecor_gfit.initialize());
  ATH_CHECK( m_mDecor_gmass.initialize());
  ATH_CHECK( m_mDecor_gmasserr.initialize());
  ATH_CHECK( m_mDecor_gprob.initialize());
 
  m_v0_BDTScore = m_v0Key + ".BDTScore";
 
  ATH_MSG_DEBUG("m_v0_BDTScore = " << m_v0_BDTScore.key());
  ATH_CHECK( m_v0_BDTScore.initialize());
 
 
  if (m_useBDT){
    std::string BDTPathName = "InDetV0FinderTool/BDT/v1/" + m_BDTFile;
    std::string fullPathToFile = PathResolverFindCalibFile(BDTPathName);
    ATH_MSG_DEBUG("Using BDT File: " << fullPathToFile);
    std::unique_ptr<TFile> rootFile(TFile::Open(fullPathToFile.c_str(), "READ"));
    std::string strBDTName = "xgboost";
    std::unique_ptr<TTree> training( (TTree*)rootFile->Get(strBDTName.c_str()) );
    m_BDT = std::make_unique<MVAUtils::BDT>(training.get());
  }
 
  ATH_CHECK( m_eventInfo_key.initialize(!m_useBeamSpotCond));
  ATH_CHECK( m_beamSpotKey.initialize( m_useBeamSpotCond));
  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;
}

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

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

inlinestatic

Definition at line 110 of file InDetV0FinderTool.h.

110{ return IID_InDetV0FinderTool;}

InDet::IID_InDetV0FinderTool

static const InterfaceID IID_InDetV0FinderTool("InDetV0FinderTool", 1, 0)

◆ invariantMass()

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

staticprivate

Definition at line 776 of file InDetV0FinderTool.cxx.

{
  double e1sq = per1->momentum().mag2() + m1*m1;
  double e1 = (e1sq>0.) ? sqrt(e1sq) : 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;
}

◆ makeLink()

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

private

Definition at line 865 of file InDetV0FinderTool.cxx.

{
    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 {
      for(const xAOD::TrackParticleContainer* trkcol : trackcols){
          auto itr = std::find(trkcol->begin(), trkcol->end(), tp);
          if(itr != trkcol->end()){
            Link.setStorableObject(*trkcol, true);
            elementSet = true;
            break;
          }
      }
    }
    if(!elementSet) ATH_MSG_ERROR("Track was not found when linking");
    return Link;
}

◆ massFit()

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

private

Definition at line 819 of file InDetV0FinderTool.cxx.

{
  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);
  } else if (pdgID == -3122) {
    masses.push_back(m_masspi);
    masses.push_back(m_massp);
  } else if (pdgID == 22) {
    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;
}

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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

{
 
  ATH_MSG_DEBUG( "InDetV0FinderTool::performSearch" );
  std::vector<const xAOD::TrackParticleContainer*> trackCols;
  for(const auto &str : m_RelinkContainers){
    SG::ReadHandle<xAOD::TrackParticleContainer> handle(str,ctx);
    trackCols.push_back(handle.cptr());
  }
 
  m_events_processed ++;
 
  //Retrieve vertices for overlap removal
  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;
  }
 
// 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) || (!m_useTrkSel))
      {
        //PV Track Overlap Selections
        const xAOD::Vertex* foundVertex { nullptr };
        if (m_useorigin)
        {
          for (const auto *const vx : *vertices)
          {
              for (const auto& tpLink : vx->trackParticleLinks())
              {
                if (*tpLink == TP)
                {
                  foundVertex = vx;
                  break;
                }
              }
            if (foundVertex) break;
          }
        }
        bool useTrack = false;
        if (!m_useorigin) useTrack = true;
        if (m_useorigin && foundVertex == nullptr) useTrack = true;
        if (!useTrack) continue;
 
 
        //d0 Selections
        bool d0wrtVertex = true;
        if (m_use_vertColl) {
          if ( !d0Pass(TP,vertColl, ctx) ) d0wrtVertex = false;
        }
        if (!m_use_vertColl && m_pv) {
          if (primaryVertex) {
            if ( !d0Pass(TP,primaryVertex, ctx) ) d0wrtVertex = false;
          } else {
            if ( !d0Pass(TP,beamspot, ctx) ) d0wrtVertex = false;
          }
        }
        if (!d0wrtVertex) continue;
 
        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::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);
 
  SG::WriteDecorHandle<xAOD::VertexContainer, float> v0_BDTScore(m_v0_BDTScore, 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();
 
    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();
 
      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;
 
      //re-do d0 selection if using m_use_vertColl to ensure both tracks pass for the SAME vertex
      bool d0wrtVertex = true;
      if (m_use_vertColl) {
        if ( !d0Pass(TP1,TP2,vertColl, 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) || (m_useBDT) ) // If using BDT selections, it makes VertProb Selections
                {
                  bool doKshortFit = false;
                  doKshortFit = doMassFit(myVxCandidate.get(),310);
                  bool doLambdaFit = false;
                  doLambdaFit = doMassFit(myVxCandidate.get(),3122);
                  bool doLambdabarFit = false;
                  doLambdabarFit = doMassFit(myVxCandidate.get(),-3122);
                  float score = 0; // BDT score variable
                  if (doKshortFit || doLambdaFit || doLambdabarFit)
                  {
                    bool pointAtVert = true;
                    if (m_use_vertColl) {
                      if ( !pointAtVertexColl(myVxCandidate.get(),vertColl,score) ) pointAtVert = false;
                    }
                    if (!m_use_vertColl && m_pv && primaryVertex) {
                      if ( !pointAtVertex(myVxCandidate.get(),primaryVertex,score) ) 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());
 
                        v0_BDTScore( *(v0Container->back()) ) = score;// decorate w/ bdt score
 
                        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;
}

◆ pointAtVertex()

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

private

Definition at line 735 of file InDetV0FinderTool.cxx.

{
  bool pass = false;
  float v0lxy = m_V0Tools->lxy(v0,PV);
  float v0lxyError = m_V0Tools->lxyError(v0,PV);
  float cos = m_V0Tools->cosTheta(v0,PV);
  float v0a0xy = m_V0Tools->a0xy(v0,PV);
  float v0a0z = m_V0Tools->a0z(v0,PV);
  if (m_useBDT){
    float prob = m_V0Tools->vertexProbability(v0);
    float nLogProb = 999999;
    if (prob>0) nLogProb = -1*log10f(prob); //bdt model uses the log, not the raw value
    std::vector<float> bdt_vars = {
                                    nLogProb,
                                    std::abs(v0a0xy),
                                    std::abs(v0a0z),
                                    v0lxy,
                                    v0lxy/v0lxyError,
                                    cos};
      float this_Score=m_BDT->GetClassification(bdt_vars);
      if (this_Score > score) {
        score = this_Score;
      }
      if (score > m_BDTCut){
        pass = true;
      }
  }
  else if (v0lxy/v0lxyError > m_vert_lxy_sig && cos > m_vert_cos_cut &&
      std::abs(v0a0xy) < m_vert_a0xy_cut && std::abs(v0a0z) < m_vert_a0z_cut &&
      v0lxy < m_vert_lxy_cut) pass = true;
  return pass;
}

◆ pointAtVertexColl()

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

private

Definition at line 768 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),score)) pass = true; }
  return pass;
}

◆ 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 588 of file InDetV0FinderTool.cxx.

{
  ATH_MSG_FATAL(errService << " not found. Exiting !");
}

◆ sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

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

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_BDT

std::unique_ptr<MVAUtils::BDT> InDet::InDetV0FinderTool::m_BDT

private

Definition at line 238 of file InDetV0FinderTool.h.

◆ m_BDTCut

DoubleProperty InDet::InDetV0FinderTool::m_BDTCut {this, "BDTCut", -1}

private

BDT Score threshold.

Definition at line 189 of file InDetV0FinderTool.h.

189{this, "BDTCut", -1};

◆ m_BDTFile

StringProperty InDet::InDetV0FinderTool::m_BDTFile {this, "BDTFile", "XGBModelBetterVertex.root"}

private

Filename of mvaUtils model file, located in /InDetV0FinderTool/BDT/v1/.

Definition at line 191 of file InDetV0FinderTool.h.

191{this, "BDTFile", "XGBModelBetterVertex.root"};

◆ m_beamSpotDecoKey

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

private

Definition at line 242 of file InDetV0FinderTool.h.

242{this, "BeamSpotDecoKeys", m_eventInfo_key, {"beamPosX", "beamPosY", "beamPosZ"}, "Add the scheduler dependencies on the beamspot information"};

◆ m_beamSpotKey

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

private

Definition at line 241 of file InDetV0FinderTool.h.

241{ this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

◆ m_concreteVertexFitter

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

private

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

181{this, "d0_cut", 2.};

◆ 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 150 of file InDetV0FinderTool.h.

150{this, "doSimpleV0", false};

◆ m_errmass

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

private

Maximum mass error (100.

MeV)

Definition at line 178 of file InDetV0FinderTool.h.

178{this, "errmass", 100.};

◆ m_eventInfo_key

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

private

Definition at line 240 of file InDetV0FinderTool.h.

240{this, "EventInfo", "EventInfo", "Input event information"};

◆ m_events_processed

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

mutableprivate

Definition at line 194 of file InDetV0FinderTool.h.

194{};

◆ 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 145 of file InDetV0FinderTool.h.

145 {

146 this, "Extrapolator", "Trk::Extrapolator"};

◆ m_Gamma_stored

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

mutableprivate

Definition at line 199 of file InDetV0FinderTool.h.

199{};

◆ m_iGammaFitter

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

private

Initial value:

{

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

Definition at line 135 of file InDetV0FinderTool.h.

135 {

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

◆ m_iKshortFitter

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

private

Initial value:

{

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

Definition at line 129 of file InDetV0FinderTool.h.

129 {

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

◆ m_iLambdabarFitter

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

private

Initial value:

{

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

Definition at line 133 of file InDetV0FinderTool.h.

133 {

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

◆ m_iLambdaFitter

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

private

Initial value:

{

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

Definition at line 131 of file InDetV0FinderTool.h.

131 {

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

◆ m_iVertexFitter

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

private

Initial value:

{

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

Definition at line 125 of file InDetV0FinderTool.h.

125 {

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

◆ m_iVKVertexFitter

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

private

Initial value:

{

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

Definition at line 127 of file InDetV0FinderTool.h.

127 {

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

◆ m_Kshort_stored

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

mutableprivate

Definition at line 196 of file InDetV0FinderTool.h.

196{};

◆ m_ksKey

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

private

Definition at line 246 of file InDetV0FinderTool.h.

246{ this, "KshortContainerName", "KshortCandidates", "Ks container name (same calling alg)" };

◆ m_ksmax

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

private

max Kshort mass (600.

MeV)

Definition at line 175 of file InDetV0FinderTool.h.

175{this, "ksmax", 600.};

◆ m_ksmin

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

private

min Kshort mass (400.

MeV)

Definition at line 174 of file InDetV0FinderTool.h.

174{this, "ksmin", 400.};

◆ 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 247 of file InDetV0FinderTool.h.

247 { this, "LambdaContainerName", "LambdaCandidates",

248 "Lambda container name (same calling alg)" };

◆ m_lamax

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

private

max Lambda mass (1200.

MeV)

Definition at line 177 of file InDetV0FinderTool.h.

177{this, "lamax", 1200.};

◆ m_Lambda_stored

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

mutableprivate

Definition at line 197 of file InDetV0FinderTool.h.

197{};

◆ m_Lambdabar_stored

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

mutableprivate

Definition at line 198 of file InDetV0FinderTool.h.

198{};

◆ m_lamin

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

private

min Lambda mass (1000.

MeV)

Definition at line 176 of file InDetV0FinderTool.h.

176{this, "lamin", 1000.};

◆ 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 249 of file InDetV0FinderTool.h.

249 { this, "LambdabarContainerName", "LambdabarCandidates",

250 "Lambdabar container name (same calling alg)" };

◆ m_masse

DoubleProperty InDet::InDetV0FinderTool::m_masse {this, "masse", ParticleConstants::electronMassInMeV}

private

electron mass (0.510999 MeV)

Definition at line 165 of file InDetV0FinderTool.h.

165{this, "masse", ParticleConstants::electronMassInMeV};

ParticleConstants::PDG2011::electronMassInMeV

constexpr double electronMassInMeV

the mass of the electron (in MeV)

Definition ParticleConstants.h:26

◆ m_masses

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

private

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

Definition at line 162 of file InDetV0FinderTool.h.

162{this, "masses", 1};

◆ m_massK0S

DoubleProperty InDet::InDetV0FinderTool::m_massK0S {this, "massK0S", ParticleConstants::KZeroMassInMeV}

private

Kshort mass (497.672 MeV)

Definition at line 166 of file InDetV0FinderTool.h.

166{this, "massK0S", ParticleConstants::KZeroMassInMeV};

ParticleConstants::PDG2011::KZeroMassInMeV

constexpr double KZeroMassInMeV

the mass of the neutral kaon (K0) (in MeV)

Definition ParticleConstants.h:47

◆ m_massLambda

DoubleProperty InDet::InDetV0FinderTool::m_massLambda {this, "massLambda", ParticleConstants::lambdaMassInMeV}

private

Lambda mass (1115.68 MeV)

Definition at line 167 of file InDetV0FinderTool.h.

167{this, "massLambda", ParticleConstants::lambdaMassInMeV};

ParticleConstants::PDG2011::lambdaMassInMeV

constexpr double lambdaMassInMeV

the mass of the lambda baryon (in MeV)

Definition ParticleConstants.h:74

◆ m_massp

DoubleProperty InDet::InDetV0FinderTool::m_massp {this, "massp", ParticleConstants::protonMassInMeV}

private

proton mass (938.272 MeV)

Definition at line 164 of file InDetV0FinderTool.h.

164{this, "massp", ParticleConstants::protonMassInMeV};

ParticleConstants::PDG2011::protonMassInMeV

constexpr double protonMassInMeV

the mass of the proton (in MeV)

Definition ParticleConstants.h:71

◆ m_masspi

DoubleProperty InDet::InDetV0FinderTool::m_masspi {this, "masspi", ParticleConstants::chargedPionMassInMeV}

private

pion mass (139.57 MeV)

Definition at line 163 of file InDetV0FinderTool.h.

163{this, "masspi", ParticleConstants::chargedPionMassInMeV};

ParticleConstants::PDG2011::chargedPionMassInMeV

constexpr double chargedPionMassInMeV

the mass of the charged pion (in MeV)

Definition ParticleConstants.h:41

◆ m_max_d0_cut

DoubleProperty InDet::InDetV0FinderTool::m_max_d0_cut {this, "max_d0_cut", 999999.}

private

track |d0| wrt a vertex (<999999.)

Definition at line 182 of file InDetV0FinderTool.h.

182{this, "max_d0_cut", 999999.};

◆ m_max_z0_cut

DoubleProperty InDet::InDetV0FinderTool::m_max_z0_cut {this, "max_z0_cut", 999999.}

private

track |z0| wrt a vertex (<999999.)

Definition at line 183 of file InDetV0FinderTool.h.

183{this, "max_z0_cut", 999999.};

◆ m_maxPV

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

private

Definition at line 251 of file InDetV0FinderTool.h.

251{ this, "MaxPV", 999999 };

◆ m_maxsxy

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

private

Maximum Rxy of starting point (1000.

mm)

Definition at line 169 of file InDetV0FinderTool.h.

169{this, "maxsxy", 1000.};

◆ m_mDecor_gfit

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

private

Definition at line 231 of file InDetV0FinderTool.h.

◆ m_mDecor_gmass

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

private

Definition at line 232 of file InDetV0FinderTool.h.

◆ m_mDecor_gmasserr

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

private

Definition at line 233 of file InDetV0FinderTool.h.

◆ m_mDecor_gprob

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

private

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

180{this, "minConstrVertProb", 0.0001};

◆ m_minVertProb

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

private

Minimum vertex probability (0.0001)

Definition at line 179 of file InDetV0FinderTool.h.

179{this, "minVertProb", 0.0001};

◆ m_particleDataTable

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

private

Definition at line 148 of file InDetV0FinderTool.h.

◆ m_partPropSvc

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

private

Definition at line 255 of file InDetV0FinderTool.h.

255{this, "PartPropSvc", "PartPropSvc"};

◆ m_ptTRT

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

private

Minimum pT for TRT tracks (700.

MeV)

Definition at line 168 of file InDetV0FinderTool.h.

168{this, "ptTRT", 700.};

◆ m_pv

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

private

= true select tracks wrt primary vertex (false)

Definition at line 153 of file InDetV0FinderTool.h.

153{this, "trkSelPV", false};

◆ 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 252 of file InDetV0FinderTool.h.

252{this, "RelinkTracks", {}, "Track Containers if they need to be relinked through indirect use" };

◆ m_samesign

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

private

= true select tracks with same sign (false)

Definition at line 152 of file InDetV0FinderTool.h.

152{this, "AddSameSign", false};

◆ m_trackParticleKey

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

private

Initial value:

{ this, "TrackParticleCollection", "InDetTrackParticles",

"key for retrieval of TrackParticles" }

Definition at line 122 of file InDetV0FinderTool.h.

122 { this, "TrackParticleCollection", "InDetTrackParticles",

123 "key for retrieval of TrackParticles" };

◆ m_trackToVertexTool

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

private

Initial value:

{

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

Definition at line 139 of file InDetV0FinderTool.h.

139 {

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

◆ m_trkSelector

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

private

Initial value:

{

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

Definition at line 141 of file InDetV0FinderTool.h.

141 {

142 this, "TrackSelectorTool", "InDet::TrackSelectorTool"};

◆ m_uksmax

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

private

max Kshort mass, unconstrained fit (600.

MeV)

Definition at line 171 of file InDetV0FinderTool.h.

171{this, "uksmax", 600.};

◆ m_uksmin

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

private

min Kshort mass, unconstrained fit (400.

MeV)

Definition at line 170 of file InDetV0FinderTool.h.

170{this, "uksmin", 400.};

◆ m_ulamax

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

private

max Lambda mass, unconstrained fit (1200.

MeV)

Definition at line 173 of file InDetV0FinderTool.h.

173{this, "ulamax", 1200.};

◆ m_ulamin

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

private

min Lambda mass, unconstrained fit (1000.

MeV)

Definition at line 172 of file InDetV0FinderTool.h.

172{this, "ulamin", 1000.};

◆ m_use_innerPixHits

BooleanProperty InDet::InDetV0FinderTool::m_use_innerPixHits {this, "use_innerPixHits", false}

private

= true select allows tracks with no innermost pixel layer hits to always pass d0 significance cut (false)

Definition at line 158 of file InDetV0FinderTool.h.

158{this, "use_innerPixHits", false};

◆ m_use_vertColl

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

private

= true select tracks wrt a vertex collection (false)

Definition at line 154 of file InDetV0FinderTool.h.

154{this, "useVertexCollection", false};

◆ m_useBDT

BooleanProperty InDet::InDetV0FinderTool::m_useBDT {this, "useBDT", false}

private

= true uses BDT selections in place of rectangular pointAtVertex + minVertProb

Definition at line 159 of file InDetV0FinderTool.h.

159{this, "useBDT", false};

◆ m_useBeamSpotCond

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

private

Definition at line 243 of file InDetV0FinderTool.h.

243{ this, "UseBeamSpotCond", false };

◆ m_useorigin

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

private

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

Definition at line 151 of file InDetV0FinderTool.h.

151{this, "useorigin", true};

◆ m_useTrkSel

BooleanProperty InDet::InDetV0FinderTool::m_useTrkSel {this, "use_TrackSelector", true}

private

= true uses TrackSelectorTool

Definition at line 160 of file InDetV0FinderTool.h.

160{this, "use_TrackSelector", true};

◆ m_useTRTplusSi

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

private

= use TRT+Si pairs (true)

Definition at line 156 of file InDetV0FinderTool.h.

156{this, "useTRTplusSi", false};

◆ m_useTRTplusTRT

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

private

= use TRT+TRT pairs (true)

Definition at line 155 of file InDetV0FinderTool.h.

155{this, "useTRTplusTRT", false};

◆ m_useV0Fitter

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

private

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

Definition at line 157 of file InDetV0FinderTool.h.

157{this, "useV0Fitter", false};

◆ m_v0_BDTScore

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

private

Definition at line 236 of file InDetV0FinderTool.h.

◆ m_v0_ksLinksDecorkey

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

private

Definition at line 227 of file InDetV0FinderTool.h.

◆ m_v0_laLinksDecorkey

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

private

Definition at line 228 of file InDetV0FinderTool.h.

◆ m_v0_lbLinksDecorkey

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

private

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

245{ this, "V0ContainerName", "V0Candidates", "V0 container name (same calling alg)" };

◆ m_v0LinksDecorkeyks

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

private

Definition at line 224 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeylb

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

private

Definition at line 225 of file InDetV0FinderTool.h.

◆ m_v0LinksDecorkeylbb

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

private

Definition at line 226 of file InDetV0FinderTool.h.

◆ m_V0s_stored

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

mutableprivate

Definition at line 195 of file InDetV0FinderTool.h.

195{};

◆ m_V0Tools

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

private

Initial value:

{

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

Definition at line 137 of file InDetV0FinderTool.h.

137 {

138 this, "V0Tools", "Trk::V0Tools"};

◆ 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 186 of file InDetV0FinderTool.h.

186{this, "vert_a0xy_cut", 3.};

◆ 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 187 of file InDetV0FinderTool.h.

187{this, "vert_a0z_cut", 15.};

◆ m_vert_cos_cut

DoubleProperty InDet::InDetV0FinderTool::m_vert_cos_cut {this, "vert_cos_cut", 0.}

private

V0 cos(theta) angle between displacement and momentum (>0.)

Definition at line 188 of file InDetV0FinderTool.h.

188{this, "vert_cos_cut", 0.};

◆ 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 185 of file InDetV0FinderTool.h.

185{this, "vert_lxy_cut", 500.};

◆ 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 184 of file InDetV0FinderTool.h.

184{this, "vert_lxy_sig", 2.};

◆ m_vertexEstimator

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

private

Initial value:

{

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

Definition at line 143 of file InDetV0FinderTool.h.

143 {

144 this, "VertexPointEstimator", "InDet::VertexPointEstimator"};

◆ m_vertexKey

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

private

Initial value:

{ this, "VertexContainer", "PrimaryVertices",

"primary vertex container" }

Definition at line 222 of file InDetV0FinderTool.h.

222 { this, "VertexContainer", "PrimaryVertices",

223 "primary vertex container" };

◆ 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/4]

◆ d0Pass() [2/4]

◆ d0Pass() [3/4]

◆ d0Pass() [4/4]

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ doFit()

◆ doMassFit()

◆ evtStore()

◆ extraDeps_update_handler()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ invariantMass()

◆ makeLink()

◆ massFit()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ performSearch()

◆ pointAtVertex()

◆ pointAtVertexColl()

◆ renounce()

◆ renounceArray()

◆ SGError()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_BDT

◆ m_BDTCut

◆ m_BDTFile

◆ 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

◆ m_lamin

◆ m_lbKey

◆ m_masse

◆ m_masses

◆ m_massK0S

◆ m_massLambda