Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 > &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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

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

Private Attributes

SG::ReadHandleKey< xAOD::TrackParticleContainer > m_trackParticleKey
 
PublicToolHandle< Trk::IVertexFitter > m_iVertexFitter
 
PublicToolHandle< Trk::IVertexFitter > m_iVKVertexFitter
 
PublicToolHandle< Trk::IVertexFitter > m_iKshortFitter
 
PublicToolHandle< Trk::IVertexFitter > m_iLambdaFitter
 
PublicToolHandle< Trk::IVertexFitter > m_iLambdabarFitter
 
PublicToolHandle< Trk::IVertexFitter > m_iGammaFitter
 
PublicToolHandle< Trk::V0Tools > m_V0Tools
 
PublicToolHandle< Reco::ITrackToVertex > m_trackToVertexTool
 
PublicToolHandle< Trk::ITrackSelectorTool > m_trkSelector
 
PublicToolHandle< InDet::VertexPointEstimator > m_vertexEstimator
 
PublicToolHandle< Trk::IExtrapolator > m_extrapolator
 
const HepPDT::ParticleDataTable * m_particleDataTable = nullptr
 
BooleanProperty m_doSimpleV0 {this, "doSimpleV0", false}
 = true equivalent to the old InDetSimpleV0Finder (false) More...
 
BooleanProperty m_useorigin {this, "useorigin", true}
 = true only using tracks that have no vertex association (true) More...
 
BooleanProperty m_samesign {this, "AddSameSign", false}
 = true select tracks with same sign (false) More...
 
BooleanProperty m_pv {this, "trkSelPV", false}
 = true select tracks wrt primary vertex (false) More...
 
BooleanProperty m_use_vertColl {this, "useVertexCollection", false}
 = true select tracks wrt a vertex collection (false) More...
 
BooleanProperty m_useTRTplusTRT {this, "useTRTplusTRT", false}
 = use TRT+TRT pairs (true) More...
 
BooleanProperty m_useTRTplusSi {this, "useTRTplusSi", false}
 = use TRT+Si pairs (true) More...
 
BooleanProperty m_useV0Fitter {this, "useV0Fitter", false}
 = true if using TrkV0Fitter, = false if using VKalVert (true) More...
 
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", 139.57}
 pion mass (139.57 MeV) More...
 
DoubleProperty m_massp {this, "massp", 938.272}
 proton mass (938.272 MeV) More...
 
DoubleProperty m_masse {this, "masse", 0.510999}
 electron mass (0.510999 MeV) More...
 
DoubleProperty m_massK0S {this, "massK0S", 497.672}
 Kshort mass (497.672 MeV) More...
 
DoubleProperty m_massLambda {this, "massLambda", 1115.68}
 Lambda mass (1115.68 MeV) More...
 
