ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
InDet::InDetV0FinderTool Class Reference

#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, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Static Public Member Functions

static 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::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> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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...
 
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) More...
 
BooleanProperty m_useBDT {this, "useBDT", false}
 = true uses BDT selections in place of rectangular pointAtVertex + minVertProb More...
 
BooleanProperty m_useTrkSel {this, "use_TrackSelector", true}
 = true uses TrackSelectorTool More...
 
IntegerProperty m_masses {this, "masses", 1}
 = 1 if using PDG values, = 2 if user set (1) More...
 
DoubleProperty m_masspi {this, "masspi", ParticleConstants::chargedPionMassInMeV}
 pion mass (139.57 MeV) More...
 
DoubleProperty m_massp {this, "massp", ParticleConstants::protonMassInMeV}
 proton mass (938.272 MeV) More...
 
DoubleProperty m_masse {this, "masse", ParticleConstants::electronMassInMeV}
 electron mass (0.510999 MeV) More...
 
DoubleProperty m_massK0S {this, "massK0S", ParticleConstants::KZeroMassInMeV}
 Kshort mass (497.672 MeV) More...
 
DoubleProperty m_massLambda {this, "massLambda", ParticleConstants::lambdaMassInMeV}
 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_max_d0_cut {this, "max_d0_cut", 999999.}
 track |d0| wrt a vertex (<999999.) More...
 
DoubleProperty m_max_z0_cut {this, "max_z0_cut", 999999.}
 track |z0| wrt a vertex (<999999.)
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...
 
DoubleProperty m_vert_cos_cut {this, "vert_cos_cut", 0.}
 V0 cos(theta) angle between displacement and momentum (>0.) More...
 
DoubleProperty m_BDTCut {this, "BDTCut", -1}
 BDT Score threshold. More...
 
StringProperty m_BDTFile {this, "BDTFile", "XGBModelBetterVertex.root"}
 Filename of mvaUtils model file, located in /InDetV0FinderTool/BDT/v1/. 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::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) 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 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 45 of file InDetV0FinderTool.cxx.