DoubleProperty m_ptTRT {this, "ptTRT", 700.}
 Minimum pT for TRT tracks (700. More...
 
DoubleProperty m_maxsxy {this, "maxsxy", 1000.}
 Maximum Rxy of starting point (1000. More...
 
DoubleProperty m_uksmin {this, "uksmin", 400.}
 min Kshort mass, unconstrained fit (400. More...
 
DoubleProperty m_uksmax {this, "uksmax", 600.}
 max Kshort mass, unconstrained fit (600. More...
 
DoubleProperty m_ulamin {this, "ulamin", 1000.}
 min Lambda mass, unconstrained fit (1000. More...
 
DoubleProperty m_ulamax {this, "ulamax", 1200.}
 max Lambda mass, unconstrained fit (1200. More...
 
DoubleProperty m_ksmin {this, "ksmin", 400.}
 min Kshort mass (400. More...
 
DoubleProperty m_ksmax {this, "ksmax", 600.}
 max Kshort mass (600. More...
 
DoubleProperty m_lamin {this, "lamin", 1000.}
 min Lambda mass (1000. More...
 
DoubleProperty m_lamax {this, "lamax", 1200.}
 max Lambda mass (1200. More...
 
DoubleProperty m_errmass {this, "errmass", 100.}
 Maximum mass error (100. More...
 
DoubleProperty m_minVertProb {this, "minVertProb", 0.0001}
 Minimum vertex probability (0.0001) More...
 
DoubleProperty m_minConstrVertProb {this, "minConstrVertProb", 0.0001}
 Minimum vertex probability for constrained fit (0.0001) More...
 
DoubleProperty m_d0_cut {this, "d0_cut", 2.}
 track d0 significance wrt a vertex (>2.) More...
 
DoubleProperty m_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" ,{}, "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 730 of file InDetV0FinderTool.cxx.

741 {
742  bool pass = false;
743  float v0lxy = m_V0Tools->lxy(v0,PV);
744  float v0lxyError = m_V0Tools->lxyError(v0,PV);
745  float cos = m_V0Tools->cosTheta(v0,PV);
746  float v0a0xy = m_V0Tools->a0xy(v0,PV);
747  float v0a0z = m_V0Tools->a0z(v0,PV);
748  if (m_useBDT){
749  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 644 of file InDetV0FinderTool.cxx.

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

◆ d0Pass() [3/4]

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

Definition at line 709 of file InDetV0FinderTool.cxx.

720 {
721  bool pass = false;
722  bool hasInnerPixHit1 = true;
723  if (m_use_innerPixHits){
724  SG::AuxElement::ConstAccessor<uint8_t> numberOfInnermostPixelLayerHits("numberOfInnermostPixelLayerHits");
725  uint8_t nInnerHits1 = numberOfInnermostPixelLayerHits(*track1);
726  if (nInnerHits1 == 0) hasInnerPixHit1 = false;
727  }
728  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 682 of file InDetV0FinderTool.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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 > &  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 > &  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 > &  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 > &  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 610 of file InDetV0FinderTool.cxx.

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

◆ doMassFit()

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

Definition at line 804 of file InDetV0FinderTool.cxx.

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

594 {
595  ATH_MSG_FATAL(errService << " not found. Exiting !");
596 }
597 
598 
599 bool InDetV0FinderTool::doFit(const xAOD::TrackParticle* track1, const xAOD::TrackParticle* track2,
600  Amg::Vector3D &startingPoint, const EventContext& ctx) const
601 {
602  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  if(!m_useBeamSpotCond){
134  for (const std::string beam : {"beamPosX", "beamPosY", "beamPosZ"}) {
135  m_beamSpotDecoKey.emplace_back(m_eventInfo_key.key() + "."+beam);
136  }
137  }
138  ATH_CHECK( m_beamSpotDecoKey.initialize(!m_useBeamSpotCond));
139 
140 // Get the track selector tool from ToolSvc
141  ATH_CHECK( m_trkSelector.retrieve() );
142  ATH_MSG_DEBUG("Retrieved tool " << m_trkSelector);
143 
144 // Get the vertex point estimator tool from ToolSvc
145  ATH_CHECK( m_vertexEstimator.retrieve() );
146  ATH_MSG_DEBUG("Retrieved tool " << m_vertexEstimator);
147 
148  const HepPDT::ParticleData* pd_pi = m_particleDataTable->particle(MC::PIPLUS);
149  const HepPDT::ParticleData* pd_p = m_particleDataTable->particle(MC::PROTON);
150  const HepPDT::ParticleData* pd_e = m_particleDataTable->particle(MC::ELECTRON);
151  const HepPDT::ParticleData* pd_K = m_particleDataTable->particle(MC::K0S);
152  const HepPDT::ParticleData* pd_L = m_particleDataTable->particle(MC::LAMBDA0);
153  if (m_masses == 1) {
154  m_masspi = pd_pi->mass();
155  m_massp = pd_p->mass();
156  m_masse = pd_e->mass();
157  m_massK0S = pd_K->mass();
158  m_massLambda = pd_L->mass();
159  }
160 
161  m_events_processed = 0;
162  m_V0s_stored = 0;
163  m_Kshort_stored = 0;
164  m_Lambdabar_stored = 0;
165  m_Lambda_stored = 0;
166  m_Gamma_stored = 0;
167 
168 // making a concrete fitter for the V0Fitter
169  m_concreteVertexFitter = nullptr;
170  if (m_useV0Fitter) {
171  m_concreteVertexFitter = dynamic_cast<Trk::TrkV0VertexFitter * >(&(*m_iVertexFitter));
172  if (m_concreteVertexFitter == nullptr) {
173  ATH_MSG_FATAL("The vertex fitter passed is not a V0 Vertex Fitter");
174  return StatusCode::FAILURE;
175  }
176  }
177 
178  ATH_CHECK(m_RelinkContainers.initialize());
179 
180  ATH_MSG_DEBUG( "Initialization successful" );
181 
182  return StatusCode::SUCCESS;
183 }
184 
185 StatusCode InDetV0FinderTool::performSearch(xAOD::VertexContainer* v0Container,
186  xAOD::VertexContainer* ksContainer,
187  xAOD::VertexContainer* laContainer,
188  xAOD::VertexContainer* lbContainer,
189  const xAOD::Vertex* primaryVertex,
190  const xAOD::VertexContainer* vertColl,
191  const EventContext& ctx
192  ) const
193 {
194 

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

794 {
795  bool pass = false;
796  double mass = 1000000000.;
797  double error = 1000000001.;
798  bool in_mass_window = false;
799  double winmass_min = 0., winmass_max = 0.;
800 
801  if (pdgID == 310) {
802  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 881 of file InDetV0FinderTool.cxx.

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

◆ massFit()

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

Definition at line 835 of file InDetV0FinderTool.cxx.

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

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

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

◆ pointAtVertexColl()

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

Definition at line 784 of file InDetV0FinderTool.cxx.

784  : 0.;
785  double e2sq = per2->momentum().mag2() + m2*m2;
786  double e2 = (e2sq>0.) ? sqrt(e2sq) : 0.;
787  double p = (per1->momentum()+per2->momentum()).mag();
788  double msq = (e1+e2+p)*(e1+e2-p);
789  double mass = (msq>0.) ? sqrt(msq) : 0.;
790  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 604 of file InDetV0FinderTool.cxx.

605  {
606  double massKshort_i=2000001., massLambda_i=2000001., massLambdabar_i=2000001.;
607  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" ,{}, "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", 0.510999}
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", 497.672}
private

Kshort mass (497.672 MeV)

Definition at line 166 of file InDetV0FinderTool.h.

◆ m_massLambda

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

Lambda mass (1115.68 MeV)

Definition at line 167 of file InDetV0FinderTool.h.

◆ m_massp

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

proton mass (938.272 MeV)

Definition at line 164 of file InDetV0FinderTool.h.

◆ m_masspi

DoubleProperty InDet::InDetV0FinderTool::m_masspi {this, "masspi", 139.57}
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:784
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
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
python.SystemOfUnits.m2
int m2
Definition: SystemOfUnits.py:92
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:196
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
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:150
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:736
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
columnar::ContainerId::track1
@ track1
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:804
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
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
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:85
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:589
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:792
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
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:485
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
python.changerun.m1
m1
Definition: changerun.py:32
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
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:794
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
jobOptions.beam
beam
Definition: jobOptions.SuperChic_ALP2.py:16
InDet::InDetV0FinderTool::m_v0_laLinksDecorkey
SG::WriteDecorHandleKey< xAOD::VertexContainer > m_v0_laLinksDecorkey
Definition: InDetV0FinderTool.h:228
InDet::InDetV0FinderTool::initialize
StatusCode initialize()
Definition: InDetV0FinderTool.cxx:54
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:751
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:610
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
Trk::d0
@ d0
Definition: ParamDefs.h:63
columnar::ContainerId::track2
@ track2
InDet::InDetV0FinderTool::m_useBeamSpotCond
Gaudi::Property< bool > m_useBeamSpotCond
Definition: InDetV0FinderTool.h:243
charge
double charge(const T &p)
Definition: AtlasPID.h:897
InDet::InDetV0FinderTool::makeLink
ElementLink< xAOD::TrackParticleContainer > makeLink(const xAOD::TrackParticle *, const std::vector< const xAOD::TrackParticleContainer * > &) const
Definition: InDetV0FinderTool.cxx:881
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
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:644
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:431
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:835
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:798
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:43
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
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.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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 Thu Mar 13 2025 21:55:38 for ATLAS Offline Software by   doxygen 1.8.18