48  {
49  ATH_CHECK( m_iVertexFitter.retrieve() );
50  ATH_MSG_DEBUG( "Retrieved tool " << m_iVertexFitter);

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

736 {
737  bool pass = false;
738  float v0lxy = m_V0Tools->lxy(v0,PV);
739  float v0lxyError = m_V0Tools->lxyError(v0,PV);
740  float cos = m_V0Tools->cosTheta(v0,PV);
741  float v0a0xy = m_V0Tools->a0xy(v0,PV);
742  float v0a0z = m_V0Tools->a0z(v0,PV);
743  if (m_useBDT){
744  float prob = m_V0Tools->vertexProbability(v0);

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

642  {
643  const xAOD::Vertex* PV = (*vItr);
644  auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV->position() );
645  if (per1 == nullptr) continue;
646  auto per2 = m_trackToVertexTool->perigeeAtVertex(ctx, *track2, PV->position() );
647  if (per2 == nullptr) continue;
648  double d0_1 = per1->parameters()[Trk::d0];
649  double sig_d0_1 = sqrt((*per1->covariance())(0,0));
650  double delta_z0_1 = track1->z0() + track1->vz() - PV->z();
651  double d0_2 = per2->parameters()[Trk::d0];
652  double sig_d0_2 = sqrt((*per2->covariance())(0,0));
653  double delta_z0_2 = track2->z0() + track2->vz() - PV->z();
654  bool IP_check1 = (std::abs(d0_1/sig_d0_1) > m_d0_cut) || !hasInnerPixHit1;
655  IP_check1 &= std::abs(d0_1) < m_max_d0_cut;
656  IP_check1 &= std::abs(delta_z0_1) < m_max_z0_cut;
657  bool IP_check2 = (std::abs(d0_2/sig_d0_2) > m_d0_cut) || !hasInnerPixHit2;
658  IP_check2 &= std::abs(d0_2) < m_max_d0_cut;
659  IP_check2 &= std::abs(delta_z0_2) < m_max_z0_cut;
660  if (IP_check1 && IP_check2) return true;
661  if (++count >= m_maxPV) break;
662  }
663  return pass;
664 }
665 
666 bool InDetV0FinderTool::d0Pass(const xAOD::TrackParticle* track1, const xAOD::VertexContainer * vertColl, const EventContext& ctx) const
667 {
668  bool pass = false;
669  int count = 0;
670  bool hasInnerPixHit1 = true;
671  if (m_use_innerPixHits){
672  SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
673  uint8_t nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
674  if (nInnerHits1 == 0) hasInnerPixHit1 = false;
675  }

◆ d0Pass() [3/4]

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

Definition at line 704 of file InDetV0FinderTool.cxx.

715 {
716  bool pass = false;
717  bool hasInnerPixHit1 = true;
718  if (m_use_innerPixHits){
719  SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
720  uint8_t nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
721  if (nInnerHits1 == 0) hasInnerPixHit1 = false;
722  }
723  auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV );

◆ d0Pass() [4/4]

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

Definition at line 677 of file InDetV0FinderTool.cxx.

677  {
678  const xAOD::Vertex* PV = (*vItr);
679  auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV->position() );
680  if (per1 == nullptr) continue;
681  double d0_1 = per1->parameters()[Trk::d0];
682  double sig_d0_1 = sqrt((*per1->covariance())(0,0));
683  double delta_z0_1 = track1->z0() + track1->vz() - PV->z();
684  if (((std::abs(d0_1/sig_d0_1) > m_d0_cut) ||
685  (!hasInnerPixHit1)) &&
686  (std::abs(d0_1) < m_max_d0_cut) &&
687  (std::abs(delta_z0_1) < m_max_z0_cut)) return true;
688  if (++count >= m_maxPV) break;
689  }
690  return pass;
691 }
692 
693 bool InDetV0FinderTool::d0Pass(const xAOD::TrackParticle* track1, const xAOD::Vertex* PV, const EventContext& ctx) const
694 {
695  bool pass = false;
696  bool hasInnerPixHit1 = true;
697  if (m_use_innerPixHits){
698  SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
699  uint8_t nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
700  if (nInnerHits1 == 0) hasInnerPixHit1 = false;
701  }
702  auto per1 = m_trackToVertexTool->perigeeAtVertex(ctx, *track1, PV->position() );

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

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

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

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

615  {
616  massKshort_i = invariantMass(extrapolatedPerigee1,extrapolatedPerigee2,m_masspi,m_masspi);
617  massLambda_i = invariantMass(extrapolatedPerigee1,extrapolatedPerigee2,m_massp,m_masspi);
618  massLambdabar_i = invariantMass(extrapolatedPerigee1,extrapolatedPerigee2,m_masspi,m_massp);
619  if ( ((massKshort_i >= m_uksmin && massKshort_i <= m_uksmax) ||
620  (massLambda_i >= m_ulamin && massLambda_i <= m_ulamax) ||
621  (massLambdabar_i >= m_ulamin && massLambdabar_i <= m_ulamax)) ) pass = true;
622  }
623  }
624 
625  return pass;
626 }
627 
628 bool InDetV0FinderTool::d0Pass(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2, const xAOD::VertexContainer * vertColl, const EventContext& ctx) const
629 {
630  bool pass = false;
631  int count = 0;
632  bool hasInnerPixHit1 = true;
633  bool hasInnerPixHit2 = true;
634  if (m_use_innerPixHits){
635  SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
636  uint8_t nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
637  if (nInnerHits1 == 0) hasInnerPixHit1 = false;

◆ doMassFit()

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

Definition at line 799 of file InDetV0FinderTool.cxx.

802  {
803  winmass_min = m_lamin;
804  winmass_max = m_lamax;
805  if (pdgID == 3122) {
806  mass = m_V0Tools->invariantMass(vxCandidate,m_massp,m_masspi);
807  error = m_V0Tools->invariantMassError(vxCandidate,m_massp,m_masspi);
808  } else if (pdgID == -3122) {
809  mass = m_V0Tools->invariantMass(vxCandidate,m_masspi,m_massp);
810  error = m_V0Tools->invariantMassError(vxCandidate,m_masspi,m_massp);
811  }
812  if (mass >= winmass_min && mass <= winmass_max && error <= m_errmass) in_mass_window = true;
813  }
814  if (in_mass_window) pass = true;
815 
816  return pass;
817 }
818 
819 xAOD::Vertex* InDetV0FinderTool::massFit(int pdgID, const std::vector<const xAOD::TrackParticle*> &pairV0, const Amg::Vector3D &vertex) const
820 {
821  xAOD::Vertex* vxCandidate(nullptr);
822  std::vector<double> masses;
823  if (pdgID == 310) {
824  masses.push_back(m_masspi);
825  masses.push_back(m_masspi);
826  } else if (pdgID == 3122) {
827  masses.push_back(m_massp);
828  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 584 of file InDetV0FinderTool.cxx.

589 {
590  ATH_MSG_FATAL(errService << " not found. Exiting !");
591 }
592 
593 
594 bool InDetV0FinderTool::doFit(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2,
595  Amg::Vector3D &startingPoint, const EventContext& ctx) const
596 {
597  bool pass = false;

◆ initialize()

StatusCode InDet::InDetV0FinderTool::initialize ( )

Definition at line 54 of file InDetV0FinderTool.cxx.

121  {
122  std::string BDTPathName = "InDetV0FinderTool/BDT/v1/" + m_BDTFile;
123  std::string fullPathToFile = PathResolverFindCalibFile(BDTPathName);
124  ATH_MSG_DEBUG("Using BDT File: " << fullPathToFile);
125  std::unique_ptr<TFile> rootFile(TFile::Open(fullPathToFile.c_str(), "READ"));
126  std::string strBDTName = "xgboost";
127  std::unique_ptr<TTree> training( (TTree*)rootFile->Get(strBDTName.c_str()) );
128  m_BDT = std::make_unique<MVAUtils::BDT>(training.get());
129  }
130 
131  ATH_CHECK( m_eventInfo_key.initialize(!m_useBeamSpotCond));
132  ATH_CHECK( m_beamSpotKey.initialize( m_useBeamSpotCond));
133  ATH_CHECK( m_beamSpotDecoKey.initialize(!m_useBeamSpotCond));
134 
135 // Get the track selector tool from ToolSvc
136  ATH_CHECK( m_trkSelector.retrieve() );
137  ATH_MSG_DEBUG("Retrieved tool " << m_trkSelector);
138 
139 // Get the vertex point estimator tool from ToolSvc
140  ATH_CHECK( m_vertexEstimator.retrieve() );
141  ATH_MSG_DEBUG("Retrieved tool " << m_vertexEstimator);
142 
143  const HepPDT::ParticleData* pd_pi = m_particleDataTable->particle(MC::PIPLUS);
144  const HepPDT::ParticleData* pd_p = m_particleDataTable->particle(MC::PROTON);
145  const HepPDT::ParticleData* pd_e = m_particleDataTable->particle(MC::ELECTRON);
146  const HepPDT::ParticleData* pd_K = m_particleDataTable->particle(MC::K0S);
147  const HepPDT::ParticleData* pd_L = m_particleDataTable->particle(MC::LAMBDA0);
148  if (m_masses == 1) {
149  m_masspi = pd_pi->mass();
150  m_massp = pd_p->mass();
151  m_masse = pd_e->mass();
152  m_massK0S = pd_K->mass();
153  m_massLambda = pd_L->mass();
154  }
155 
156  m_events_processed = 0;
157  m_V0s_stored = 0;
158  m_Kshort_stored = 0;
159  m_Lambdabar_stored = 0;
160  m_Lambda_stored = 0;
161  m_Gamma_stored = 0;
162 
163 // making a concrete fitter for the V0Fitter
164  m_concreteVertexFitter = nullptr;
165  if (m_useV0Fitter) {
166  m_concreteVertexFitter = dynamic_cast<Trk::TrkV0VertexFitter * >(&(*m_iVertexFitter));
167  if (m_concreteVertexFitter == nullptr) {
168  ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
169  return StatusCode::FAILURE;
170  }
171  }
172 
173  ATH_CHECK(m_RelinkContainers.initialize());
174 
175  ATH_MSG_DEBUG( "Initialization successful" );
176 
177  return StatusCode::SUCCESS;
178 }
179 
180 StatusCode InDetV0FinderTool::performSearch(xAOD::VertexContainer* v0Container,
181  xAOD::VertexContainer* ksContainer,
182  xAOD::VertexContainer* laContainer,
183  xAOD::VertexContainer* lbContainer,
184  const xAOD::Vertex* primaryVertex,
185  const xAOD::VertexContainer* vertColl,
186  const EventContext& ctx
187  ) const
188 {
189 

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

110 { return IID_InDetV0FinderTool;}

◆ invariantMass()

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

Definition at line 787 of file InDetV0FinderTool.cxx.

789 {
790  bool pass = false;
791  double mass = 1000000000.;
792  double error = 1000000001.;
793  bool in_mass_window = false;
794  double winmass_min = 0., winmass_max = 0.;
795 
796  if (pdgID == 310) {
797  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 876 of file InDetV0FinderTool.cxx.

877  {
878  Link.setStorableObject(*trkcol, true);
879  elementSet = true;
880  break;
881  }
882  }
883  }
884  if(!elementSet) ATH_MSG_ERROR("Track was not found when linking");
885  return Link;
886 }
887 
888 
889 }//end of namespace InDet
890 

◆ massFit()

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

Definition at line 830 of file InDetV0FinderTool.cxx.

832  {
833  masses.push_back(m_masse);
834  masses.push_back(m_masse);
835  }
836 
837  if (pdgID == 22) {
838  vxCandidate = m_iGammaFitter->fit(pairV0, vertex);
839  }
840  if (pdgID == 310) {
841  if (m_useV0Fitter) {
842  vxCandidate = m_concreteVertexFitter->fit(pairV0, masses, m_massK0S, nullptr, vertex);
843  } else {
844  vxCandidate = m_iKshortFitter->fit(pairV0, vertex);
845  }
846  }
847  if (pdgID == 3122) {
848  if (m_useV0Fitter) {
849  vxCandidate = m_concreteVertexFitter->fit(pairV0, masses, m_massLambda, nullptr, vertex);
850  } else {
851  vxCandidate = m_iLambdaFitter->fit(pairV0, vertex);
852  }
853  }
854  if (pdgID == -3122) {
855  if (m_useV0Fitter) {
856  vxCandidate = m_concreteVertexFitter->fit(pairV0, masses, m_massLambda, nullptr, vertex);
857  } else {
858  vxCandidate = m_iLambdabarFitter->fit(pairV0, vertex);
859  }
860  }
861 
862  return vxCandidate;
863 }
864 
865 ElementLink<xAOD::TrackParticleContainer> InDetV0FinderTool::makeLink(const xAOD::TrackParticle* tp,
866  const std::vector<const xAOD::TrackParticleContainer*>& trackcols) const
867 {
868  ElementLink<xAOD::TrackParticleContainer> Link;
869  Link.setElement(tp);
870  bool elementSet = false;
871  if(trackcols.empty()){
872  Link.setStorableObject( *dynamic_cast<const xAOD::TrackParticleContainer*>( tp->container() ) );
873  elementSet = true;
874  } else {

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

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

192  : m_RelinkContainers){
193  SG::ReadHandle<xAOD::TrackParticleContainer> handle(str,ctx);
194  trackCols.push_back(handle.cptr());
195  }
196 
197  m_events_processed ++;
198 
199  //Retrieve vertices for overlap removal
200  SG::ReadHandle<xAOD::VertexContainer> vertices { m_vertexKey, ctx };
201  if (!vertices.isValid())
202  {
203  ATH_MSG_WARNING("Primary vertex container with key " << m_vertexKey.key() << " not found");
204  return StatusCode::SUCCESS;
205  }
206 
207 // Retrieve track particles from StoreGate
208  SG::ReadHandle<xAOD::TrackParticleContainer> TPC( m_trackParticleKey, ctx );
209  if ( !TPC.isValid() )
210  {
211  ATH_MSG_ERROR("Input TrackParticle collection is invalid!");
212  return StatusCode::SUCCESS;
213  }
214  ATH_MSG_DEBUG("Track particle container size " << TPC->size());
215 
216  if (m_use_vertColl) {
217  ATH_MSG_DEBUG("Vertex container size " << vertColl->size());
218  }
219  Amg::Vector3D beamspot;
220  if(m_useBeamSpotCond){
221  auto beamSpotHandle = SG::ReadCondHandle(m_beamSpotKey, ctx);
222  beamspot = beamSpotHandle->beamPos();
223  }else{
224  SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosX(m_beamSpotDecoKey[0], ctx);
225  SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosY(m_beamSpotDecoKey[1], ctx);
226  SG::ReadDecorHandle<xAOD::EventInfo, float> beamPosZ(m_beamSpotDecoKey[2], ctx);
227  beamspot = Amg::Vector3D(beamPosX(0), beamPosY(0), beamPosZ(0));
228  }
229 // track preselection
230  std::vector<const xAOD::TrackParticle*> posTracks; posTracks.clear();
231  std::vector<const xAOD::TrackParticle*> negTracks; negTracks.clear();
232  const xAOD::Vertex* vx = nullptr;
233  if (m_pv && primaryVertex) vx = primaryVertex;
234 
235  if (TPC->size() > 1) {
236  xAOD::TrackParticleContainer::const_iterator tpIt;
237  for ( tpIt=TPC->begin(); tpIt!=TPC->end(); ++tpIt )
238  {
239  const xAOD::TrackParticle* TP = (*tpIt);
240  double charge = TP->charge();
241 
242  if (m_trkSelector->decision(*TP, vx) || (!m_useTrkSel))
243  {
244  //PV Track Overlap Selections
245  const xAOD::Vertex* foundVertex { nullptr };
246  if (m_useorigin)
247  {
248  for (const auto *const vx : *vertices)
249  {
250  for (const auto& tpLink : vx->trackParticleLinks())
251  {
252  if (*tpLink == TP)
253  {
254  foundVertex = vx;
255  break;
256  }
257  }
258  if (foundVertex) break;
259  }
260  }
261  bool useTrack = false;
262  if (!m_useorigin) useTrack = true;
263  if (m_useorigin && foundVertex == nullptr) useTrack = true;
264  if (!useTrack) continue;
265 
266 
267  //d0 Selections
268  bool d0wrtVertex = true;
269  if (m_use_vertColl) {
270  if ( !d0Pass(TP,vertColl, ctx) ) d0wrtVertex = false;
271  }
272  if (!m_use_vertColl && m_pv) {
273  if (primaryVertex) {
274  if ( !d0Pass(TP,primaryVertex, ctx) ) d0wrtVertex = false;
275  } else {
276  if ( !d0Pass(TP,beamspot, ctx) ) d0wrtVertex = false;
277  }
278  }
279  if (!d0wrtVertex) continue;
280 
281  if (m_samesign) {
282  posTracks.push_back(TP);
283  negTracks.push_back(TP);
284  } else {
285  if (charge > 0) {
286  posTracks.push_back(*tpIt);
287  } else {
288  negTracks.push_back(*tpIt);
289  }
290  }
291  }
292  }
293  }
294  ATH_MSG_DEBUG("number of tracks passing preselection, positive " << posTracks.size() << " negative " << negTracks.size());
295 
296  if (!posTracks.empty() && !negTracks.empty())
297  {
298 
299 
300  SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0LinksDecorks(m_v0LinksDecorkeyks, ctx);
301  SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0LinksDecorlb(m_v0LinksDecorkeylb, ctx);
302  SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0LinksDecorlbb(m_v0LinksDecorkeylbb, ctx);
303  SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0_ksLinksDecor(m_v0_ksLinksDecorkey, ctx);
304  SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0_laLinksDecor(m_v0_laLinksDecorkey, ctx);
305  SG::WriteDecorHandle<xAOD::VertexContainer, ElementLink<xAOD::VertexContainer>> v0_lbLinksDecor(m_v0_lbLinksDecorkey, ctx);
306  SG::WriteDecorHandle<xAOD::VertexContainer, int> mDecor_gfit(m_mDecor_gfit, ctx);
307  SG::WriteDecorHandle<xAOD::VertexContainer, float> mDecor_gmass(m_mDecor_gmass, ctx);
308  SG::WriteDecorHandle<xAOD::VertexContainer, float> mDecor_gmasserr(m_mDecor_gmasserr, ctx);
309  SG::WriteDecorHandle<xAOD::VertexContainer, float> mDecor_gprob(m_mDecor_gprob, ctx);
310 
311  SG::WriteDecorHandle<xAOD::VertexContainer, float> v0_BDTScore(m_v0_BDTScore, ctx);
312 
313  std::vector<const xAOD::TrackParticle*>::const_iterator tpIt1;
314  std::vector<const xAOD::TrackParticle*>::const_iterator tpIt2;
315  unsigned int i1 = 0;
316  for (tpIt1 = posTracks.begin(); tpIt1 != posTracks.end(); ++tpIt1)
317  {
318  const xAOD::TrackParticle* TP1 = (*tpIt1);
319  uint8_t temp1(0);
320  uint8_t nclus1(0);
321  if ( TP1->summaryValue( temp1 , xAOD::numberOfPixelHits) ) nclus1 += temp1;
322  if ( TP1->summaryValue( temp1 , xAOD::numberOfSCTHits) ) nclus1 += temp1;
323  double pt1 = TP1->pt();
324 
325  unsigned int i2 = 0;
326  for (tpIt2 = negTracks.begin(); tpIt2 != negTracks.end(); ++tpIt2)
327  {
328  if (*tpIt1 == *tpIt2) continue;
329  if (m_samesign && i1 <= i2) continue;
330 
331  const xAOD::TrackParticle* TP2 = (*tpIt2);
332  uint8_t temp2(0);
333  uint8_t nclus2(0);
334  if ( TP2->summaryValue( temp2 , xAOD::numberOfPixelHits) ) nclus2 += temp2;
335  if ( TP2->summaryValue( temp2 , xAOD::numberOfSCTHits) ) nclus2 += temp2;
336  ATH_MSG_DEBUG("nclus1 " << (int)nclus1 << " nclus2 " << (int)nclus2);
337 
338  if (!m_useTRTplusTRT && nclus1 == 0 && nclus2 == 0) continue;
339  if (!m_useTRTplusSi && (nclus1 == 0 || nclus2 == 0)) continue;
340 
341  double pt2 = TP2->pt();
342 
343  bool trk_cut1 = false;
344  bool trk_cut2 = false;
345  if (nclus1 != 0) trk_cut1 = true;
346  if (nclus1 == 0 && pt1 >= m_ptTRT) trk_cut1 = true;
347  if (!trk_cut1) continue;
348  if (nclus2 != 0) trk_cut2 = true;
349  if (nclus2 == 0 && pt2 >= m_ptTRT) trk_cut2 = true;
350  if (!trk_cut2) continue;
351 
352 // find a starting point
353  const Trk::Perigee& aPerigee1 = TP1->perigeeParameters();
354  const Trk::Perigee& aPerigee2 = TP2->perigeeParameters();
355  int sflag = 0;
356  int errorcode = 0;
357  Amg::Vector3D startingPoint = m_vertexEstimator->getCirclesIntersectionPoint(&aPerigee1,&aPerigee2,sflag,errorcode);
358  if (errorcode != 0) {startingPoint(0) = 0.0; startingPoint(1) = 0.0; startingPoint(2) = 0.0;}
359  bool errorCode = false;
360  if (errorcode == 0 || errorcode == 5 || errorcode == 6 || errorcode == 8) errorCode = true;
361  if (!errorCode) continue;
362 
363  //re-do d0 selection if using m_use_vertColl to ensure both tracks pass for the SAME vertex
364  bool d0wrtVertex = true;
365  if (m_use_vertColl) {
366  if ( !d0Pass(TP1,TP2,vertColl, ctx) ) d0wrtVertex = false;
367  }
368  if (!d0wrtVertex) continue;
369 
370 
371 // pair pre-selection cuts
372  if ( doFit(TP1,TP2,startingPoint, ctx) )
373  {
374  std::vector<const xAOD::TrackParticle*> pairV0;
375  pairV0.clear();
376  pairV0.push_back(TP1);
377  pairV0.push_back(TP2);
378 
379 // vertex fit
380  ATH_MSG_DEBUG("unconstrained fit now");
381 
382  std::unique_ptr<xAOD::Vertex> myVxCandidate;
383  if (m_useV0Fitter) {
384  myVxCandidate = std::unique_ptr<xAOD::Vertex>( m_concreteVertexFitter->fit(pairV0, startingPoint) );
385  } else {
386  myVxCandidate = std::unique_ptr<xAOD::Vertex>( m_iVKVertexFitter->fit(pairV0, startingPoint) );
387  }
388 
389  if (myVxCandidate)
390  {
391  myVxCandidate->setVertexType(xAOD::VxType::V0Vtx);
392  if ( (m_V0Tools->vertexProbability(myVxCandidate.get()) >= m_minVertProb) || (m_useBDT) ) // If using BDT selections, it makes VertProb Selections
393  {
394  bool doKshortFit = false;
395  doKshortFit = doMassFit(myVxCandidate.get(),310);
396  bool doLambdaFit = false;
397  doLambdaFit = doMassFit(myVxCandidate.get(),3122);
398  bool doLambdabarFit = false;
399  doLambdabarFit = doMassFit(myVxCandidate.get(),-3122);
400  float score = 0; // BDT score variable
401  if (doKshortFit || doLambdaFit || doLambdabarFit)
402  {
403  bool pointAtVert = true;
404  if (m_use_vertColl) {
405  if ( !pointAtVertexColl(myVxCandidate.get(),vertColl,score) ) pointAtVert = false;
406  }
407  if (!m_use_vertColl && m_pv && primaryVertex) {
408  if ( !pointAtVertex(myVxCandidate.get(),primaryVertex,score) ) pointAtVert = false;
409  }
410  if (m_doSimpleV0) pointAtVert = true;
411  if (pointAtVert)
412  {
413  Amg::Vector3D vertex = m_V0Tools->vtx(myVxCandidate.get());
414 
415  std::unique_ptr<xAOD::Vertex> myKshort;
416  std::unique_ptr<xAOD::Vertex> myLambda;
417  std::unique_ptr<xAOD::Vertex> myLambdabar;
418  std::unique_ptr<xAOD::Vertex> myGamma;
419  bool foundKshort = false;
420  bool foundLambda = false;
421  bool foundLambdabar = false;
422 
423  if (doKshortFit && !m_doSimpleV0) {
424  myKshort = std::unique_ptr<xAOD::Vertex>( massFit(310, pairV0, vertex) );
425  if (myKshort) {
426  if (m_V0Tools->vertexProbability(myKshort.get()) >= m_minConstrVertProb) {
427  myKshort->setVertexType(xAOD::VxType::V0Vtx);
428  foundKshort = true;
429  }
430  }
431  }
432 
433  if (doLambdaFit && !m_doSimpleV0) {
434  myLambda = std::unique_ptr<xAOD::Vertex>( massFit(3122, pairV0, vertex) );
435  if (myLambda) {
436  if (m_V0Tools->vertexProbability(myLambda.get()) >= m_minConstrVertProb) {
437  myLambda->setVertexType(xAOD::VxType::V0Vtx);
438  foundLambda = true;
439  }
440  }
441  }
442 
443  if (doLambdabarFit && !m_doSimpleV0) {
444  myLambdabar = std::unique_ptr<xAOD::Vertex>( massFit(-3122, pairV0, vertex));
445  if (myLambdabar) {
446  if (m_V0Tools->vertexProbability(myLambdabar.get()) >= m_minConstrVertProb) {
447  myLambdabar->setVertexType(xAOD::VxType::V0Vtx);
448  foundLambdabar = true;
449  }
450  }
451  }
452 
453  bool doGamma = false;
454  int gamma_fit = 0;
455  double gamma_prob = -1., gamma_mass = -1., gamma_massErr = -1.;
456  if (foundKshort || foundLambda || foundLambdabar) doGamma = true;
457 
458  ElementLink<xAOD::VertexContainer> v0Link;
459  ElementLink<xAOD::VertexContainer> ksLink;
460  ElementLink<xAOD::VertexContainer> laLink;
461  ElementLink<xAOD::VertexContainer> lbLink;
462 
463  if (m_doSimpleV0 || (!m_doSimpleV0 && doGamma)) {
464  m_V0s_stored++;
465  myVxCandidate->clearTracks();
466  ElementLink<xAOD::TrackParticleContainer> newLink1 = makeLink(*tpIt1, trackCols);
467  ElementLink<xAOD::TrackParticleContainer> newLink2 = makeLink(*tpIt2, trackCols);
468  myVxCandidate->addTrackAtVertex(newLink1);
469  myVxCandidate->addTrackAtVertex(newLink2);
470  v0Container->push_back(myVxCandidate.release());
471 
472  v0_BDTScore( *(v0Container->back()) ) = score;// decorate w/ bdt score
473 
474  if (foundKshort && !m_doSimpleV0) {
475  m_Kshort_stored++;
476  myKshort->clearTracks();
477  ElementLink<xAOD::TrackParticleContainer> ksLink1 = makeLink(*tpIt1, trackCols);
478  ElementLink<xAOD::TrackParticleContainer> ksLink2 = makeLink(*tpIt2, trackCols);
479  myKshort->addTrackAtVertex(ksLink1);
480  myKshort->addTrackAtVertex(ksLink2);
481  ksContainer->push_back(myKshort.release());
482 
483  v0Link.setElement(v0Container->back());
484  v0Link.setStorableObject(*v0Container);
485  v0LinksDecorks(*(ksContainer->back())) = v0Link;
486 
487  ksLink.setElement(ksContainer->back());
488  ksLink.setStorableObject(*ksContainer);
489  v0_ksLinksDecor(*(v0Container->back())) = ksLink;
490  } else {
491  v0_ksLinksDecor(*(v0Container->back())) = ksLink;
492  }
493  if (foundLambda && !m_doSimpleV0) {
494  m_Lambda_stored++;
495  myLambda->clearTracks();
496  ElementLink<xAOD::TrackParticleContainer> laLink1 = makeLink(*tpIt1, trackCols);
497  ElementLink<xAOD::TrackParticleContainer> laLink2 = makeLink(*tpIt2, trackCols);
498  myLambda->addTrackAtVertex(laLink1);
499  myLambda->addTrackAtVertex(laLink2);
500  laContainer->push_back(myLambda.release());
501 
502  v0Link.setElement(v0Container->back());
503  v0Link.setStorableObject(*v0Container);
504  v0LinksDecorlb(*(laContainer->back())) = v0Link;
505 
506  laLink.setElement(laContainer->back());
507  laLink.setStorableObject(*laContainer);
508  v0_laLinksDecor(*(v0Container->back())) = laLink;
509  } else {
510  v0_laLinksDecor(*(v0Container->back())) = laLink;
511  }
512  if (foundLambdabar && !m_doSimpleV0) {
513  m_Lambdabar_stored++;
514  myLambdabar->clearTracks();
515  ElementLink<xAOD::TrackParticleContainer> lbLink1 = makeLink(*tpIt1, trackCols);
516  ElementLink<xAOD::TrackParticleContainer> lbLink2 = makeLink(*tpIt2, trackCols);
517  myLambdabar->addTrackAtVertex(lbLink1);
518  myLambdabar->addTrackAtVertex(lbLink2);
519  lbContainer->push_back(myLambdabar.release());
520 
521  v0Link.setElement(v0Container->back());
522  v0Link.setStorableObject(*v0Container);
523  v0LinksDecorlbb(*(lbContainer->back())) = v0Link;
524 
525  lbLink.setElement(lbContainer->back());
526  lbLink.setStorableObject(*lbContainer);
527  v0_lbLinksDecor(*(v0Container->back())) = lbLink;
528  } else {
529  v0_lbLinksDecor(*(v0Container->back())) = lbLink;
530  }
531  if (doGamma && !m_doSimpleV0) {
532  myGamma = std::unique_ptr<xAOD::Vertex>( massFit(22, pairV0, vertex) );
533  if (myGamma && m_V0Tools->vertexProbability(myGamma.get()) >= m_minConstrVertProb) {
534  gamma_fit = 1;
535  gamma_prob = m_V0Tools->vertexProbability(myGamma.get());
536  gamma_mass = m_V0Tools->invariantMass(myGamma.get(),m_masse,m_masse);
537  gamma_massErr = m_V0Tools->invariantMassError(myGamma.get(),m_masse,m_masse);
538  }
539 
540  mDecor_gfit( *(v0Container->back()) ) = gamma_fit;
541  mDecor_gmass( *(v0Container->back()) ) = gamma_mass;
542  mDecor_gmasserr( *(v0Container->back()) ) = gamma_massErr;
543  mDecor_gprob( *(v0Container->back()) ) = gamma_prob;
544  }
545  }
546 
547  } // pointAtVert
548 
549  } // in mass window (doMassFit)
550 
551  } // chi2 cut failed
552  } else { // unconstrained fit failed
553  ATH_MSG_DEBUG("Fitter failed!");
554  }
555 
556  } // doFit
557 
558  i2++;
559  } // loop over negative tracks
560  i1++;
561  } // loop over positive tracks
562 
563  } // posTracks.size() > 0 && negTracks.size() > 0
564 
565  if (v0Container->empty()) ATH_MSG_DEBUG("No Candidates found. Empty container returned");
566  if (ksContainer->empty()) ATH_MSG_DEBUG("No Kshort Candidates found. Empty container returned");
567  if (laContainer->empty()) ATH_MSG_DEBUG("No Lambda Candidates found. Empty container returned");
568  if (lbContainer->empty()) ATH_MSG_DEBUG("No Lambdabar Candidates found. Empty container returned");
569 
570  return StatusCode::SUCCESS;
571 }
572 
573 StatusCode InDetV0FinderTool::finalize()
574 {
575  msg(MSG::DEBUG)
576  << "----------------------------------------------------------------------------------------------------------------------------------------------" << endmsg
577  << "\tSummary" << endmsg
578  << "\tProcessed : " << m_events_processed << " events" << endmsg
579  << "\tStored : " << m_V0s_stored << " V0s" << endmsg
580  << "\tof which : " << m_Kshort_stored << " Kshorts" << endmsg
581  << "\t : " << m_Lambda_stored << " Lambdas" << endmsg
582  << "\t : " << m_Lambdabar_stored << " Lambdabars" << endmsg;

◆ pointAtVertex()

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

Definition at line 746 of file InDetV0FinderTool.cxx.

747  {
748  nLogProb,
749  std::abs(v0a0xy),
750  std::abs(v0a0z),
751  v0lxy,
752  v0lxy/v0lxyError,
753  cos};
754  float this_Score=m_BDT->GetClassification(bdt_vars);
755  if (this_Score > score) {
756  score = this_Score;
757  }
758  if (score > m_BDTCut){
759  pass = true;
760  }
761  }
762  else if (v0lxy/v0lxyError > m_vert_lxy_sig && cos > m_vert_cos_cut &&
763  std::abs(v0a0xy) < m_vert_a0xy_cut && std::abs(v0a0z) < m_vert_a0z_cut &&
764  v0lxy < m_vert_lxy_cut) pass = true;
765  return pass;
766 }
767 
768 bool InDetV0FinderTool::pointAtVertexColl(xAOD::Vertex* v0, const xAOD::VertexContainer * vertColl, float &score) const
769 {
770  bool pass = false;
771  xAOD::VertexContainer::const_iterator vItr = vertColl->begin();
772  for ( vItr=vertColl->begin(); vItr!=vertColl->end(); ++vItr ) { if (pointAtVertex(v0,(*vItr),score)) pass = true; }
773  return pass;
774 }
775 
776 double InDetV0FinderTool::invariantMass(const Trk::TrackParameters* per1, const Trk::TrackParameters* per2, double m1, double m2)
777 {

◆ pointAtVertexColl()

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

Definition at line 779 of file InDetV0FinderTool.cxx.

779  : 0.;
780  double e2sq = per2->momentum().mag2() + m2*m2;
781  double e2 = (e2sq>0.) ? sqrt(e2sq) : 0.;
782  double p = (per1->momentum()+per2->momentum()).mag();
783  double msq = (e1+e2+p)*(e1+e2-p);
784  double mass = (msq>0.) ? sqrt(msq) : 0.;
785  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.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ SGError()

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

Definition at line 599 of file InDetV0FinderTool.cxx.

600  {
601  double massKshort_i=2000001., massLambda_i=2000001., massLambdabar_i=2000001.;
602  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.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

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.

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

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

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

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

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

◆ m_errmass

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

Maximum mass error (100.

MeV)

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

◆ m_events_processed

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

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

◆ m_Gamma_stored

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

Definition at line 199 of file InDetV0FinderTool.h.

◆ m_iGammaFitter

PublicToolHandle<Trk::IVertexFitter> InDet::InDetV0FinderTool::m_iGammaFitter
private
Initial value:
{
this, "GammaFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 135 of file InDetV0FinderTool.h.

◆ m_iKshortFitter

PublicToolHandle<Trk::IVertexFitter> InDet::InDetV0FinderTool::m_iKshortFitter
private
Initial value:
{
this, "KshortFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 129 of file InDetV0FinderTool.h.

◆ m_iLambdabarFitter

PublicToolHandle<Trk::IVertexFitter> InDet::InDetV0FinderTool::m_iLambdabarFitter
private
Initial value:
{
this, "LambdabarFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 133 of file InDetV0FinderTool.h.

◆ m_iLambdaFitter

PublicToolHandle<Trk::IVertexFitter> InDet::InDetV0FinderTool::m_iLambdaFitter
private
Initial value:
{
this, "LambdaFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 131 of file InDetV0FinderTool.h.

◆ m_iVertexFitter

PublicToolHandle<Trk::IVertexFitter> InDet::InDetV0FinderTool::m_iVertexFitter
private
Initial value:
{
this, "VertexFitterTool", "Trk::V0VertexFitter"}

Definition at line 125 of file InDetV0FinderTool.h.

◆ m_iVKVertexFitter

PublicToolHandle<Trk::IVertexFitter> InDet::InDetV0FinderTool::m_iVKVertexFitter
private
Initial value:
{
this, "VKVertexFitterTool", "Trk::TrkVKalVrtFitter"}

Definition at line 127 of file InDetV0FinderTool.h.

◆ m_Kshort_stored

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

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

◆ m_ksmax

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

max Kshort mass (600.

MeV)

Definition at line 175 of file InDetV0FinderTool.h.

◆ m_ksmin

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

min Kshort mass (400.

MeV)

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

◆ m_lamax

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

max Lambda mass (1200.

MeV)

Definition at line 177 of file InDetV0FinderTool.h.

◆ m_Lambda_stored

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

Definition at line 197 of file InDetV0FinderTool.h.

◆ m_Lambdabar_stored

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

Definition at line 198 of file InDetV0FinderTool.h.

◆ m_lamin

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

min Lambda mass (1000.

MeV)

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

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

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

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

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

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

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

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

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

◆ m_maxPV

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

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

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

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

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

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

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

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

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

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

◆ m_trackToVertexTool

PublicToolHandle<Reco::ITrackToVertex> InDet::InDetV0FinderTool::m_trackToVertexTool
private
Initial value:
{
this, "TrackToVertexTool", "Reco::TrackToVertex"}

Definition at line 139 of file InDetV0FinderTool.h.

◆ m_trkSelector

PublicToolHandle<Trk::ITrackSelectorTool> InDet::InDetV0FinderTool::m_trkSelector
private
Initial value:
{
this, "TrackSelectorTool", "InDet::TrackSelectorTool"}

Definition at line 141 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 171 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 170 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 173 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 172 of file InDetV0FinderTool.h.

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

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

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

◆ m_useBeamSpotCond

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

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

◆ m_useTrkSel

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

= true uses TrackSelectorTool

Definition at line 160 of file InDetV0FinderTool.h.

◆ m_useTRTplusSi

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

= use TRT+Si pairs (true)

Definition at line 156 of file InDetV0FinderTool.h.

◆ m_useTRTplusTRT

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

= use TRT+TRT pairs (true)

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

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

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

◆ m_V0Tools

PublicToolHandle<Trk::V0Tools> InDet::InDetV0FinderTool::m_V0Tools
private
Initial value:
{
this, "V0Tools", "Trk::V0Tools"}

Definition at line 137 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 186 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 187 of file InDetV0FinderTool.h.

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

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

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

◆ m_vertexEstimator

PublicToolHandle<InDet::VertexPointEstimator> InDet::InDetV0FinderTool::m_vertexEstimator
private
Initial value:
{
this, "VertexPointEstimator", "InDet::VertexPointEstimator"}

Definition at line 143 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 222 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:
InDet::InDetV0FinderTool::pointAtVertexColl
bool pointAtVertexColl(xAOD::Vertex *v0, const xAOD::VertexContainer *vertColl, float &score) const
Definition: InDetV0FinderTool.cxx:779
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:75
InDet::InDetV0FinderTool::m_vertexEstimator
PublicToolHandle< InDet::VertexPointEstimator > m_vertexEstimator
Definition: InDetV0FinderTool.h:143
InDet::InDetV0FinderTool::m_useorigin
BooleanProperty m_useorigin
= true only using tracks that have no vertex association (true)
Definition: InDetV0FinderTool.h:151
InDet::InDetV0FinderTool::m_ulamax
DoubleProperty m_ulamax
max Lambda mass, unconstrained fit (1200.
Definition: InDetV0FinderTool.h:173
InDet::InDetV0FinderTool::m_minVertProb
DoubleProperty m_minVertProb
Minimum vertex probability (0.0001)
Definition: InDetV0FinderTool.h:179
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
InDet::InDetV0FinderTool::m_beamSpotDecoKey
SG::ReadDecorHandleKeyArray< xAOD::EventInfo > m_beamSpotDecoKey
Definition: InDetV0FinderTool.h:242
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
InDet::InDetV0FinderTool::m_mDecor_gprob
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_mDecor_gprob
Definition: InDetV0FinderTool.h:234
InDet::InDetV0FinderTool::m_massp
DoubleProperty m_massp
proton mass (938.272 MeV)
Definition: InDetV0FinderTool.h:164
InDet::InDetV0FinderTool::m_V0s_stored
std::atomic< unsigned int > m_V0s_stored
Definition: InDetV0FinderTool.h:195
InDet::InDetV0FinderTool::performSearch
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
Definition: InDetV0FinderTool.cxx:191
SG::ReadCondHandle
Definition: ReadCondHandle.h:40
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:553
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:143
InDet::InDetV0FinderTool::m_uksmax
DoubleProperty m_uksmax
max Kshort mass, unconstrained fit (600.
Definition: InDetV0FinderTool.h:171
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
InDet::InDetV0FinderTool::m_masspi
DoubleProperty m_masspi
pion mass (139.57 MeV)
Definition: InDetV0FinderTool.h:163
xAOD::VxType::V0Vtx
@ V0Vtx
Vertex from V0 decay.
Definition: TrackingPrimitives.h:576
xAOD::Vertex_v1::trackParticleLinks
const TrackParticleLinks_t & trackParticleLinks() const
Get all the particles associated with the vertex.
xAOD::TrackParticle_v1::summaryValue
bool summaryValue(uint8_t &value, const SummaryType &information) const
Accessor for TrackSummary values.
Definition: TrackParticle_v1.cxx:666
xAOD::TrackParticle_v1::vz
float vz() const
The z origin for the parameters.
InDet::InDetV0FinderTool::m_uksmin
DoubleProperty m_uksmin
min Kshort mass, unconstrained fit (400.
Definition: InDetV0FinderTool.h:170
InDet::InDetV0FinderTool::m_ptTRT
DoubleProperty m_ptTRT
Minimum pT for TRT tracks (700.
Definition: InDetV0FinderTool.h:168
xAOD::TrackParticle_v1::z0
float z0() const
Returns the parameter.
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
InDet::InDetV0FinderTool::doMassFit
bool doMassFit(xAOD::Vertex *vxCandidate, int pdgID) const
Definition: InDetV0FinderTool.cxx:799
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
InDet::InDetV0FinderTool::m_v0LinksDecorkeylbb
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0LinksDecorkeylbb
Definition: InDetV0FinderTool.h:226
ParticleTest.tp
tp
Definition: ParticleTest.py:25
InDet::InDetV0FinderTool::m_mDecor_gmasserr
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_mDecor_gmasserr
Definition: InDetV0FinderTool.h:233
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
xAOD::Vertex_v1::position
const Amg::Vector3D & position() const
Returns the 3-pos.
InDet::InDetV0FinderTool::m_vert_a0xy_cut
DoubleProperty m_vert_a0xy_cut
V0 |a0xy| wrt a vertex (<3.)
Definition: InDetV0FinderTool.h:186
InDet::InDetV0FinderTool::m_maxPV
Gaudi::Property< int > m_maxPV
Definition: InDetV0FinderTool.h:251
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
InDet::InDetV0FinderTool::m_useV0Fitter
BooleanProperty m_useV0Fitter
= true if using TrkV0Fitter, = false if using VKalVert (true)
Definition: InDetV0FinderTool.h:157
covarianceTool.prob
prob
Definition: covarianceTool.py:678
InDet::InDetV0FinderTool::m_concreteVertexFitter
const Trk::TrkV0VertexFitter * m_concreteVertexFitter
Definition: InDetV0FinderTool.h:220
InDet::InDetV0FinderTool::m_doSimpleV0
BooleanProperty m_doSimpleV0
= true equivalent to the old InDetSimpleV0Finder (false)
Definition: InDetV0FinderTool.h:150
InDet::InDetV0FinderTool::m_use_vertColl
BooleanProperty m_use_vertColl
= true select tracks wrt a vertex collection (false)
Definition: InDetV0FinderTool.h:154
InDet::InDetV0FinderTool::m_v0_BDTScore
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0_BDTScore
Definition: InDetV0FinderTool.h:236
XMLtoHeader.count
count
Definition: XMLtoHeader.py:84
InDet::InDetV0FinderTool::m_ksmin
DoubleProperty m_ksmin
min Kshort mass (400.
Definition: InDetV0FinderTool.h:174
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
InDet::InDetV0FinderTool::m_d0_cut
DoubleProperty m_d0_cut
track d0 significance wrt a vertex (>2.)
Definition: InDetV0FinderTool.h:181
InDet::InDetV0FinderTool::m_vert_cos_cut
DoubleProperty m_vert_cos_cut
V0 cos(theta) angle between displacement and momentum (>0.)
Definition: InDetV0FinderTool.h:188
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
InDet::InDetV0FinderTool::finalize
StatusCode finalize()
Definition: InDetV0FinderTool.cxx:584
InDet::InDetV0FinderTool::m_vert_lxy_cut
DoubleProperty m_vert_lxy_cut
V0 lxy V0 lxy (<500.)
Definition: InDetV0FinderTool.h:185
InDet::InDetV0FinderTool::invariantMass
static double invariantMass(const Trk::TrackParameters *per1, const Trk::TrackParameters *per2, double m1, double m2)
Definition: InDetV0FinderTool.cxx:787
xAOD::Vertex_v1::setVertexType
void setVertexType(VxType::VertexType vType)
Set the type of the vertex.
InDet::InDetV0FinderTool::m_particleDataTable
const HepPDT::ParticleDataTable * m_particleDataTable
Definition: InDetV0FinderTool.h:148
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
InDet::InDetV0FinderTool::m_vertexKey
SG::ReadHandleKey< xAOD::VertexContainer > m_vertexKey
Definition: InDetV0FinderTool.h:222
xAOD::Vertex_v1::addTrackAtVertex
void addTrackAtVertex(const ElementLink< TrackParticleContainer > &tr, float weight=1.0)
Add a new track to the vertex.
Definition: Vertex_v1.cxx:314
xAOD::TrackParticle_v1::perigeeParameters
const Trk::Perigee & perigeeParameters() const
Returns the Trk::MeasuredPerigee track parameters.
Definition: TrackParticle_v1.cxx:415
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
python.changerun.m1
m1
Definition: changerun.py:30
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::ReadDecorHandle
Handle class for reading a decoration on an object.
Definition: StoreGate/StoreGate/ReadDecorHandle.h:94
InDet::InDetV0FinderTool::m_events_processed
std::atomic< unsigned int > m_events_processed
Definition: InDetV0FinderTool.h:194
InDet::InDetV0FinderTool::m_iKshortFitter
PublicToolHandle< Trk::IVertexFitter > m_iKshortFitter
Definition: InDetV0FinderTool.h:129
parseMapping.v0
def v0
Definition: parseMapping.py:149
InDet::InDetV0FinderTool::m_Kshort_stored
std::atomic< unsigned int > m_Kshort_stored
Definition: InDetV0FinderTool.h:196
InDet::InDetV0FinderTool::m_BDTCut
DoubleProperty m_BDTCut
BDT Score threshold.
Definition: InDetV0FinderTool.h:189
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
InDet::InDetV0FinderTool::m_Lambdabar_stored
std::atomic< unsigned int > m_Lambdabar_stored
Definition: InDetV0FinderTool.h:198
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
InDet::InDetV0FinderTool::m_max_d0_cut
DoubleProperty m_max_d0_cut
track |d0| wrt a vertex (<999999.)
Definition: InDetV0FinderTool.h:182
InDet::InDetV0FinderTool::m_iLambdabarFitter
PublicToolHandle< Trk::IVertexFitter > m_iLambdabarFitter
Definition: InDetV0FinderTool.h:133
InDet::InDetV0FinderTool::m_max_z0_cut
DoubleProperty m_max_z0_cut
track |z0| wrt a vertex (<999999.)
Definition: InDetV0FinderTool.h:183
InDet::InDetV0FinderTool::m_iVertexFitter
PublicToolHandle< Trk::IVertexFitter > m_iVertexFitter
Definition: InDetV0FinderTool.h:125
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
makeComparison.rootFile
rootFile
Definition: makeComparison.py:27
InDet::InDetV0FinderTool::m_eventInfo_key
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo_key
Definition: InDetV0FinderTool.h:240
InDet::InDetV0FinderTool::m_trackToVertexTool
PublicToolHandle< Reco::ITrackToVertex > m_trackToVertexTool
Definition: InDetV0FinderTool.h:139
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::Vertex_v1::clearTracks
void clearTracks()
Remove all tracks from the vertex.
Definition: Vertex_v1.cxx:331
InDet::InDetV0FinderTool::m_v0_lbLinksDecorkey
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0_lbLinksDecorkey
Definition: InDetV0FinderTool.h:229
Trk::ParametersBase
Definition: ParametersBase.h:55
xAOD::Vertex_v1::z
float z() const
Returns the z position.
InDet::InDetV0FinderTool::m_useTrkSel
BooleanProperty m_useTrkSel
= true uses TrackSelectorTool
Definition: InDetV0FinderTool.h:160
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
InDet::InDetV0FinderTool::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: InDetV0FinderTool.h:241
DataVector::back
const T * back() const
Access the last element in the collection as an rvalue.
DataVector
Derived DataVector<T>.
Definition: DataVector.h:795
InDet::InDetV0FinderTool::m_errmass
DoubleProperty m_errmass
Maximum mass error (100.
Definition: InDetV0FinderTool.h:178
InDet::InDetV0FinderTool::m_v0_ksLinksDecorkey
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0_ksLinksDecorkey
Definition: InDetV0FinderTool.h:227
InDet::InDetV0FinderTool::m_masses
IntegerProperty m_masses
= 1 if using PDG values, = 2 if user set (1)
Definition: InDetV0FinderTool.h:162
InDet::InDetV0FinderTool::m_mDecor_gmass
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_mDecor_gmass
Definition: InDetV0FinderTool.h:232
InDet::InDetV0FinderTool::m_v0_laLinksDecorkey
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0_laLinksDecorkey
Definition: InDetV0FinderTool.h:228
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
InDet::InDetV0FinderTool::pointAtVertex
bool pointAtVertex(const xAOD::Vertex *v0, const xAOD::Vertex *PV, float &score) const
Definition: InDetV0FinderTool.cxx:746
InDet::InDetV0FinderTool::m_ulamin
DoubleProperty m_ulamin
min Lambda mass, unconstrained fit (1000.
Definition: InDetV0FinderTool.h:172
InDet::InDetV0FinderTool::m_BDT
std::unique_ptr< MVAUtils::BDT > m_BDT
Definition: InDetV0FinderTool.h:238
InDet::InDetV0FinderTool::doFit
bool doFit(const xAOD::TrackParticle *track1, const xAOD::TrackParticle *track2, Amg::Vector3D &startingPoint, const EventContext &ctx) const
Definition: InDetV0FinderTool.cxx:605
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::d0
@ d0
Definition: ParamDefs.h:63
InDet::InDetV0FinderTool::m_useBeamSpotCond
Gaudi::Property< bool > m_useBeamSpotCond
Definition: InDetV0FinderTool.h:243
charge
double charge(const T &p)
Definition: AtlasPID.h:997
InDet::InDetV0FinderTool::makeLink
ElementLink< xAOD::TrackParticleContainer > makeLink(const xAOD::TrackParticle *, const std::vector< const xAOD::TrackParticleContainer * > &) const
Definition: InDetV0FinderTool.cxx:876
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
InDet::InDetV0FinderTool::m_useTRTplusTRT
BooleanProperty m_useTRTplusTRT
= use TRT+TRT pairs (true)
Definition: InDetV0FinderTool.h:155
InDet::InDetV0FinderTool::m_iLambdaFitter
PublicToolHandle< Trk::IVertexFitter > m_iLambdaFitter
Definition: InDetV0FinderTool.h:131
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
InDet::InDetV0FinderTool::m_v0LinksDecorkeyks
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0LinksDecorkeyks
Definition: InDetV0FinderTool.h:224
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
InDet::InDetV0FinderTool::d0Pass
bool d0Pass(const xAOD::TrackParticle *track1, const xAOD::TrackParticle *track2, const xAOD::VertexContainer *vertColl, const EventContext &ctx) const
Definition: InDetV0FinderTool.cxx:639
InDet::InDetV0FinderTool::m_vert_a0z_cut
DoubleProperty m_vert_a0z_cut
V0 |a0z| wrt a vertex (<15.)
Definition: InDetV0FinderTool.h:187
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:321
xAOD::score
@ score
Definition: TrackingPrimitives.h:514
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
InDet::InDetV0FinderTool::m_lamin
DoubleProperty m_lamin
min Lambda mass (1000.
Definition: InDetV0FinderTool.h:176
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
Trk::TrkV0VertexFitter::fit
virtual xAOD::Vertex * fit(const std::vector< const xAOD::TrackParticle * > &vectorTrk, const Amg::Vector3D &startingPoint) const override
Interface for xAOD::TrackParticle with Amg::Vector3D starting point.
Definition: TrkV0VertexFitter.cxx:83
InDet::InDetV0FinderTool::m_massLambda
DoubleProperty m_massLambda
Lambda mass (1115.68 MeV)
Definition: InDetV0FinderTool.h:167
a
TList * a
Definition: liststreamerinfos.cxx:10
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
InDet::InDetV0FinderTool::m_useTRTplusSi
BooleanProperty m_useTRTplusSi
= use TRT+Si pairs (true)
Definition: InDetV0FinderTool.h:156
InDet::InDetV0FinderTool::m_lamax
DoubleProperty m_lamax
max Lambda mass (1200.
Definition: InDetV0FinderTool.h:177
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
InDet::InDetV0FinderTool::m_samesign
BooleanProperty m_samesign
= true select tracks with same sign (false)
Definition: InDetV0FinderTool.h:152
InDet::InDetV0FinderTool::m_use_innerPixHits
BooleanProperty m_use_innerPixHits
= true select allows tracks with no innermost pixel layer hits to always pass d0 significance cut (fa...
Definition: InDetV0FinderTool.h:158
DEBUG
#define DEBUG
Definition: page_access.h:11
InDet::InDetV0FinderTool::m_Gamma_stored
std::atomic< unsigned int > m_Gamma_stored
Definition: InDetV0FinderTool.h:199
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
InDet::InDetV0FinderTool::m_minConstrVertProb
DoubleProperty m_minConstrVertProb
Minimum vertex probability for constrained fit (0.0001)
Definition: InDetV0FinderTool.h:180
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
InDet::InDetV0FinderTool::m_trackParticleKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackParticleKey
Definition: InDetV0FinderTool.h:122
InDet::InDetV0FinderTool::m_pv
BooleanProperty m_pv
= true select tracks wrt primary vertex (false)
Definition: InDetV0FinderTool.h:153
InDet::InDetV0FinderTool::massFit
xAOD::Vertex * massFit(int pdgID, const std::vector< const xAOD::TrackParticle * > &pairV0, const Amg::Vector3D &vertex) const
Definition: InDetV0FinderTool.cxx:830
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
InDet::InDetV0FinderTool::m_masse
DoubleProperty m_masse
electron mass (0.510999 MeV)
Definition: InDetV0FinderTool.h:165
str
Definition: BTagTrackIpAccessor.cxx:11
InDet::InDetV0FinderTool::m_vert_lxy_sig
DoubleProperty m_vert_lxy_sig
V0 lxy significance wrt a vertex (>2.)
Definition: InDetV0FinderTool.h:184
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
Trk::TrkV0VertexFitter
This class implements a vertex fitting algorithm optimised for V0 finding.
Definition: TrkV0VertexFitter.h:40
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:44
InDet::InDetV0FinderTool::m_massK0S
DoubleProperty m_massK0S
Kshort mass (497.672 MeV)
Definition: InDetV0FinderTool.h:166
InDet::InDetV0FinderTool::m_mDecor_gfit
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_mDecor_gfit
Definition: InDetV0FinderTool.h:231
InDet::InDetV0FinderTool::m_trkSelector
PublicToolHandle< Trk::ITrackSelectorTool > m_trkSelector
Definition: InDetV0FinderTool.h:141
InDet::InDetV0FinderTool::m_iGammaFitter
PublicToolHandle< Trk::IVertexFitter > m_iGammaFitter
Definition: InDetV0FinderTool.h:135
InDet::InDetV0FinderTool::m_V0Tools
PublicToolHandle< Trk::V0Tools > m_V0Tools
Definition: InDetV0FinderTool.h:137
python.SystemOfUnits.m2
float m2
Definition: SystemOfUnits.py:107
error
Definition: IImpactPoint3dEstimator.h:70
InDet::InDetV0FinderTool::m_v0LinksDecorkeylb
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0LinksDecorkeylb
Definition: InDetV0FinderTool.h:225
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
InDet::InDetV0FinderTool::m_RelinkContainers
SG::ReadHandleKeyArray< xAOD::TrackParticleContainer > m_RelinkContainers
Definition: InDetV0FinderTool.h:252
mag
Scalar mag() const
mag method
Definition: AmgMatrixBasePlugin.h:26
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
InDet::InDetV0FinderTool::m_useBDT
BooleanProperty m_useBDT
= true uses BDT selections in place of rectangular pointAtVertex + minVertProb
Definition: InDetV0FinderTool.h:159
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:238
SUSY_SimplifiedModel_PreInclude.masses
dictionary masses
Definition: SUSY_SimplifiedModel_PreInclude.py:7
InDet::InDetV0FinderTool::m_BDTFile
StringProperty m_BDTFile
Filename of mvaUtils model file, located in /InDetV0FinderTool/BDT/v1/.
Definition: InDetV0FinderTool.h:191
InDet::InDetV0FinderTool::m_Lambda_stored
std::atomic< unsigned int > m_Lambda_stored
Definition: InDetV0FinderTool.h:197
InDet::InDetV0FinderTool::m_iVKVertexFitter
PublicToolHandle< Trk::IVertexFitter > m_iVKVertexFitter
Definition: InDetV0FinderTool.h:127
Generated on Wed Nov 19 2025 22:02:29 for ATLAS Offline Software by   doxygen 1.8.18