ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | Friends | List of all members
InDet::InDetTrackSelectionTool Class Referenceabstract

Implementation of the track selector tool. More...

#include <InDetTrackSelectionTool.h>

Inheritance diagram for InDet::InDetTrackSelectionTool:
Collaboration diagram for InDet::InDetTrackSelectionTool:

Public Member Functions

virtual void print () const =0
 Print the state of the tool. More...
 
virtual void print () const
 Print the state of the tool. More...
 
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
 

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< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

virtual void setCutLevel (InDet::CutLevel level, Bool_t overwrite=true) override __attribute__((deprecated("For consistency with the athena interface
 Function to set the cut level within standalone ROOT. More...
 
void setCutLevelPrivate (InDet::CutLevel level, Bool_t overwrite=true)
 
template<int VERBOSE, class Trk_Helper >
StatusCode setupCuts (std::map< std::string, std::vector< std::function< bool(Trk_Helper helper, const asg::AsgMessaging &msgHelper)> > > &trackCuts)
 
template<class Trk_Helper >
asg::AcceptData accept (Trk_Helper helper, const std::map< std::string, std::vector< std::function< bool(Trk_Helper helper, const asg::AsgMessaging &msgHelper)> > > &trackCuts) 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...
 
Function(s) implementing the asg::IAsgTool interface
virtual StatusCode initialize () override
 Function initialising the tool. More...
 
virtual StatusCode finalize () override
 Function finalizing the tool. More...
 
Function(s) implementing the IAsgSelectionTool interface
virtual const asg::AcceptInfogetAcceptInfo () const override
 Get an object describing the "selection steps" of the tool. More...
 
virtual asg::AcceptData accept (const xAOD::IParticle *) const override
 Get the decision using a generic IParticle pointer. More...
 
Function(s) implementing the IInDetTrackSelectionTool interface
virtual asg::AcceptData accept (const xAOD::TrackParticle &track, const xAOD::Vertex *vertex=nullptr) const override
 Get the decision for a specific track object. More...
 
virtual asg::AcceptData accept (const Trk::Track &track, const Trk::Vertex *vertex=nullptr) const override
 Function that returns the result of the cuts to a Trk::Track. More...
 

Static Private Member Functions

static bool maxDoubleIsSet (Double_t cutValue)
 
static bool maxIntIsSet (Int_t cutValue)
 

Private Attributes

virtual void the cut level is best set through the CutLevel property
 
bool m_isInitialized = false
 
std::atomic_bool m_warnInit = false
 
std::unordered_map< std::string, std::shared_ptr< TrackAccessor > > m_trackAccessors
 list of the accessors that need to be run for each track More...
 
std::unique_ptr< asg::AsgMessagingm_msgHelper
 
std::map< std::string, std::vector< std::function< bool(InDetAccessor::TrackParticleHelper helper, const asg::AsgMessaging &msgHelper)> > > m_trackParticleCuts
 First element is the name of the cut family, second element is the set of cuts. More...
 
std::map< std::string, std::vector< std::function< bool(InDetAccessor::TrkTrackHelper helper, const asg::AsgMessaging &msgHelper)> > > m_trkTrackCuts
 First element is the name of the cut family, second element is the set of cuts. More...
 
std::atomic< ULong64_t > m_numTracksProcessed = 0
 a counter of the number of tracks proccessed More...
 
std::atomic< ULong64_t > m_numTracksPassed = 0
 a counter of the number of tracks that passed all cuts More...
 
std::vector< ULong64_t > m_numTracksPassedCuts ATLAS_THREAD_SAFE
 tracks the number of tracks that passed each cut family. More...
 
std::mutex m_mutex
 
Gaudi::Property< Double_t > m_minPt {this, "minPt", -1., "Minimum transverse momentum"}
 
Gaudi::Property< Double_t > m_minP {this, "minP", -1., "Minimum momentum"}
 
Gaudi::Property< Double_t > m_maxAbsEta {this, "maxAbsEta", LOCAL_MAX_DOUBLE, "Maximum magnitude of pseudorapidity"}
 
Gaudi::Property< Double_t > m_maxZ0SinTheta {this, "maxZ0SinTheta", LOCAL_MAX_DOUBLE, "Maximum |z0|*sin(theta)"}
 
Gaudi::Property< Double_t > m_maxZ0 {this, "maxZ0", LOCAL_MAX_DOUBLE, "Maximum longitudinal separation"}
 
Gaudi::Property< Double_t > m_maxD0 {this, "maxD0", LOCAL_MAX_DOUBLE, "Maximum transvers separation"}
 
Gaudi::Property< Double_t > m_maxSigmaD0 {this, "maxSigmaD0", LOCAL_MAX_DOUBLE, "Maximum error on d0"}
 
Gaudi::Property< Double_t > m_maxSigmaZ0 {this, "maxSigmaZ0", LOCAL_MAX_DOUBLE, "Maximum error on z0"}
 
Gaudi::Property< Double_t > m_maxSigmaZ0SinTheta {this, "maxSigmaZ0SinTheta", LOCAL_MAX_DOUBLE, "Maximum error on z0*sin(theta)"}
 
Gaudi::Property< Double_t > m_maxD0overSigmaD0 {this, "maxD0overSigmaD0", LOCAL_MAX_DOUBLE, "Significance cut on |d0|"}
 
Gaudi::Property< Double_t > m_maxZ0overSigmaZ0 {this, "maxZ0overSigmaZ0", LOCAL_MAX_DOUBLE, "Significance cut on |z0|"}
 
Gaudi::Property< Double_t > m_maxZ0SinThetaoverSigmaZ0SinTheta
 
Gaudi::Property< Int_t > m_minNInnermostLayerHits
 
Gaudi::Property< Int_t > m_minNNextToInnermostLayerHits
 
Gaudi::Property< Int_t > m_minNBothInnermostLayersHits
 
Gaudi::Property< Int_t > m_maxNInnermostLayerSharedHits
 
Gaudi::Property< Int_t > m_useMinBiasInnermostLayersCut
 
Gaudi::Property< Int_t > m_minNSiHits {this, "minNSiHits", -1, "Minimum silicon (pixel + SCT) hits"}
 
Gaudi::Property< Int_t > m_maxNSiSharedHits
 
Gaudi::Property< Int_t > m_minNSiHitsIfSiSharedHits
 
Gaudi::Property< Int_t > m_maxNSiHoles {this, "maxNSiHoles", LOCAL_MAX_INT, "Maximum silicon (pixel + SCT) holes"}
 
Gaudi::Property< Int_t > m_minNPixelHits {this, "minNPixelHits", -1, "Required pixel hits"}
 
Gaudi::Property< Int_t > m_maxNPixelSharedHits
 
Gaudi::Property< Int_t > m_maxNPixelHoles
 
Gaudi::Property< Double_t > m_minEtaForStrictNSiHitsCut
 
Gaudi::Property< Int_t > m_minNSiHitsAboveEtaCutoff
 
Gaudi::Property< Bool_t > m_maxOneSharedModule
 
Gaudi::Property< Bool_t > m_useEtaDependentMaxChiSq
 
Gaudi::Property< Int_t > m_minNSiHitsPhysical
 
Gaudi::Property< Int_t > m_minNPixelHitsPhysical {this, "minNPixelHitsPhysical", -1, "Minimum physical pixel hits"}
 
Gaudi::Property< Int_t > m_minNSctHitsPhysical {this, "minNSctHitsPhysical", -1, "Minimum physical SCT hits"}
 
Gaudi::Property< Int_t > m_minNSctHits {this, "minNSctHits", -1, "Minimum SCT hits"}
 
Gaudi::Property< Int_t > m_maxNSctSharedHits
 
Gaudi::Property< Int_t > m_maxNSctHoles {this, "maxNSctHoles", LOCAL_MAX_INT, "Maximum SCT holes"}
 
Gaudi::Property< Int_t > m_maxNSctDoubleHoles {this, "maxNSctDoubleHoles", LOCAL_MAX_INT, "Maximum SCT double holes"}
 
Gaudi::Property< Double_t > m_maxTrtEtaAcceptance
 
Gaudi::Property< Double_t > m_maxEtaForTrtHitCuts
 
Gaudi::Property< Int_t > m_minNTrtHits {this, "minNTrtHits", -1, "Minimum TRT hits"}
 
Gaudi::Property< Int_t > m_minNTrtHitsPlusOutliers {this, "minNTrtHitsPlusOutliers", -1, "Minimum TRT hits including outliers"}
 
Gaudi::Property< Int_t > m_minNTrtHighThresholdHits {this, "minNTrtHighThresholdHits", -1, "Minimum high E TRT hits"}
 
Gaudi::Property< Int_t > m_minNTrtHighThresholdHitsPlusOutliers
 
Gaudi::Property< Double_t > m_maxTrtHighEFraction
 
Gaudi::Property< Double_t > m_maxTrtHighEFractionWithOutliers
 
Gaudi::Property< Double_t > m_maxTrtOutlierFraction
 
Gaudi::Property< Double_t > m_maxChiSq {this, "maxChiSq", LOCAL_MAX_DOUBLE, "Maximum chi squared"}
 
Gaudi::Property< Double_t > m_maxChiSqperNdf
 
Gaudi::Property< Double_t > m_minProb {this, "minProb", -1., "Minimum p(chi^2, Ndof)"}
 
Gaudi::Property< Double_t > m_minPtForProbCut
 
Gaudi::Property< Double_t > m_minProbAbovePtCutoff
 
Gaudi::Property< Int_t > m_minNUsedHitsdEdx {this, "minNUsedHitsdEdx", -1, "Minimum hits used for dEdx"}
 
Gaudi::Property< Int_t > m_minNOverflowHitsdEdx {this, "minNOverflowHitsdEdx", -1, "Minimum overflow hits in IBL for dEdx"}
 
Gaudi::Property< Bool_t > m_eProbHTonlyForXe
 
Gaudi::Property< Double_t > m_minEProbabilityHT
 
Gaudi::Property< Bool_t > m_useExperimentalInnermostLayersCut
 
Gaudi::Property< Int_t > m_minNSiHitsMod
 
Gaudi::Property< Int_t > m_minNSiHitsModTop
 
Gaudi::Property< Int_t > m_minNSiHitsModBottom
 
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForSiHitsCut
 
Gaudi::Property< std::vector< Int_t > > m_vecMinNSiHitsAboveEta
 
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForPtCut {this, "vecEtaCutoffsForPtCut", {}, "Minimum eta cutoffs for each pT cut"}
 
Gaudi::Property< std::vector< Double_t > > m_vecMinPtAboveEta
 
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForSctHitsCut
 
Gaudi::Property< std::vector< Int_t > > m_vecMinNSctHitsAbovePt
 
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForZ0SinThetaCut
 
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForZ0SinThetaCut
 
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMaxZ0SinThetaAboveEtaPt
 
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForD0Cut {this, "vecEtaCutoffsForD0Cut", {}, "Minimum eta cutoffs for each D0 value"}
 
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForD0Cut {this, "vecPtCutoffsForD0Cut", {}, "Minimum pt cutoffs for each D0 value"}
 
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMaxD0AboveEtaPt
 
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForSctHolesCut
 
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForSctHolesCut
 
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMaxSctHolesAboveEtaPt
 
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForSctHitsPlusDeadCut
 
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForSctHitsPlusDeadCut
 
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMinSctHitsPlusDeadAboveEtaPt
 
asg::AcceptInfo m_acceptInfo
 Object used to store the last decision. More...
 
Gaudi::Property< std::string > m_cutLevel {this, "CutLevel", ""}
 The string version of the cut level so that it can be set via jobOptions. More...
 
Gaudi::Property< Bool_t > m_initTrkTools {this, "UseTrkTrackTools", false, "Whether to initialize the Trk::Track tools"}
 
Bool_t m_trackSumToolAvailable = false
 Whether the summary tool is available. More...
 
ToolHandle< Trk::ITrackSummaryToolm_trackSumTool {this, "TrackSummaryTool", "Trk::TrackSummaryTool/TrackSummaryTool"}
 
ToolHandle< Trk::IExtrapolatorm_extrapolator {this, "Extrapolator", "Trk::Extrapolator/Extrapolator"}
 
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
 

Static Private Attributes

constexpr static Double_t LOCAL_MAX_DOUBLE = 1.0e16
 
constexpr static Int_t LOCAL_MAX_INT = std::numeric_limits<Int_t>::max()
 
static const std::unordered_map< std::string, CutLevels_mapCutLevel
 

Friends

class TrackCut
 

Detailed Description

Implementation of the track selector tool.

Definition at line 50 of file InDetTrackSelectionTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

◆ accept() [1/4]

asg::AcceptData InDet::InDetTrackSelectionTool::accept ( const Trk::Track track,
const Trk::Vertex vertex = nullptr 
) const
overrideprivatevirtual

Function that returns the result of the cuts to a Trk::Track.

This version of accept() is included to allow the tool to be used in full-blown athena on Trk::Tracks. It is supposed to have identical functionality to the user as the xAOD version above, but of course it does need to access track information differently.

Implements InDet::IInDetTrackSelectionTool.

Definition at line 1072 of file InDetTrackSelectionTool.cxx.

1074 {
1075  if (!m_isInitialized) ATH_MSG_WARNING( "Tool is not initialized! Calling accept() will not be very helpful." );
1076 
1077  asg::AcceptData acceptData(&m_acceptInfo);
1078  if (m_trkTrackCuts.empty()) {
1081  return acceptData;
1082  }
1083 
1084  const Trk::TrackParameters* perigee = track.perigeeParameters();
1085 
1086  if ( perigee == nullptr || !perigee->covariance() ) {
1087  ATH_MSG_WARNING( "Track preselection: Zero pointer to parameterbase* received (most likely a track without perigee). This track will not pass any cuts." );
1088  return acceptData;
1089  }
1090 
1091  std::unique_ptr<const Trk::TrackParameters> paramsAtVertex;
1092  if (vertex) {
1093  Trk::PerigeeSurface perigeeSurface(vertex->position());
1094  paramsAtVertex =
1095  m_extrapolator->extrapolate(Gaudi::Hive::currentContext(),
1096  *perigee,
1097  perigeeSurface,
1099  true,
1100  track.info().particleHypothesis());
1101  perigee = paramsAtVertex.get();
1102  }
1103 
1104  if ( perigee == nullptr || !perigee->covariance() ) {
1105  ATH_MSG_INFO( "Track preselection: cannot make a measured perigee. This track will not pass any cuts." );
1106  if (!m_initTrkTools)
1107  ATH_MSG_INFO( "The user should set \"UseTrkTrackTools\" to true if they want the extrapolation tool to try to get a perigee." );
1108  return acceptData;
1109  }
1110 
1111 
1112  std::unique_ptr<Trk::TrackSummary> cleanup_summary;
1113  const Trk::TrackSummary* summary = track.trackSummary();
1114  if (summary == nullptr && m_trackSumToolAvailable) {
1115  cleanup_summary = m_trackSumTool->summary(Gaudi::Hive::currentContext(),track);
1116  summary = cleanup_summary.get();
1117  }
1118  if (summary == nullptr) {
1119  ATH_MSG_INFO( "Track preselection: cannot get a track summary. This track will not pass any cuts." );
1120  if (!m_initTrkTools)
1121  ATH_MSG_INFO( "The Trk::Track tools were not set to be initialized. The user should set the property \"UseTrkTrackTools\" to true if they wish to use the summary tool." );
1122  return acceptData;
1123  }
1124 
1125  InDetAccessor::TrkTrackHelper track_helper(track,*summary, perigee);
1126  acceptData = accept( track_helper, m_trkTrackCuts);
1127  return acceptData;
1128 }

◆ accept() [2/4]

asg::AcceptData InDet::InDetTrackSelectionTool::accept ( const xAOD::IParticle p) const
overrideprivatevirtual

Get the decision using a generic IParticle pointer.

Function that returns the result of the cut through the xAOD::IParticle interface.

This is included to implement the AsgSelectionTool interface. It is not the recommended way of using the tool. If the IParticle is an xAOD::TrackParticle, then it will return the result of the explicitly xAOD::TrackParticle version below, with no vertex provided.

Parameters
pAn xAOD::IParticle pointer. If it is of type xAOD::TrackParticle, then it will be cast as such and funnelled into the corresponding function. If it is of some different type, then the particle will not pass.

Implements InDet::IInDetTrackSelectionTool.

Definition at line 1006 of file InDetTrackSelectionTool.cxx.

1007 {
1008 
1009  asg::AcceptData acceptData(&m_acceptInfo);
1010  // Check if this is a track:
1011  if( p->type() != xAOD::Type::TrackParticle ) {
1012  ATH_MSG_ERROR( "accept(...) Function received a non-track" );
1013  return acceptData;
1014  }
1015 
1016  // Cast it to a track (we have already checked its type so we do not have to dynamic_cast):
1017  const xAOD::TrackParticle* trk = static_cast< const xAOD::TrackParticle* >( p );
1018 
1019  // Let the specific function do the work:
1020  return accept( *trk, nullptr );
1021 }

◆ accept() [3/4]

asg::AcceptData InDet::InDetTrackSelectionTool::accept ( const xAOD::TrackParticle trk,
const xAOD::Vertex vtx = nullptr 
) const
overrideprivatevirtual

Get the decision for a specific track object.

Function that returns the result of the cuts applied to a track in the xAOD framework.

The workhorse function of the tool that checks whether or not a track passes, and also can provide some information about why the track failed when it does. First it accesses all the data it needs from the track (but does not retrieve info it won't need to check) by looping over its InDet::TrackAccessors. It then loops over its cut families, each of which is composed of one or more InDet::TrackCuts, storing whether or not the track passes all the corresponding cuts. This design allows functionality to be added to the tool without increasing overhead in the main loop for users who don't need it. This eliminates the need for several multiple versions of the tool.

Parameters
trkThe xAOD::TrackParticle in question.
vtxAn optional pointer to a xAOD::Vertex that can be provided if the user wishes to cut on z0 with respect to the vertex's position. Note that this does not affect d0 cuts. If a vertex is not provided then the z0 cuts are performed with respect to the beamspot. More information can be found at the InDetTrackingDC14 TWiki.
Returns
A asg::AcceptData object that can be treated as a boolean for a simple pass/fail. It does store more detailed information about which cuts passed and which failed, by organizing the results into cut families. For example, TAccept::getCutResult("Z0SinTheta") will be true if the track passed cuts on Z0*Sin(theta), its uncertainty, and its significance.

Implements InDet::IInDetTrackSelectionTool.

Definition at line 1049 of file InDetTrackSelectionTool.cxx.

1051 {
1052  asg::AcceptData acceptData(&m_acceptInfo);
1053  if (m_trackParticleCuts.empty()) {
1056  return acceptData;
1057  }
1058 
1059  InDetAccessor::TrackParticleHelper track_helper(trk,vtx);
1060  return accept( track_helper, m_trackParticleCuts);
1061 }

◆ accept() [4/4]

template<class Trk_Helper >
asg::AcceptData InDet::InDetTrackSelectionTool::accept ( Trk_Helper  helper,
const std::map< std::string, std::vector< std::function< bool(Trk_Helper helper, const asg::AsgMessaging &msgHelper)> > > &  trackCuts 
) const
private

Definition at line 912 of file InDetTrackSelectionTool.cxx.

913  {
914  if (!m_isInitialized) {
915  if (!m_warnInit) {
916  ATH_MSG_WARNING( "Tool is not initialized! Calling accept() will not be very helpful." );
917  m_warnInit = true;
918  }
919  }
920 
921  asg::AcceptData acceptData(&m_acceptInfo);
922  bool passAll = true;
923 
924  // loop over all cuts
925  UShort_t cutFamilyIndex = 0;
926  for ( const auto& cutFamily : trackCuts ) {
927  bool pass = true;
928 
929  for ( const auto& cut : cutFamily.second ) {
930  if (! cut(helper, *m_msgHelper) ) {
931  pass = false;
932  break;
933  }
934  }
935 
936  // @TODO really always run through all cuts even if passed is false ?
937  passAll &= pass;
938  acceptData.setCutResult( cutFamilyIndex, pass );
939  cutFamilyIndex++;
940  }
941 
942  {
943  // lock access to m_numTracksPassedCuts
944  std::lock_guard<std::mutex> lock(m_mutex);
945  for (unsigned int idx=0; idx < trackCuts.size(); ++idx) {
946  assert(idx<m_numTracksPassedCuts.size());
947  m_numTracksPassedCuts[idx] += acceptData.getCutResult(idx);
948  }
949  }
950  if (passAll) m_numTracksPassed++;
952 
953  return acceptData;
954 
955 }

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

◆ 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::InDetTrackSelectionTool::finalize ( )
overrideprivatevirtual

Function finalizing the tool.

Implements InDet::IInDetTrackSelectionTool.

Definition at line 958 of file InDetTrackSelectionTool.cxx.

959 {
960  if (!m_isInitialized) {
961  ATH_MSG_ERROR( "You are attempting to finalize a tool that has not been initialized()." );
962  }
963 
964 #ifdef XAOD_ANALYSIS
965  if (m_numTracksProcessed == 0) {
966  ATH_MSG_INFO( "No tracks processed in selection tool." );
967  return StatusCode::SUCCESS;
968  }
969 
970  // Only printed out for analysis
972  << m_numTracksPassed*100./m_numTracksProcessed << "% passed all cuts." );
973  for (const auto& cutFamily : m_trackParticleCuts) {
974  // lock(m_mutex) is not needed because this is inside of non-const finalize method.
975  ULong64_t numPassed = m_numTracksPassedCuts.at(m_acceptInfo.getCutPosition(cutFamily.first));
976  ATH_MSG_INFO( numPassed << " = " << numPassed*100./m_numTracksProcessed << "% passed "
977  << cutFamily.first << " cut." );
978  }
979 #endif
980 
981  return StatusCode::SUCCESS;
982 }

◆ getAcceptInfo()

const asg::AcceptInfo & InDet::InDetTrackSelectionTool::getAcceptInfo ( ) const
overrideprivatevirtual

Get an object describing the "selection steps" of the tool.

Accessor function to the tool's Root::TAccept object, which stores the result of the last accept(...) call.

The TAccept object itself is expensive to copy, and so should be accessed by const reference.

Implements InDet::IInDetTrackSelectionTool.

Definition at line 989 of file InDetTrackSelectionTool.cxx.

990 {
991  return m_acceptInfo;
992 }

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void *  ptr) const
inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getName
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

119  {
120 
121 #ifdef XAOD_STANDALONE
122  // In case we use @c xAOD::TEvent, we have a direct function call
123  // for this.
124  return evtStore()->event()->getKey( ptr );
125 #else
126  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
127  return ( proxy == nullptr ? 0 : proxy->sgkey() );
128 #endif // XAOD_STANDALONE
129  }

◆ getName()

const std::string & asg::AsgTool::getName ( const void *  ptr) const
inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also
asg::AsgTool::getKey
Parameters
ptrThe bare pointer to the object that the event store should know about
Returns
The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

106  {
107 
108 #ifdef XAOD_STANDALONE
109  // In case we use @c xAOD::TEvent, we have a direct function call
110  // for this.
111  return evtStore()->event()->getName( ptr );
112 #else
113  const SG::DataProxy* proxy = evtStore()->proxy( ptr );
114  static const std::string dummy = "";
115  return ( proxy == nullptr ? dummy : proxy->name() );
116 #endif // XAOD_STANDALONE
117  }

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ initialize()

StatusCode InDet::InDetTrackSelectionTool::initialize ( )
overrideprivatevirtual

Function initialising the tool.

Initializes the selection tool, setting up the cut objects as well as any additional tools it needs.

In athena, this is called automatically after the user has set the properties and so it must set the cut level without overwriting any additional cuts that have been set.

In standalone root, the cut levels can be set in a more or less intuitive way. After setting the cut levels and providing any additional configuration, this initialize() function must be called explicitly.

Reimplemented from asg::AsgTool.

Definition at line 103 of file InDetTrackSelectionTool.cxx.

103  {
104  // Make sure we haven't already been initialized - this would be a sign of improper usage.
105  if (m_isInitialized) {
106  ATH_MSG_ERROR( "Tool has already been initialized. This is illegitimate." );
107  ATH_MSG_ERROR( "This call to initialize() will do nothing." );
108  return StatusCode::SUCCESS;
109  }
110 
111  // Greet the user:
113 
114  // if the CutLevel string is set to something recognizable,
115  // then do a soft set on the cuts (i.e. not overwriting those already set)
116  if (!m_cutLevel.empty()) {
117  std::unordered_map<std::string, InDet::CutLevel>::const_iterator it_mapCutLevel = s_mapCutLevel.find(m_cutLevel);
118  if ( it_mapCutLevel == s_mapCutLevel.end() ) {
119  ATH_MSG_ERROR( "The string \"" << m_cutLevel << "\" is not recognized as a cut level. No cuts will be changed." );
120  ATH_MSG_ERROR( "Cut level options are:" );
121  for (const auto& opt : s_mapCutLevel) {
122  ATH_MSG_ERROR( "\t" << opt.first );
123  }
124  } else {
125  ATH_MSG_DEBUG( "Cut level set to \"" << it_mapCutLevel->first << "\"." );
126  ATH_MSG_DEBUG( "This will not overwrite other cuts that have been set.");
127  setCutLevelPrivate( it_mapCutLevel->second, false );
128  }
129  }
130 
131 #ifndef XAOD_ANALYSIS
132  if (m_initTrkTools) {
133  m_trackSumToolAvailable = false;
134  if (!m_trackSumTool.empty()) {
135  ATH_CHECK( m_trackSumTool.retrieve() );
136  ATH_MSG_DEBUG( "Track summary tool retrieved." );
138  }
139  ATH_CHECK( m_extrapolator.retrieve() );
140  ATH_MSG_DEBUG( "Retrieved tool " << m_extrapolator );
141  } else {
142  m_extrapolator.disable();
143  m_trackSumTool.disable();
144  }
145 #endif // XAOD_ANALYSIS
146 
147  // Need messaging helper for cut functions
148  m_msgHelper = std::make_unique<asg::AsgMessaging>(this) ;
149 
150 
151 #ifndef XAOD_ANALYSIS
152  // setup cut functions for Trk::Tracks
153  ATH_CHECK( setupCuts<0>(m_trkTrackCuts) );
154  ATH_CHECK( setupCuts<0>(m_trackParticleCuts) );
155 #else
156  ATH_CHECK( setupCuts<1>(m_trackParticleCuts) );
157 #endif
158  // setup cut functions for xAOD::TrackParticles
159  for (const auto& cutFamily : m_trackParticleCuts) {
160  const std::string& cutFamilyName = cutFamily.first;
161  // lock(m_mutex) is not needed because this is inside of non-const initialize method.
162  m_numTracksPassedCuts.push_back(0);
163  if (m_acceptInfo.addCut( cutFamilyName, "Selection of tracks according to " + cutFamilyName ) < 0) {
164  ATH_MSG_ERROR( "Failed to add cut family " << cutFamilyName << " because the TAccept object is full." );
165  return StatusCode::FAILURE;
166  }
167  ATH_MSG_VERBOSE("Adding cut family " << cutFamilyName);
168  }
169 
170  m_isInitialized = true;
171 
172  return StatusCode::SUCCESS;
173 }

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

◆ maxDoubleIsSet()

static bool InDet::InDetTrackSelectionTool::maxDoubleIsSet ( Double_t  cutValue)
inlinestaticprivate

Definition at line 136 of file InDetTrackSelectionTool.h.

136 {return cutValue < InDet::InDetTrackSelectionTool::LOCAL_MAX_DOUBLE && cutValue >= 0.;}

◆ maxIntIsSet()

static bool InDet::InDetTrackSelectionTool::maxIntIsSet ( Int_t  cutValue)
inlinestaticprivate

Definition at line 137 of file InDetTrackSelectionTool.h.

137 {return cutValue < InDet::InDetTrackSelectionTool::LOCAL_MAX_INT && cutValue >= 0;}

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

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const
inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns
The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

101  {
102 
103  return MSG::name( msg().level() );
104  }

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

◆ print() [1/2]

void asg::AsgTool::print ( ) const
virtualinherited

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const
pure virtualinherited

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

◆ setCutLevel()

void InDet::InDetTrackSelectionTool::setCutLevel ( InDet::CutLevel  level,
Bool_t  overwrite = true 
)
overrideprivatevirtual

Function to set the cut level within standalone ROOT.

This function can be used to set the cut selection of the tool to a pre-defined level, as definied in the twiki for InDetTrackingPerformanceGuidelines. It is left public for use in standalone ROOT. In athena, this should be set through the jobOptions via the "CutLevel" property instead.

Parameters
levelThe CutLevel enumeration that picks the preset level to set the cuts to.
overwriteA boolean (default true) that indicates whether to force an overwrite of each cut. If false, this function does not change the cut levels if they have been altered from their default (no cut) value.

Implements InDet::IInDetTrackSelectionTool.

Definition at line 1151 of file InDetTrackSelectionTool.cxx.

1152 {
1153 #ifndef XAOD_STANDALONE
1154  ATH_MSG_WARNING( "InDetTrackSelectionTool::setCutLevel() is not designed to be called manually in Athena." );
1155  ATH_MSG_WARNING( "It may not behave as intended. Instead, configure it in the job options through the CutLevel property." );
1156 #endif // XAOD_STANDALONE
1157  if (!m_cutLevel.empty()) {
1158  ATH_MSG_WARNING( "Cut level already set to " << m_cutLevel << ". Calling setCutLevel() is not expected." );
1159  }
1160  setCutLevelPrivate(level, overwrite);
1161 }

◆ setCutLevelPrivate()

void InDet::InDetTrackSelectionTool::setCutLevelPrivate ( InDet::CutLevel  level,
Bool_t  overwrite = true 
)
private

Definition at line 1166 of file InDetTrackSelectionTool.cxx.

1167 {
1168  switch (level) {
1169  case CutLevel::NoCut :
1170  if (m_isInitialized) {
1171  // this check is in here so that it only happens once per call to setCutLevel,
1172  // but will still warn if only the private version is called somehow.
1173  ATH_MSG_WARNING( "Trying to set cut level while the tool is already initialized." );
1174  ATH_MSG_WARNING( "This will almost certainly not exhibit intended behavior." );
1175  }
1176  if (overwrite) {
1177  // minimum cuts will default to -1, so if a user wishes to remove a cut
1178  // from a preset level they can do so by setting the minimum to zero.
1179  // maximum cuts can be removed from a preset level by setting them negative.
1180  m_minPt = -1.; // in MeV
1181  m_minP = -1.;
1183  m_maxZ0SinTheta = LOCAL_MAX_DOUBLE; // in mm
1197  m_minNPixelHits = -1;
1201  m_minNSctHits = -1;
1202  m_minNSctHitsPhysical = -1;
1206  m_minNSiHits = -1;
1207  m_minNSiHitsPhysical = -1;
1213  m_maxOneSharedModule = false;
1215  m_maxEtaForTrtHitCuts = -1.; // this is really a minimum eta above which cuts are not applied
1216  m_minNTrtHits = -1;
1224  m_minProb = -1.;
1227  m_minProbAbovePtCutoff = -1.;
1228  m_useEtaDependentMaxChiSq = false;
1229  m_minNUsedHitsdEdx = -1;
1231  m_minEProbabilityHT = -1.;
1232  m_eProbHTonlyForXe = false;
1233 #ifndef XAOD_ANALYSIS
1234  m_minNSiHitsMod = -1;
1235  m_minNSiHitsModTop = -1;
1236  m_minNSiHitsModBottom = -1;
1237 #endif
1238  m_vecEtaCutoffsForSiHitsCut = std::vector<double>();
1239  m_vecMinNSiHitsAboveEta = std::vector<int>();
1240  m_vecEtaCutoffsForPtCut = std::vector<double>();
1241  m_vecMinPtAboveEta = std::vector<double>();
1242  m_vecPtCutoffsForSctHitsCut = std::vector<double>();
1243  m_vecMinNSctHitsAbovePt = std::vector<int>();
1244  m_vecEtaCutoffsForZ0SinThetaCut = std::vector<double>();
1245  m_vecPtCutoffsForZ0SinThetaCut = std::vector<double>();
1246  m_vecvecMaxZ0SinThetaAboveEtaPt = std::vector<std::vector<double>>();
1247  m_vecEtaCutoffsForD0Cut = std::vector<double>();
1248  m_vecPtCutoffsForD0Cut = std::vector<double>();
1249  m_vecvecMaxD0AboveEtaPt = std::vector<std::vector<double>>();
1250  m_vecEtaCutoffsForSctHolesCut = std::vector<double>();
1251  m_vecPtCutoffsForSctHolesCut = std::vector<double>();
1252  m_vecvecMaxSctHolesAboveEtaPt = std::vector<std::vector<double>>();
1253  m_vecEtaCutoffsForSctHitsPlusDeadCut = std::vector<double>();
1254  m_vecPtCutoffsForSctHitsPlusDeadCut = std::vector<double>();
1255  m_vecvecMinSctHitsPlusDeadAboveEtaPt = std::vector<std::vector<double>>();
1256  }
1257  break;
1258  case CutLevel::Loose :
1259  setCutLevelPrivate(CutLevel::NoCut, overwrite); // if hard overwrite, reset all cuts first. will do nothing if !overwrite
1260  // change the cuts if a hard overwrite is asked for or if the cuts are unset
1261  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1262  if (overwrite || m_minNSiHits < 0) m_minNSiHits = 8;
1263  m_maxOneSharedModule = true;
1264  if (overwrite || m_maxNSiHoles >= LOCAL_MAX_INT) m_maxNSiHoles = 2;
1265  if (overwrite || m_maxNPixelHoles >= LOCAL_MAX_INT) m_maxNPixelHoles = 1;
1266  break;
1267  case CutLevel::LoosePrimary :
1268  setCutLevelPrivate(CutLevel::NoCut, overwrite); // implement loose cuts first
1269  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1270  if (overwrite || m_minNSiHits < 0) m_minNSiHits = 8;
1271  m_maxOneSharedModule = true;
1272  if (overwrite || m_maxNSiHoles >= LOCAL_MAX_INT) m_maxNSiHoles = 2;
1273  if (overwrite || m_maxNPixelHoles >= LOCAL_MAX_INT) m_maxNPixelHoles = 1;
1274  if (overwrite || m_minNSiHitsIfSiSharedHits < 0) m_minNSiHitsIfSiSharedHits = 10;
1275  break;
1276  case CutLevel::TightPrimary :
1277  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1278  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1279  if (overwrite || m_minNSiHits < 0) m_minNSiHits = 9;
1280  m_maxOneSharedModule = true;
1281  if (overwrite || m_maxNSiHoles >= LOCAL_MAX_INT) m_maxNSiHoles = 2;
1282  if (overwrite || m_maxNPixelHoles >= LOCAL_MAX_INT) m_maxNPixelHoles = 0;
1284  if (overwrite || m_minNSiHitsAboveEtaCutoff < 0) m_minNSiHitsAboveEtaCutoff = 11;
1286  break;
1287  case CutLevel::LooseMuon :
1288  setCutLevelPrivate(CutLevel::NoCut, overwrite); // reset cuts unless we are doing a soft set
1289  if (overwrite || m_minNPixelHits < 0) m_minNPixelHits = 1;
1290  if (overwrite || m_minNSctHits < 0) m_minNSctHits = 5;
1291  if (overwrite || m_maxNSiHoles >= LOCAL_MAX_INT) m_maxNSiHoles = 2;
1292  if (overwrite || m_maxTrtEtaAcceptance >= LOCAL_MAX_DOUBLE ) m_maxTrtEtaAcceptance = 0.1;
1293  if (overwrite || m_maxEtaForTrtHitCuts < 0.) m_maxEtaForTrtHitCuts = 1.9;
1294  if (overwrite || m_minNTrtHitsPlusOutliers < 0) m_minNTrtHitsPlusOutliers = 6;
1296  break;
1297  case CutLevel::LooseElectron :
1298  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1299  if (overwrite || m_minNSiHits < 0) m_minNSiHits = 7;
1300  if (overwrite || m_minNPixelHits < 0) m_minNPixelHits = 1;
1301  break;
1302  case CutLevel::LooseTau :
1303  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1304  if (overwrite || m_minPt < 0.0) m_minPt = 1000.0;
1305  if (overwrite || m_minNSiHits < 0) m_minNSiHits = 7;
1306  if (overwrite || m_minNPixelHits < 0) m_minNPixelHits = 2;
1307  if (overwrite || m_maxD0 >= LOCAL_MAX_DOUBLE) m_maxD0 = 1.0;
1308  if (overwrite || m_maxZ0 >= LOCAL_MAX_DOUBLE) m_maxZ0 = 1.5;
1309  break;
1310  case CutLevel::MinBias :
1311  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1312  if (overwrite || m_useMinBiasInnermostLayersCut >= 0) m_useMinBiasInnermostLayersCut = 1; // if this is less than 0, it is turned off
1313  if (overwrite || m_minNPixelHits < 0) m_minNPixelHits = 1;
1314  if (overwrite || m_minNSctHits < 0) m_minNSctHits = 6;
1315  if (overwrite || m_minProbAbovePtCutoff < 0.) {
1316  m_minPtForProbCut = 10000.;
1317  m_minProbAbovePtCutoff = .01;
1318  }
1319  if (overwrite || m_maxD0 >= LOCAL_MAX_DOUBLE) m_maxD0 = 1.5;
1320  if (overwrite || m_maxZ0SinTheta >= LOCAL_MAX_DOUBLE) m_maxZ0SinTheta = 1.5;
1321  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1322  if (overwrite || m_minPt < 0.) m_minPt = 500.0;
1323  break;
1324  case CutLevel::HILoose:
1325  // HILoose is similar to MinBias, but not identical
1326  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1327  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1329  if (overwrite || m_minNPixelHits < 0) m_minNPixelHits = 1;
1330  if (overwrite || (m_vecPtCutoffsForSctHitsCut.empty()
1331  && m_vecMinNSctHitsAbovePt.empty())) {
1332  m_vecPtCutoffsForSctHitsCut = std::vector<double>({0.0, 300.0, 400.0});
1333  m_vecMinNSctHitsAbovePt = std::vector<int>({2, 4, 6});
1334  }
1335  if (overwrite || m_maxD0 >= LOCAL_MAX_DOUBLE) m_maxD0 = 1.5;
1336  if (overwrite || m_maxZ0SinTheta >= LOCAL_MAX_DOUBLE) m_maxZ0SinTheta = 1.5;
1337  break;
1338  case CutLevel::HITight:
1339  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1340  // HITight is like HILoose but we require 8 SCT hits and 2 pixel hits
1341  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1342  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1344  if (overwrite || m_minNPixelHits < 0) m_minNPixelHits = 2;
1345  if (overwrite || (m_vecPtCutoffsForSctHitsCut.empty()
1346  && m_vecMinNSctHitsAbovePt.empty())) {
1347  m_vecPtCutoffsForSctHitsCut = std::vector<double>({0.0, 300.0, 400.0});
1348  m_vecMinNSctHitsAbovePt = std::vector<int>({4, 6, 8});
1349  }
1350  if (overwrite || m_maxD0 >= LOCAL_MAX_DOUBLE) m_maxD0 = 1.0;
1351  if (overwrite || m_maxZ0SinTheta >= LOCAL_MAX_DOUBLE) m_maxZ0SinTheta = 1.0;
1352  if (overwrite || m_maxChiSqperNdf >= LOCAL_MAX_DOUBLE) m_maxChiSqperNdf = 6.0;
1353  break;
1354  case CutLevel::HILooseOptimized:
1355  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1356  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1357  if (overwrite || m_maxNPixelHoles >= LOCAL_MAX_INT) m_maxNPixelHoles = 0;
1359  if (overwrite || (m_vecEtaCutoffsForZ0SinThetaCut.empty() &&
1362  m_vecEtaCutoffsForZ0SinThetaCut = std::vector<double>({0.0, 1.1, 1.6, 2.0});
1364  std::vector<double>({500, 600, 700, 800, 900, 1000, 1500,
1365  2000, 2500, 3000, 5000, 8000, 12000});
1367  std::vector<std::vector<double>>({{2.10, 2.15, 6.00, 5.00, 3.10, 2.00, 1.75, 1.60, 1.43, 1.40, 1.05, 0.65, 0.60},
1368  {1.44, 1.47, 1.50, 1.55, 1.62, 1.45, 1.45, 1.78, 1.73, 1.50, 1.20, 0.97, 0.53},
1369  {1.40, 1.45, 1.50, 1.46, 1.41, 1.37, 1.25, 1.50, 1.50, 1.36, 1.10, 0.85, 0.52},
1370  {1.51, 1.70, 1.70, 1.71, 1.71, 1.53, 1.54, 1.49, 1.36, 1.20, 0.95, 0.60, 0.55}});
1371  }
1372  if (overwrite || (m_vecEtaCutoffsForD0Cut.empty() &&
1373  m_vecPtCutoffsForD0Cut.empty() &&
1374  m_vecvecMaxD0AboveEtaPt.empty())){
1375  m_vecEtaCutoffsForD0Cut = std::vector<double>({0.0, 1.1, 1.6, 2.0});
1377  std::vector<double>({500, 600, 700, 800, 900, 1000, 1500,
1378  2000, 2500, 3000, 5000, 8000, 12000});
1380  std::vector<std::vector<double>>({{0.81, 0.90, 0.94, 0.92, 0.90, 0.75, 0.65, 0.63, 0.62, 0.60, 0.63, 0.50, 0.55},
1381  {1.00, 0.98, 0.98, 0.92, 0.90, 0.69, 0.67, 0.86, 0.88, 0.88, 0.88, 0.87, 1.06},
1382  {1.19, 1.15, 1.10, 1.08, 1.03, 0.94, 0.85, 0.97, 0.97, 0.96, 0.95, 0.92, 1.04},
1383  {1.33, 1.23, 1.21, 1.15, 1.15, 1.07, 0.94, 0.97, 0.97, 0.97, 0.98, 1.10, 1.10}});
1384  }
1385  break;
1386  case CutLevel::HITightOptimized:
1387  setCutLevelPrivate(CutLevel::NoCut, overwrite);
1388  if (overwrite || m_maxAbsEta >= LOCAL_MAX_DOUBLE) m_maxAbsEta = 2.5;
1389  if (overwrite || m_maxNPixelHoles >= LOCAL_MAX_INT) m_maxNPixelHoles = 0;
1391  if (overwrite || (m_vecEtaCutoffsForZ0SinThetaCut.empty() &&
1394  m_vecEtaCutoffsForZ0SinThetaCut = std::vector<double>({0.0, 1.1, 1.6, 2.0});
1395  m_vecPtCutoffsForZ0SinThetaCut = std::vector<double>({500, 600, 700, 800, 900, 1000, 1500,
1396  2000, 2500, 3000, 5000, 8000, 12000});
1398  std::vector<std::vector<double>>({{0.62, 0.70, 0.82, 0.87, 0.74, 0.61, 0.50, 0.48, 0.46, 0.45, 0.30, 0.24, 0.23},
1399  {0.51, 0.53, 0.53, 0.53, 0.52, 0.43, 0.28, 0.27, 0.28, 0.30, 0.24, 0.22, 0.13},
1400  {0.91, 0.89, 0.87, 0.55, 0.59, 0.37, 0.39, 0.31, 0.34, 0.35, 0.30, 0.30, 0.20},
1401  {0.76, 0.71, 0.69, 0.48, 0.48, 0.47, 0.46, 0.42, 0.38, 0.32, 0.28, 0.20, 0.15}});
1402  }
1403  if (overwrite || (m_vecEtaCutoffsForD0Cut.empty() &&
1404  m_vecPtCutoffsForD0Cut.empty() &&
1405  m_vecvecMaxD0AboveEtaPt.empty())){
1406  m_vecEtaCutoffsForD0Cut = std::vector<double>({0.0, 1.1, 1.6, 2.0});
1407  m_vecPtCutoffsForD0Cut = std::vector<double>({500, 600, 700, 800, 900, 1000, 1500,
1408  2000, 2500, 3000, 5000, 8000, 12000});
1410  std::vector<std::vector<double>>({{0.34, 0.39, 0.47, 0.49, 0.55, 0.47, 0.44, 0.21, 0.19, 0.17, 0.12, 0.14, 0.15},
1411  {0.32, 0.32, 0.33, 0.33, 0.33, 0.27, 0.16, 0.15, 0.13, 0.15, 0.13, 0.16, 0.20},
1412  {0.95, 0.91, 0.88, 0.35, 0.37, 0.24, 0.26, 0.22, 0.23, 0.24, 0.19, 0.19, 0.23},
1413  {0.68, 0.67, 0.65, 0.42, 0.42, 0.36, 0.35, 0.31, 0.27, 0.26, 0.27, 0.28, 0.30}});
1414  }
1415  if (overwrite || (m_vecEtaCutoffsForSctHolesCut.empty() &&
1416  m_vecPtCutoffsForSctHolesCut.empty() &&
1418  m_vecEtaCutoffsForSctHolesCut = std::vector<double>({0.0, 1.1, 1.6, 2.0});
1419  m_vecPtCutoffsForSctHolesCut = std::vector<double>({500, 600, 700, 800, 900, 1000, 1500,
1420  2000, 2500, 3000, 5000, 8000, 12000});
1422  std::vector<std::vector<double>>({{0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1},
1423  {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1},
1424  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
1425  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}});
1426  }
1427  if (overwrite || (m_vecEtaCutoffsForSctHitsPlusDeadCut.empty() &&
1430  m_vecEtaCutoffsForSctHitsPlusDeadCut = std::vector<double>({0.0, 1.1, 1.6, 2.0});
1431  m_vecPtCutoffsForSctHitsPlusDeadCut = std::vector<double>({500, 600, 700, 800, 900, 1000, 1500,
1432  2000, 2500, 3000, 5000, 8000, 12000});
1434  std::vector<std::vector<double>>({{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1435  {0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 0, 0, 0},
1436  {8, 8, 8, 7, 7, 6, 6, 6, 6, 6, 0, 0, 0},
1437  {7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}});
1438  }
1439  break;
1440  default:
1441  ATH_MSG_ERROR("CutLevel not recognized. Cut selection will remain unchanged.");
1442  break;
1443  }
1444 }

◆ setupCuts()

template<int VERBOSE, class Trk_Helper >
StatusCode InDet::InDetTrackSelectionTool::setupCuts ( std::map< std::string, std::vector< std::function< bool(Trk_Helper helper, const asg::AsgMessaging &msgHelper)> > > &  trackCuts)
private

Definition at line 180 of file InDetTrackSelectionTool.cxx.

180  {
181  // track parameter cuts
182  if (m_minPt > 0.) {
183  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum Pt: " << m_minPt << " MeV" );
184  trackCuts["Pt"].push_back( [minPt = m_minPt](Trk_Helper helper, const asg::AsgMessaging &msgHelper) -> bool { return helper.pt(msgHelper) >= minPt; } );
185  }
187  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum |Eta|: " << m_maxAbsEta );
188  trackCuts["Eta"].push_back( [maxAbsEta = m_maxAbsEta](Trk_Helper helper, const asg::AsgMessaging &msgHelper) { return std::abs(helper.eta(msgHelper)) <= maxAbsEta; } );
189  }
190  if (m_minP > 0.) {
191  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum P: " << m_minP << " MeV" );
192  trackCuts["P"].push_back( [maxInvP = 1./m_minP](Trk_Helper helper, const asg::AsgMessaging &msgHelper) { return std::abs(helper.qOverP(msgHelper)) <= maxInvP; } );
193  }
194  if (maxDoubleIsSet(m_maxD0)) {
195  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum d0: " << m_maxD0 << " mm" );
196  trackCuts["D0"].push_back( [maxD0 = m_maxD0](Trk_Helper helper, const asg::AsgMessaging &msgHelper) { return std::abs(helper.d0(msgHelper)) <= maxD0; } );
197  }
198  if (maxDoubleIsSet(m_maxZ0)) {
199  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum z0: " << m_maxZ0 << " mm");
200  trackCuts["Z0"].push_back( [maxZ0 = m_maxZ0](Trk_Helper helper, const asg::AsgMessaging &msgHelper) { return std::abs(helper.z0(msgHelper)) <= maxZ0; } );
201  }
203  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum z0*sin(theta): " << m_maxZ0SinTheta << " mm" );
204  trackCuts["Z0SinTheta"].push_back([maxZ0SinTheta = m_maxZ0SinTheta](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
205  return std::abs( helper.z0(msgHelper) * std::sin(helper.theta(msgHelper))) <= maxZ0SinTheta;
206  });
207  }
209  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum uncertainty on d0: " << m_maxSigmaD0 << " mm" );
210  trackCuts["D0"].push_back([maxSigmaD0Squared = sqr(m_maxSigmaD0.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
211  return getDefiningParametersCov(helper,msgHelper, InDetAccessor::d0,InDetAccessor::d0) <= maxSigmaD0Squared;
212  });
213  }
215  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum uncertainty on z0: " << m_maxSigmaZ0 << " mm" );
216  trackCuts["Z0"].push_back([maxSigmaZ0Squared = sqr(m_maxSigmaZ0.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
217  return getDefiningParametersCov(helper,msgHelper, InDetAccessor::z0,InDetAccessor::z0) <= maxSigmaZ0Squared;
218  });
219  }
221  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum uncertainty on z0*sin(theta): "
222  << m_maxSigmaZ0SinTheta << " mm" );
223  trackCuts["Z0SinTheta"].push_back([maxSigmaZ0SinThetaSquared = sqr(m_maxSigmaZ0SinTheta.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
224  double theta = helper.theta(msgHelper);
225  double sinTheta = std::sin(theta);
226  double cosTheta = std::cos(theta);
227  double z0 = helper.z0(msgHelper);
228 
230  + 2*z0 *sinTheta*cosTheta * getDefiningParametersCov(helper,msgHelper, InDetAccessor::theta,InDetAccessor::z0)
231  + sqr(sinTheta) * getDefiningParametersCov(helper,msgHelper, InDetAccessor::z0, InDetAccessor::z0) ) <= maxSigmaZ0SinThetaSquared;
232  });
233  }
235  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum significance on d0: " << m_maxD0overSigmaD0 );
236  trackCuts["D0"].push_back([maxD0overSigmaD0Squared = sqr(m_maxD0overSigmaD0.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
237  return sqr(helper.d0(msgHelper)) <= maxD0overSigmaD0Squared * getDefiningParametersCov(helper,msgHelper, InDetAccessor::d0,InDetAccessor::d0);
238  });
239  }
241  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum significance on z0: " << m_maxZ0overSigmaZ0 );
242  trackCuts["Z0"].push_back([maxZ0overSigmaZ0Squared = sqr(m_maxZ0overSigmaZ0.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) -> bool {
243  return sqr(helper.z0(msgHelper)) <= maxZ0overSigmaZ0Squared * getDefiningParametersCov(helper,msgHelper, InDetAccessor::z0,InDetAccessor::z0);
244  });
245  }
247  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum significance on z0*sin(theta): "
249  trackCuts["Z0SinTheta"].push_back([maxZ0SinThetaoverSigmaZ0SinThetaSquared = sqr(m_maxZ0SinThetaoverSigmaZ0SinTheta.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
250 
251  double theta = helper.theta(msgHelper);
252  double sinTheta = std::sin(theta);
253  double cosTheta = std::cos(theta);
254  double z0 = helper.z0(msgHelper);
255 
256  return sqr(z0*sinTheta) <=
257  maxZ0SinThetaoverSigmaZ0SinThetaSquared * ( sqr(z0)*sqr(cosTheta) * getDefiningParametersCov(helper,msgHelper, InDetAccessor::theta,InDetAccessor::theta)
258  + 2*z0 *sinTheta*cosTheta * getDefiningParametersCov(helper,msgHelper, InDetAccessor::theta,InDetAccessor::z0)
260  });
261  }
262 
263  // hit cuts
264  if (m_minNInnermostLayerHits > 0) {
265  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum hits from innermost pixel layer: " << m_minNInnermostLayerHits );
266  if constexpr(VERBOSE>0) ATH_MSG_INFO( " (Track will pass if no hit is expected.)" );
267  trackCuts["InnermostLayersHits"].push_back([minNInnermostLayerHits = m_minNInnermostLayerHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
268  return ( getSummary(helper, msgHelper, xAOD::numberOfInnermostPixelLayerHits) >= minNInnermostLayerHits
270  });
271  }
273  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum hits from next to innermost pixel layer: " << m_minNNextToInnermostLayerHits );
274  if constexpr(VERBOSE>0) ATH_MSG_INFO( " (Track will pass if no hit is expected.)" );
275  trackCuts["InnermostLayersHits"].push_back([minNNextToInnermostLayerHits = m_minNNextToInnermostLayerHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
276  return ( getSummary(helper, msgHelper, xAOD::numberOfNextToInnermostPixelLayerHits) >= minNNextToInnermostLayerHits
278  });
279  }
281  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum hits from both innermost pixel layers: " << m_minNBothInnermostLayersHits );
282  if constexpr(VERBOSE>0) ATH_MSG_INFO( " (If a layer has no hits but one is not expected, the" );
283  if constexpr(VERBOSE>0) ATH_MSG_INFO( " number of hits in that layer will be taken to be 1.)" );
285  ATH_MSG_WARNING( "A value of minNBothInnermostLayersHits above 2 does not make sense." );
286  ATH_MSG_WARNING( " Use 1 for \"or\" or 2 for \"and\"." );
287  }
288  trackCuts["InnermostLayersHits"].push_back([minNBothInnermostLayersHits = m_minNBothInnermostLayersHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
290  static_cast<uint8_t>( !getSummary(helper, msgHelper, xAOD::expectInnermostPixelLayerHit) ))
293  >= minNBothInnermostLayersHits);
294  });
295  }
296  if (m_useMinBiasInnermostLayersCut > 0 ) { // less than zero indicates this cut is manually turned off
297  if constexpr(VERBOSE>0) ATH_MSG_INFO( " An innermost layer hit is required if expected, otherwise" );
298  if constexpr(VERBOSE>0) ATH_MSG_INFO( " a next-to-innermost layer hit is required if it is expected." );
299  trackCuts["InnermostLayersHits"].push_back([](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
300  uint8_t expected_innermost_pixel_layer_hit = getSummary(helper, msgHelper, xAOD::expectInnermostPixelLayerHit);
301  return (expected_innermost_pixel_layer_hit > 0 && getSummary(helper, msgHelper, xAOD::numberOfInnermostPixelLayerHits)>=1)
302  || (expected_innermost_pixel_layer_hit == 0 && ( getSummary(helper, msgHelper, xAOD::expectNextToInnermostPixelLayerHit)==0
304  });
305  }
307  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum shared hits in innermost pixel layer: " << m_maxNInnermostLayerSharedHits );
308  trackCuts["InnermostLayersHits"].push_back([maxNInnermostLayerSharedHits = m_maxNInnermostLayerSharedHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
309  return getSummary(helper, msgHelper, xAOD::numberOfInnermostPixelLayerSharedHits) <= maxNInnermostLayerSharedHits;
310  });
311  }
312  if (m_minNPixelHits > 0) {
313  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum pixel hits: " << m_minNPixelHits );
314  trackCuts["PixelHits"].push_back( [minNPixelHits = m_minNPixelHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
315  return getSummarySum<2,Trk_Helper>(helper, msgHelper, {xAOD::numberOfPixelHits,xAOD::numberOfPixelDeadSensors}) >= minNPixelHits;
316  });
317  }
318  if (m_minNPixelHitsPhysical > 0) {
319  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum physical pixel hits (i.e. dead sensors do not count): "
321  trackCuts["PixelHits"].push_back([minNPixelHitsPhysical = m_minNPixelHitsPhysical](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
322  return getSummary(helper, msgHelper, xAOD::numberOfPixelHits) >= minNPixelHitsPhysical;
323  });
324  }
326  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum pixel holes: " << m_maxNPixelHoles );
327  trackCuts["PixelHits"].push_back([maxNPixelHoles = m_maxNPixelHoles](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
328  return getSummary(helper, msgHelper, xAOD::numberOfPixelHoles) <= maxNPixelHoles;
329  });
330  }
332  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum pixel shared hits: " << m_maxNPixelSharedHits );
333  trackCuts["PixelHits"].push_back([maxNPixelSharedHits = m_maxNPixelSharedHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
334  return getSummary(helper, msgHelper, xAOD::numberOfPixelSharedHits) <= maxNPixelSharedHits;
335  });
336  }
337  if (m_minNSctHits > 0) {
338  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum SCT hits: " << m_minNSctHits );
339  trackCuts["SctHits"].push_back( [minNSctHits = m_minNSctHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
340  return getSummarySum<2,Trk_Helper>(helper, msgHelper, {xAOD::numberOfSCTHits, xAOD::numberOfSCTDeadSensors}) >= minNSctHits;
341  });
342  }
343  if (m_minNSctHitsPhysical > 0) {
344  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum physical SCT hits (i.e. dead sensors do not count): "
346  trackCuts["SctHits"].push_back([minNSctHitsPhysical = m_minNSctHitsPhysical](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
347  return getSummary(helper, msgHelper, xAOD::numberOfSCTHits) >= minNSctHitsPhysical;
348  });
349  }
351  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum SCT holes: " << m_maxNSctHoles );
352  trackCuts["SctHits"].push_back([maxNSctHoles = m_maxNSctHoles](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
353  return getSummary(helper, msgHelper, xAOD::numberOfSCTHoles) <= maxNSctHoles;
354  });
355  }
357  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum SCT shared hits: " << m_maxNSctSharedHits );
358  trackCuts["SctHits"].push_back([maxNSctSharedHits = m_maxNSctSharedHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
359  return getSummary(helper, msgHelper, xAOD::numberOfSCTSharedHits) <= maxNSctSharedHits;
360  });
361  }
363  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum SCT double holes: " << m_maxNSctDoubleHoles );
364  trackCuts["SctHits"].push_back([maxNSctDoubleHoles = m_maxNSctDoubleHoles](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
365  return getSummary(helper, msgHelper, xAOD::numberOfSCTDoubleHoles) <= maxNSctDoubleHoles ;
366  });
367  }
368  if (m_minNSiHits > 0) {
369  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum silicon (pixel + SCT) hits: " << m_minNSiHits );
370  trackCuts["SiHits"].push_back([minNSiHits = m_minNSiHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
371  return getSummarySum<4,Trk_Helper>(helper, msgHelper, {xAOD::numberOfPixelHits,
374  xAOD::numberOfSCTDeadSensors} ) >= minNSiHits ;
375  });
376  }
377  if (m_minNSiHitsPhysical > 0) {
378  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum physical silicon hits (i.e. dead sensors do not count): "
380  trackCuts["SiHits"].push_back([minNSiHitsPhysical = m_minNSiHitsPhysical](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
381  return getSummarySum<2,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelHits, xAOD::numberOfSCTHits} ) >= minNSiHitsPhysical ;
382  });
383  }
384  if (maxIntIsSet(m_maxNSiHoles)) {
385  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum silicon holes: " << m_maxNSiHoles );
386  trackCuts["SiHits"].push_back([maxNSiHoles = m_maxNSiHoles](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
387  return getSummarySum<2,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelHoles, xAOD::numberOfSCTHoles} ) <= maxNSiHoles ;
388  });
389  }
391  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum silicon shared hits: " << m_maxNSiSharedHits );
392  trackCuts["SiHits"].push_back([maxNSiSharedHits = m_maxNSiSharedHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
393  return getSummarySum<2,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelSharedHits, xAOD::numberOfSCTSharedHits} ) <= maxNSiSharedHits ;
394  });
395  }
396  if (m_maxOneSharedModule) {
397  if constexpr(VERBOSE>0) ATH_MSG_INFO( " No more than one shared module:" );
398  if constexpr(VERBOSE>0) ATH_MSG_INFO( " i.e. max 1 shared pixel hit or" );
399  if constexpr(VERBOSE>0) ATH_MSG_INFO( " 2 shared SCT hits, and not both." );
400  trackCuts["SiHits"].push_back([](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
402  + getSummary(helper, msgHelper,xAOD::numberOfSCTSharedHits )/2 <= 1 ;
403  });
404  }
405  if (m_minNSiHitsIfSiSharedHits > 0) {
406  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum silicon hits if the track has shared hits: "
408  trackCuts["SiHits"].push_back([minNSiHitsIfSiSharedHits = m_minNSiHitsIfSiSharedHits](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
409  return getSummarySum<2,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelSharedHits, xAOD::numberOfSCTSharedHits} ) == 0
410  || getSummarySum<4,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelHits,
413  xAOD::numberOfSCTDeadSensors}) >=minNSiHitsIfSiSharedHits;
414  });
415  }
418  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Require " << m_minNSiHitsAboveEtaCutoff
419  << " silicon hits above eta = " << m_minEtaForStrictNSiHitsCut );
420  trackCuts["SiHits"].push_back([minEtaForStrictNSiHitsCut = m_minEtaForStrictNSiHitsCut,
421  minNSiHitsAboveEtaCutoff = m_minNSiHitsAboveEtaCutoff](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
422  return std::abs(helper.eta(msgHelper)) <= minEtaForStrictNSiHitsCut
423  || getSummarySum<4,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelHits,
426  xAOD::numberOfSCTDeadSensors}) >= minNSiHitsAboveEtaCutoff;
427  });
428  }
430  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Zero pixel holes allowed, except one pix hole is allowed if there is a physical IBL hit and a BLayer hit is expected but there is no BLayer hit." );
431  trackCuts["PixHits"].push_back([](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
432  uint8_t pixel_holes = getSummary(helper, msgHelper,xAOD::numberOfPixelHoles);
433  return pixel_holes == 0 || ( pixel_holes<=1 && getSummary(helper, msgHelper,xAOD::numberOfInnermostPixelLayerHits) >= 1
436  });
437  }
438 #ifndef XAOD_ANALYSIS
439  if (m_minNSiHitsMod > 0) {
440  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum modified Si hits (2*pix + sct) (does not include dead sensors)= "
441  << m_minNSiHitsMod );
442  trackCuts["SiHits"].push_back([minNSiHitsMod = m_minNSiHitsMod](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
443  return getSummarySum<3,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelHits,
444  xAOD::numberOfPixelHits, // pixel hits count twice in this definition
445  xAOD::numberOfSCTHits}) >= minNSiHitsMod;
446  });
447  }
448  if (m_minNSiHitsModTop > 0 || m_minNSiHitsModBottom > 0) {
449  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum modified Si hits in top half = "
450  << m_minNSiHitsModTop );
451  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum modified Si hits in bottom half = "
453  trackCuts["SiHits"].push_back([minNSiHitsModTop = m_minNSiHitsModTop,
454  minNSiHitsModBottom = m_minNSiHitsModBottom](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
455  auto [top,bottom] = getSiHitsTopBottom(helper, msgHelper);
456  return top >= minNSiHitsModTop && bottom >= minNSiHitsModBottom;
457  });
458  }
459 #endif
461  if constexpr(VERBOSE>0) ATH_MSG_INFO( " -- TRT hit cuts applied above eta = " << m_maxTrtEtaAcceptance
462  << " and below eta = " << m_maxEtaForTrtHitCuts << " --" );
463  if (m_minNTrtHits > 0) {
464  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum TRT hits outside eta acceptance: " << m_minNTrtHits );
465  trackCuts["TrtHits"].push_back( MinTRTHitsCut<Trk_Helper,1>( m_maxTrtEtaAcceptance, m_maxEtaForTrtHitCuts, m_minNTrtHits,
467  }
468  if (m_minNTrtHitsPlusOutliers > 0) {
469  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum TRT hits outside eta acceptance including outliers: " << m_minNTrtHitsPlusOutliers );
470  trackCuts["TrtHits"].push_back( MinTRTHitsCut<Trk_Helper,2>( m_maxTrtEtaAcceptance,m_maxEtaForTrtHitCuts, m_minNTrtHitsPlusOutliers,
472  }
473  if (m_minNTrtHighThresholdHits > 0) {
474  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum TRT hits outside eta acceptance above high energy threshold: "
476  trackCuts["TrtHits"].push_back( MinTRTHitsCut<Trk_Helper,1>( m_maxTrtEtaAcceptance,m_maxEtaForTrtHitCuts, m_minNTrtHighThresholdHits,
478  }
480  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum TRT hits outside eta acceptance above high energy threshold including outliers: "
482  trackCuts["TrtHits"].push_back( MinTRTHitsCut<Trk_Helper,2>( m_maxTrtEtaAcceptance,m_maxEtaForTrtHitCuts, m_minNTrtHighThresholdHitsPlusOutliers,
484  }
485  if (maxDoubleIsSet(m_maxTrtHighEFraction)) { // I think this condition could be instead that it is between 0 and 1
486  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum ratio of high threshold to regular TRT hits outside eta acceptance: "
488  trackCuts["TrtHits"].push_back([maxTrtEtaAcceptance = m_maxTrtEtaAcceptance,
489  maxEtaForTrtHitCuts = m_maxEtaForTrtHitCuts,
490  maxTrtHighEFraction = m_maxTrtHighEFraction](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
491  double absEta = std::abs( helper.eta( msgHelper) );
492  return (absEta <= maxTrtEtaAcceptance || absEta > maxEtaForTrtHitCuts)
494  <= maxTrtHighEFraction * getSummary(helper, msgHelper,xAOD::numberOfTRTHits );
495  });
496  }
498  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum ratio of high threshold to regular TRT hits above eta acceptance including outliers: "
500  trackCuts["TrtHits"].push_back([maxTrtEtaAcceptance = m_maxTrtEtaAcceptance,
501  maxEtaForTrtHitCuts = m_maxEtaForTrtHitCuts,
502  maxTrtHighEFractionWithOutliers = m_maxTrtHighEFractionWithOutliers](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
503  double absEta = std::abs( helper.eta( msgHelper) );
504  return (absEta <= maxTrtEtaAcceptance || absEta > maxEtaForTrtHitCuts)
505  || ( getSummarySum<2,Trk_Helper>(helper, msgHelper,{xAOD::numberOfTRTHighThresholdHits, xAOD::numberOfTRTHighThresholdOutliers} ))
506  <= maxTrtHighEFractionWithOutliers * ( getSummarySum<2,Trk_Helper>(helper, msgHelper,{xAOD::numberOfTRTHits, xAOD::numberOfTRTOutliers} ));
507  });
508  }
509  if (m_maxTrtOutlierFraction < 1. && m_maxTrtOutlierFraction >= 0.) {
510  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum fraction of TRT hits that are outliers: " << m_maxTrtOutlierFraction );
511  trackCuts["TrtHits"].push_back([maxTrtEtaAcceptance = m_maxTrtEtaAcceptance,
512  maxEtaForTrtHitCuts = m_maxEtaForTrtHitCuts,
513  maxTrtOutlierFraction = m_maxTrtOutlierFraction](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
514  double absEta = std::abs( helper.eta( msgHelper) );
515  uint8_t trt_outliers = getSummary(helper, msgHelper,xAOD::numberOfTRTOutliers );
516  return ( absEta <= maxTrtEtaAcceptance || absEta > maxEtaForTrtHitCuts)
517  || trt_outliers <= maxTrtOutlierFraction * ( trt_outliers + getSummary(helper, msgHelper,xAOD::numberOfTRTHits) );
518  });
519  }
520  }
521 
522  // fit quality cuts
524  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Using pre-defined eta-dependent maximum chi squared (no longer recommended)." );
525  trackCuts["FitQuality"].push_back([](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
526  double eta = helper.eta(msgHelper);
527  double fit_chi_square = getFitChiSquare(helper,msgHelper);
528  double fit_ndof = getFitNDoF(helper,msgHelper);
529  if (std::abs( eta) < 1.9) {
530  return fit_chi_square <= fit_ndof * ( 4.4 + 0.32*sqr(eta) );
531  }
532  else {
533  return fit_chi_square <= fit_ndof * ( 26.9 - 19.6978*std::abs(eta) + 4.4534*sqr(eta) );
534  }
535  });
536  }
537  if (maxDoubleIsSet(m_maxChiSq)) {
538  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum chi squared: " << m_maxChiSq );
539  trackCuts["FitQuality"].push_back([maxChiSq = m_maxChiSq](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
540  return getFitChiSquare(helper,msgHelper) <= maxChiSq;
541  });
542  }
544  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Maximum chi squared per degree of freedom: " << m_maxChiSqperNdf );
545  trackCuts["FitQuality"].push_back([maxChiSqperNdf = m_maxChiSqperNdf](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
546  return getFitChiSquare(helper,msgHelper) <= maxChiSqperNdf * getFitNDoF(helper,msgHelper);
547  });
548  }
549  if (m_minProb > 0.) {
550  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum chi squared probability: " << m_minProb );
551  trackCuts["FitQuality"].push_back([minProb = m_minProb](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
552  return TMath::Prob( getFitChiSquare(helper,msgHelper),getFitNDoF(helper,msgHelper)) >= minProb;
553  });
554  }
556  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum chi-sq probability of " << m_minProbAbovePtCutoff
557  << " above pt of " << m_minPtForProbCut*1e-3 << " GeV." );
558  trackCuts["FitQuality"].push_back([minPtForProbCut = m_minPtForProbCut,
559  minProbAbovePtCutoff = m_minProbAbovePtCutoff](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
560  return helper.pt(msgHelper) <= minPtForProbCut
561  || TMath::Prob( getFitChiSquare(helper,msgHelper),getFitNDoF(helper,msgHelper)) >= minProbAbovePtCutoff;
562  });
563  }
564 
565  // dE/dx cuts
566  if (m_minNUsedHitsdEdx > 0) {
567  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum used hits for dEdx: " << m_minNUsedHitsdEdx );
568  trackCuts["dEdxHits"].push_back([minNUsedHitsdEdx = m_minNUsedHitsdEdx](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
569  return getNumberOfUsedHitsdEdx(helper,msgHelper) >= minNUsedHitsdEdx;
570  });
571  }
572  if (m_minNOverflowHitsdEdx > 0) {
573  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum IBL overflow hits for dEdx: " << m_minNOverflowHitsdEdx );
574  trackCuts["dEdxHits"].push_back([minNOverflowHitsdEdx = m_minNOverflowHitsdEdx](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
575  return getNumberOfIBLOverflowsdEdx(helper,msgHelper) >= minNOverflowHitsdEdx;
576  });
577  }
578  if (m_minEProbabilityHT > 0) {
579  if constexpr(VERBOSE>0) ATH_MSG_INFO( " Minimum high threshold electron probability: " << m_minEProbabilityHT );
581  if constexpr(VERBOSE>0) ATH_MSG_INFO( " (only applied on tracks where all TRT hits are Xenon)" );
582  trackCuts["eProbHT"].push_back([minEProbabilityHT = m_minEProbabilityHT](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
583  return getSummarySum<2,Trk_Helper>(helper, msgHelper, {xAOD::numberOfTRTHits, xAOD::numberOfTRTOutliers})
585  || getEProbabilityHT(helper,msgHelper) >= minEProbabilityHT;
586  });
587  } else {
588  trackCuts["eProbHT"].push_back([minEProbabilityHT = m_minEProbabilityHT](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
589  return getEProbabilityHT(helper,msgHelper) >= minEProbabilityHT;
590  });
591  }
592  }
593 
594  if (!m_vecEtaCutoffsForSiHitsCut.empty() || !m_vecMinNSiHitsAboveEta.empty()) {
595  auto cutSize = m_vecEtaCutoffsForSiHitsCut.size();
596  if (cutSize != m_vecMinNSiHitsAboveEta.size()) {
597  ATH_MSG_ERROR( "Eta cutoffs and Silicon hit cuts must be vectors of the same length." );
598  return StatusCode::FAILURE;
599  }
600  if constexpr(VERBOSE>0) {
601  for (size_t i_cut=0; i_cut<cutSize-1; ++i_cut) {
602  ATH_MSG_INFO( " for " << m_vecEtaCutoffsForSiHitsCut[i_cut]
603  << " < eta < " << m_vecEtaCutoffsForSiHitsCut[i_cut+1]
604  << " ,Silicon hits >= " << m_vecMinNSiHitsAboveEta[i_cut] );
605  }
606  }
607  if (!checkOrder(m_vecEtaCutoffsForSiHitsCut.value())) {
608  ATH_MSG_ERROR( "Eta values not in ascending order." );
609  return StatusCode::FAILURE;
610  }
611  if constexpr(VERBOSE>0) ATH_MSG_INFO( " for eta > " << m_vecEtaCutoffsForSiHitsCut[cutSize-1]
612  << " ,Silicon hits >= " << m_vecMinNSiHitsAboveEta[cutSize-1] );
613 
614  trackCuts["SiHits"].push_back([p_vecEtaCutoffsForSiHitsCut = &std::as_const(m_vecEtaCutoffsForSiHitsCut.value()),
615  p_vecMinNSiHitsAboveEta = &std::as_const(m_vecMinNSiHitsAboveEta.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
616  double abs_eta = std::abs(helper.eta(msgHelper));
617  unsigned int bin_i = findBin(*p_vecEtaCutoffsForSiHitsCut, abs_eta);
618  return bin_i >= p_vecMinNSiHitsAboveEta->size()
619  || abs_eta>5.0
620  || getSummarySum<4,Trk_Helper>(helper, msgHelper,{xAOD::numberOfPixelHits,
623  xAOD::numberOfSCTDeadSensors}) >= (*p_vecMinNSiHitsAboveEta)[bin_i];
624  });
625  }
626 
627  if (!m_vecEtaCutoffsForPtCut.empty() || !m_vecMinPtAboveEta.empty()) {
628  auto cutSize = m_vecEtaCutoffsForPtCut.size();
629  if (cutSize != m_vecMinPtAboveEta.size()) {
630  ATH_MSG_ERROR( "Eta cutoffs and pT cuts must be vectors of the same length." );
631  return StatusCode::FAILURE;
632  }
633  if constexpr(VERBOSE>0) {
634  for (size_t i_cut=0; i_cut<cutSize-1; ++i_cut) {
635  ATH_MSG_INFO( " for " << m_vecEtaCutoffsForPtCut[i_cut]
636  << " < eta < " << m_vecEtaCutoffsForPtCut[i_cut+1]
637  << " ,transverse momentum >= " << m_vecMinPtAboveEta[i_cut] );
638  }
639  }
640  if (!checkOrder(m_vecEtaCutoffsForPtCut.value())) {
641  ATH_MSG_ERROR( "Eta values not in ascending order." );
642  return StatusCode::FAILURE;
643  }
644  if constexpr(VERBOSE>0) ATH_MSG_INFO( " for eta > " << m_vecEtaCutoffsForPtCut[cutSize-1]
645  << " ,transverse momentum >= " << m_vecMinPtAboveEta[cutSize-1] );
646  trackCuts["Pt"].push_back([p_vecEtaCutoffsForPtCut = &std::as_const(m_vecEtaCutoffsForPtCut.value()),
647  p_vecMinPtAboveEta = &std::as_const(m_vecMinPtAboveEta.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
648  double abs_eta = std::abs(helper.eta(msgHelper));
649  unsigned int bin_i = findBin(*p_vecEtaCutoffsForPtCut, abs_eta);
650  return bin_i >= p_vecMinPtAboveEta->size() || abs_eta > 5.0 || helper.pt(msgHelper) >= (*p_vecMinPtAboveEta)[bin_i];
651  });
652  }
653 
654  if (!m_vecPtCutoffsForSctHitsCut.empty() || !m_vecMinNSctHitsAbovePt.empty()) {
655  auto cutSize = m_vecPtCutoffsForSctHitsCut.size();
656  if (cutSize != m_vecMinNSctHitsAbovePt.size()) {
657  ATH_MSG_ERROR( "Pt cutoffs and SCT hit cuts must be vectors of the same length." );
658  return StatusCode::FAILURE;
659  }
660  if constexpr(VERBOSE>0) {
661  for (size_t i_cut=0; i_cut<cutSize-1; ++i_cut) {
662  ATH_MSG_INFO( " for " << m_vecPtCutoffsForSctHitsCut[i_cut]
663  << " < pt < " << m_vecPtCutoffsForSctHitsCut[i_cut+1]
664  << " MeV,\tSCT hits >= " << m_vecMinNSctHitsAbovePt[i_cut] );
665  }
666  }
667  if (!checkOrder(m_vecPtCutoffsForSctHitsCut.value())) {
668  ATH_MSG_ERROR( "Pt values not in ascending order." );
669  return StatusCode::FAILURE;
670  }
671  if constexpr(VERBOSE>0) ATH_MSG_INFO( " for pt > " << m_vecPtCutoffsForSctHitsCut[cutSize-1]
672  << " MeV,\t\tSCT hits >= " << m_vecMinNSctHitsAbovePt[cutSize-1] );
673  trackCuts["SctHits"].push_back([p_vecPtCutoffsForSctHitsCut = &std::as_const(m_vecPtCutoffsForSctHitsCut.value()),
674  p_vecMinNSctHitsAbovePt = &std::as_const(m_vecMinNSctHitsAbovePt.value())](Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
675  double pt = helper.pt(msgHelper);
676  unsigned int bin_i = findBin(*p_vecPtCutoffsForSctHitsCut, pt);
677  return bin_i >= p_vecPtCutoffsForSctHitsCut->size()
678  || getSummarySum<2,Trk_Helper>(helper, msgHelper,{xAOD::numberOfSCTHits,
679  xAOD::numberOfSCTDeadSensors}) >= (*p_vecMinNSctHitsAbovePt)[bin_i];
680  });
681  }
682 
683  if (!m_vecPtCutoffsForZ0SinThetaCut.empty() ||
686  auto etaSize = m_vecEtaCutoffsForZ0SinThetaCut.size();
687  auto ptSize = m_vecPtCutoffsForZ0SinThetaCut.size();
688  if (etaSize != m_vecvecMaxZ0SinThetaAboveEtaPt.size()) {
689  ATH_MSG_ERROR( "Eta cutoffs and Z0SinTheta cuts must be vectors of the same length." );
690  return StatusCode::FAILURE;
691  }
692  for (size_t i_size=0; i_size<etaSize-1; ++i_size) {
693  if (ptSize != m_vecvecMaxZ0SinThetaAboveEtaPt[i_size].size()) {
694  ATH_MSG_ERROR( "Pt cutoffs and Z0SinTheta cuts must be vectors of the same length." );
695  return StatusCode::FAILURE;
696  }
697  }
698 
699  std::stringstream pTRangeBuffer;
700  std::copy(m_vecPtCutoffsForZ0SinThetaCut.begin(), m_vecPtCutoffsForZ0SinThetaCut.end(), std::ostream_iterator<Double_t>(pTRangeBuffer, ", "));
701  std::string pTString=pTRangeBuffer.str();
702  if constexpr(VERBOSE>0) ATH_MSG_INFO("Z0SinTheta cuts (<=) for pT above "<<pTString.substr(0, pTString.size()-2)<<"MeV, respectively:");
703  for (size_t i_cut_eta=0; i_cut_eta<etaSize; ++i_cut_eta)
704  {
705  std::stringstream etaRangeBuffer;
706  etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForZ0SinThetaCut[i_cut_eta] << " < |#eta| < ";
707  if(i_cut_eta!=etaSize-1) etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForZ0SinThetaCut[i_cut_eta+1];
708  else etaRangeBuffer << std::setprecision(2) << std::fixed <<m_maxAbsEta;
709 
710  std::stringstream cutBuffer;
711  std::copy(m_vecvecMaxZ0SinThetaAboveEtaPt[i_cut_eta].begin(), m_vecvecMaxZ0SinThetaAboveEtaPt[i_cut_eta].end(), std::ostream_iterator<Double_t>(cutBuffer, ", "));
712  std::string cutString=cutBuffer.str();
713 
714  if constexpr(VERBOSE>0) ATH_MSG_INFO(" for "<<etaRangeBuffer.str()<<": "<<cutString.substr(0, cutString.size()-2));
715  }
716 
718  ATH_MSG_ERROR( "Eta values not in ascending order." );
719  return StatusCode::FAILURE;
720  }
722  ATH_MSG_ERROR( "Pt values not in ascending order." );
723  return StatusCode::FAILURE;
724  }
725 
726  trackCuts["Z0SinTheta"].push_back([p_vecEtaCutoffsForZ0SinThetaCut = &std::as_const(m_vecEtaCutoffsForZ0SinThetaCut.value()),
727  p_vecPtCutoffsForZ0SinThetaCut = &std::as_const(m_vecPtCutoffsForZ0SinThetaCut.value()),
728  p_vecvecMaxZ0SinThetaAboveEtaPt = &std::as_const(m_vecvecMaxZ0SinThetaAboveEtaPt.value())] (Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
729  double eta = helper.eta(msgHelper);
730  unsigned int bin_eta = findBin(*p_vecEtaCutoffsForZ0SinThetaCut, std::fabs(eta));
731  double pt = helper.pt(msgHelper);
732  unsigned int bin_pt = findBin(*p_vecPtCutoffsForZ0SinThetaCut, pt);
733  return bin_eta >= p_vecEtaCutoffsForZ0SinThetaCut->size()
734  || bin_pt >= p_vecPtCutoffsForZ0SinThetaCut->size()
735  || std::fabs(helper.z0(msgHelper) * std::sin(helper.theta(msgHelper))) <= (*p_vecvecMaxZ0SinThetaAboveEtaPt)[bin_eta][bin_pt];
736  });
737  }
738 
739  if (!m_vecPtCutoffsForD0Cut.empty() ||
740  !m_vecEtaCutoffsForD0Cut.empty() ||
741  !m_vecvecMaxD0AboveEtaPt.empty()) {
742  auto etaSize = m_vecEtaCutoffsForD0Cut.size();
743  auto ptSize = m_vecPtCutoffsForD0Cut.size();
744  if (etaSize != m_vecvecMaxD0AboveEtaPt.size()) {
745  ATH_MSG_ERROR( "Eta cutoffs and D0 cuts must be vectors of the same length." );
746  return StatusCode::FAILURE;
747  }
748  for (size_t i_size=0; i_size<etaSize-1; ++i_size) {
749  if (ptSize != m_vecvecMaxD0AboveEtaPt[i_size].size()) {
750  ATH_MSG_ERROR( "Pt cutoffs and D0 cuts must be vectors of the same length." );
751  return StatusCode::FAILURE;
752  }
753  }
754 
755  std::stringstream pTRangeBuffer;
756  std::copy(m_vecPtCutoffsForD0Cut.begin(), m_vecPtCutoffsForD0Cut.end(), std::ostream_iterator<Double_t>(pTRangeBuffer, ", "));
757  std::string pTString=pTRangeBuffer.str();
758  if constexpr(VERBOSE>0) ATH_MSG_INFO("D0 cuts (<=) for pT above "<<pTString.substr(0, pTString.size()-2)<<"MeV, respectively:");
759  for (size_t i_cut_eta=0; i_cut_eta<etaSize; ++i_cut_eta)
760  {
761  std::stringstream etaRangeBuffer;
762  etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForD0Cut[i_cut_eta] << " < |#eta| < ";
763  if(i_cut_eta!=etaSize-1) etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForD0Cut[i_cut_eta+1];
764  else etaRangeBuffer << std::setprecision(2) << std::fixed <<m_maxAbsEta;
765 
766  std::stringstream cutBuffer;
767  std::copy(m_vecvecMaxD0AboveEtaPt[i_cut_eta].begin(), m_vecvecMaxD0AboveEtaPt[i_cut_eta].end(), std::ostream_iterator<Double_t>(cutBuffer, ", "));
768  std::string cutString=cutBuffer.str();
769 
770  if constexpr(VERBOSE>0) ATH_MSG_INFO(" for "<<etaRangeBuffer.str()<<": "<<cutString.substr(0, cutString.size()-2));
771  }
772 
774  ATH_MSG_ERROR( "Eta values not in ascending order." );
775  return StatusCode::FAILURE;
776  }
777  if (!checkOrder(m_vecPtCutoffsForD0Cut.value())) {
778  ATH_MSG_ERROR( "Pt values not in ascending order." );
779  return StatusCode::FAILURE;
780  }
781 
782  trackCuts["D0"].push_back([p_vecEtaCutoffsForD0Cut = &std::as_const(m_vecEtaCutoffsForD0Cut.value()),
783  p_vecPtCutoffsForD0Cut = &std::as_const(m_vecPtCutoffsForD0Cut.value()),
784  p_vecvecMaxD0AboveEtaPt = &std::as_const(m_vecvecMaxD0AboveEtaPt.value())] (Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
785  double eta = helper.eta(msgHelper);
786  unsigned int bin_eta = findBin(*p_vecEtaCutoffsForD0Cut, std::fabs(eta));
787  double pt = helper.pt(msgHelper);
788  unsigned int bin_pt = findBin(*p_vecPtCutoffsForD0Cut, pt);
789  return bin_eta >= p_vecEtaCutoffsForD0Cut->size()
790  || bin_pt >= p_vecPtCutoffsForD0Cut->size()
791  || std::fabs(helper.d0(msgHelper)) <= (*p_vecvecMaxD0AboveEtaPt)[bin_eta][bin_pt];
792  });
793  }
794 
795  if (!m_vecPtCutoffsForSctHolesCut.empty() ||
798  auto etaSize = m_vecEtaCutoffsForSctHolesCut.size();
799  auto ptSize = m_vecPtCutoffsForSctHolesCut.size();
800  if (etaSize != m_vecvecMaxSctHolesAboveEtaPt.size()) {
801  ATH_MSG_ERROR( "Eta cutoffs and SctHoles cuts must be vectors of the same length." );
802  return StatusCode::FAILURE;
803  }
804  for (size_t i_size=0; i_size<etaSize-1; ++i_size) {
805  if (ptSize != m_vecvecMaxSctHolesAboveEtaPt[i_size].size()) {
806  ATH_MSG_ERROR( "Pt cutoffs and SctHoles cuts must be vectors of the same length." );
807  return StatusCode::FAILURE;
808  }
809  }
810 
811  std::stringstream pTRangeBuffer;
812  std::copy(m_vecPtCutoffsForSctHolesCut.begin(), m_vecPtCutoffsForSctHolesCut.end(), std::ostream_iterator<Double_t>(pTRangeBuffer, ", "));
813  std::string pTString=pTRangeBuffer.str();
814  if constexpr(VERBOSE>0) ATH_MSG_INFO("SctHoles cuts (<=) for pT above "<<pTString.substr(0, pTString.size()-2)<<"MeV, respectively:");
815  for (size_t i_cut_eta=0; i_cut_eta<etaSize; ++i_cut_eta)
816  {
817  std::stringstream etaRangeBuffer;
818  etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForSctHolesCut[i_cut_eta] << " < |#eta| < ";
819  if(i_cut_eta!=etaSize-1) etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForSctHolesCut[i_cut_eta+1];
820  else etaRangeBuffer << std::setprecision(2) << std::fixed <<m_maxAbsEta;
821 
822  std::stringstream cutBuffer;
823  std::copy(m_vecvecMaxSctHolesAboveEtaPt[i_cut_eta].begin(), m_vecvecMaxSctHolesAboveEtaPt[i_cut_eta].end(), std::ostream_iterator<Double_t>(cutBuffer, ", "));
824  std::string cutString=cutBuffer.str();
825 
826  if constexpr(VERBOSE>0) ATH_MSG_INFO(" for "<<etaRangeBuffer.str()<<": "<<cutString.substr(0, cutString.size()-2));
827  }
828 
830  ATH_MSG_ERROR( "Eta values not in ascending order." );
831  return StatusCode::FAILURE;
832  }
834  ATH_MSG_ERROR( "Pt values not in ascending order." );
835  return StatusCode::FAILURE;
836  }
837 
838  trackCuts["SctHits"].push_back([p_vecEtaCutoffsForSctHolesCut = &std::as_const(m_vecEtaCutoffsForSctHolesCut.value()),
839  p_vecPtCutoffsForSctHolesCut = &std::as_const(m_vecPtCutoffsForSctHolesCut.value()),
840  p_vecvecMaxSctHolesAboveEtaPt = &std::as_const(m_vecvecMaxSctHolesAboveEtaPt.value())] (Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
841  double eta = helper.eta(msgHelper);
842  unsigned int bin_eta = findBin(*p_vecEtaCutoffsForSctHolesCut, std::fabs(eta));
843  double pt = helper.pt(msgHelper);
844  unsigned int bin_pt = findBin(*p_vecPtCutoffsForSctHolesCut, pt);
845  return bin_eta >= p_vecEtaCutoffsForSctHolesCut->size()
846  || bin_pt >= p_vecPtCutoffsForSctHolesCut->size()
847  || getSummary(helper, msgHelper, xAOD::numberOfSCTHoles) <= (*p_vecvecMaxSctHolesAboveEtaPt)[bin_eta][bin_pt];
848  });
849  }
850 
854  auto etaSize = m_vecEtaCutoffsForSctHitsPlusDeadCut.size();
855  auto ptSize = m_vecPtCutoffsForSctHitsPlusDeadCut.size();
856  if (etaSize != m_vecvecMinSctHitsPlusDeadAboveEtaPt.size()) {
857  ATH_MSG_ERROR( "Eta cutoffs and SctHitsPlusDead cuts must be vectors of the same length." );
858  return StatusCode::FAILURE;
859  }
860  for (size_t i_size=0; i_size<etaSize-1; ++i_size) {
861  if (ptSize != m_vecvecMinSctHitsPlusDeadAboveEtaPt[i_size].size()) {
862  ATH_MSG_ERROR( "Pt cutoffs and SctHitsPlusDead cuts must be vectors of the same length." );
863  return StatusCode::FAILURE;
864  }
865  }
866 
867  std::stringstream pTRangeBuffer;
868  std::copy(m_vecPtCutoffsForSctHitsPlusDeadCut.begin(), m_vecPtCutoffsForSctHitsPlusDeadCut.end(), std::ostream_iterator<Double_t>(pTRangeBuffer, ", "));
869  std::string pTString=pTRangeBuffer.str();
870  if constexpr(VERBOSE>0) ATH_MSG_INFO("SctHitsPlusDead cuts (>=) for pT above "<<pTString.substr(0, pTString.size()-2)<<"MeV, respectively:");
871  for (size_t i_cut_eta=0; i_cut_eta<etaSize; ++i_cut_eta)
872  {
873  std::stringstream etaRangeBuffer;
874  etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForSctHitsPlusDeadCut[i_cut_eta] << " < |#eta| < ";
875  if(i_cut_eta!=etaSize-1) etaRangeBuffer << std::setprecision(2) << std::fixed << m_vecEtaCutoffsForSctHitsPlusDeadCut[i_cut_eta+1];
876  else etaRangeBuffer << std::setprecision(2) << std::fixed <<m_maxAbsEta;
877 
878  std::stringstream cutBuffer;
879  std::copy(m_vecvecMinSctHitsPlusDeadAboveEtaPt[i_cut_eta].begin(), m_vecvecMinSctHitsPlusDeadAboveEtaPt[i_cut_eta].end(), std::ostream_iterator<Double_t>(cutBuffer, ", "));
880  std::string cutString=cutBuffer.str();
881 
882  if constexpr(VERBOSE>0) ATH_MSG_INFO(" for "<<etaRangeBuffer.str()<<": "<<cutString.substr(0, cutString.size()-2));
883  }
884 
886  ATH_MSG_ERROR( "Eta values not in ascending order." );
887  return StatusCode::FAILURE;
888  }
890  ATH_MSG_ERROR( "Pt values not in ascending order." );
891  return StatusCode::FAILURE;
892  }
893 
894  trackCuts["SctHits"].push_back([p_vecEtaCutoffsForSctHitsPlusDeadCut = &std::as_const(m_vecEtaCutoffsForSctHitsPlusDeadCut.value()),
895  p_vecPtCutoffsForSctHitsPlusDeadCut = &std::as_const(m_vecPtCutoffsForSctHitsPlusDeadCut.value()),
896  p_vecvecMinSctHitsPlusDeadAboveEtaPt = &std::as_const(m_vecvecMinSctHitsPlusDeadAboveEtaPt.value())] (Trk_Helper helper, const asg::AsgMessaging &msgHelper) {
897  double eta = helper.eta(msgHelper);
898  unsigned int bin_eta = findBin(*p_vecEtaCutoffsForSctHitsPlusDeadCut, std::fabs(eta));
899  double pt = helper.pt(msgHelper);
900  unsigned int bin_pt = findBin(*p_vecPtCutoffsForSctHitsPlusDeadCut, pt);
901  return bin_eta >= p_vecEtaCutoffsForSctHitsPlusDeadCut->size()
902  || bin_pt >= p_vecPtCutoffsForSctHitsPlusDeadCut->size()
903  || getSummarySum<2,Trk_Helper>(helper, msgHelper, {xAOD::numberOfSCTHits, xAOD::numberOfSCTDeadSensors}) >= (*p_vecvecMinSctHitsPlusDeadAboveEtaPt)[bin_eta][bin_pt];
904  });
905  }
906 
907  return StatusCode::SUCCESS;
908 }

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

Friends And Related Function Documentation

◆ TrackCut

friend class TrackCut
friend

Definition at line 54 of file InDetTrackSelectionTool.h.

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::vector<ULong64_t> m_numTracksPassedCuts InDet::InDetTrackSelectionTool::ATLAS_THREAD_SAFE
mutableprivate

tracks the number of tracks that passed each cut family.

Guarded by m_mutex

Definition at line 133 of file InDetTrackSelectionTool.h.

◆ LOCAL_MAX_DOUBLE

constexpr static Double_t InDet::InDetTrackSelectionTool::LOCAL_MAX_DOUBLE = 1.0e16
staticconstexprprivate

Definition at line 138 of file InDetTrackSelectionTool.h.

◆ LOCAL_MAX_INT

constexpr static Int_t InDet::InDetTrackSelectionTool::LOCAL_MAX_INT = std::numeric_limits<Int_t>::max()
staticconstexprprivate

Definition at line 139 of file InDetTrackSelectionTool.h.

◆ m_acceptInfo

asg::AcceptInfo InDet::InDetTrackSelectionTool::m_acceptInfo
private

Object used to store the last decision.

Object that stores detailed selection information

Definition at line 352 of file InDetTrackSelectionTool.h.

◆ m_cutLevel

Gaudi::Property<std::string> InDet::InDetTrackSelectionTool::m_cutLevel {this, "CutLevel", ""}
private

The string version of the cut level so that it can be set via jobOptions.

Definition at line 356 of file InDetTrackSelectionTool.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_eProbHTonlyForXe

Gaudi::Property<Bool_t> InDet::InDetTrackSelectionTool::m_eProbHTonlyForXe
private
Initial value:
{this, "eProbHTonlyForXe", false,
"Flag whether to apply the eProbabilityHT cut only when all TRT hits are Xenon"}

Definition at line 271 of file InDetTrackSelectionTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extrapolator

ToolHandle<Trk::IExtrapolator> InDet::InDetTrackSelectionTool::m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/Extrapolator"}
private

Definition at line 366 of file InDetTrackSelectionTool.h.

◆ m_initTrkTools

Gaudi::Property<Bool_t> InDet::InDetTrackSelectionTool::m_initTrkTools {this, "UseTrkTrackTools", false, "Whether to initialize the Trk::Track tools"}
private

Definition at line 362 of file InDetTrackSelectionTool.h.

◆ m_isInitialized

bool InDet::InDetTrackSelectionTool::m_isInitialized = false
private

Definition at line 108 of file InDetTrackSelectionTool.h.

◆ m_maxAbsEta

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxAbsEta {this, "maxAbsEta", LOCAL_MAX_DOUBLE, "Maximum magnitude of pseudorapidity"}
private

Definition at line 144 of file InDetTrackSelectionTool.h.

◆ m_maxChiSq

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxChiSq {this, "maxChiSq", LOCAL_MAX_DOUBLE, "Maximum chi squared"}
private

Definition at line 254 of file InDetTrackSelectionTool.h.

◆ m_maxChiSqperNdf

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxChiSqperNdf
private
Initial value:
{this, "maxChiSqperNdf", LOCAL_MAX_DOUBLE,
"Maximum chi squared per degree of freedom"}

Definition at line 256 of file InDetTrackSelectionTool.h.

◆ m_maxD0

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxD0 {this, "maxD0", LOCAL_MAX_DOUBLE, "Maximum transvers separation"}
private

Definition at line 150 of file InDetTrackSelectionTool.h.

◆ m_maxD0overSigmaD0

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxD0overSigmaD0 {this, "maxD0overSigmaD0", LOCAL_MAX_DOUBLE, "Significance cut on |d0|"}
private

Definition at line 158 of file InDetTrackSelectionTool.h.

◆ m_maxEtaForTrtHitCuts

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxEtaForTrtHitCuts
private
Initial value:
{this, "maxEtaForTrtHitCuts", -1.,
"Eta above which TRT hit cuts are not applied."}

Definition at line 233 of file InDetTrackSelectionTool.h.

◆ m_maxNInnermostLayerSharedHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNInnermostLayerSharedHits
private
Initial value:
{this, "maxNInnermostLayerSharedHits", LOCAL_MAX_INT,
"Maximum shared hits in innermost pixel layer"}

Definition at line 175 of file InDetTrackSelectionTool.h.

◆ m_maxNPixelHoles

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNPixelHoles
private
Initial value:
{this, "maxNPixelHoles", LOCAL_MAX_INT,
"Maximum number of missed layers in pixel"}

Definition at line 196 of file InDetTrackSelectionTool.h.

◆ m_maxNPixelSharedHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNPixelSharedHits
private
Initial value:
{this, "maxNPixelSharedHits", LOCAL_MAX_INT,
"Maximum pixels shared with other tracks"}

Definition at line 193 of file InDetTrackSelectionTool.h.

◆ m_maxNSctDoubleHoles

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNSctDoubleHoles {this, "maxNSctDoubleHoles", LOCAL_MAX_INT, "Maximum SCT double holes"}
private

Definition at line 227 of file InDetTrackSelectionTool.h.

◆ m_maxNSctHoles

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNSctHoles {this, "maxNSctHoles", LOCAL_MAX_INT, "Maximum SCT holes"}
private

Definition at line 225 of file InDetTrackSelectionTool.h.

◆ m_maxNSctSharedHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNSctSharedHits
private
Initial value:
{this, "maxNSctSharedHits", LOCAL_MAX_INT,
"Maximum SCT hits shared with other track"}

Definition at line 222 of file InDetTrackSelectionTool.h.

◆ m_maxNSiHoles

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNSiHoles {this, "maxNSiHoles", LOCAL_MAX_INT, "Maximum silicon (pixel + SCT) holes"}
private

Definition at line 189 of file InDetTrackSelectionTool.h.

◆ m_maxNSiSharedHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_maxNSiSharedHits
private
Initial value:
{this, "maxNSiSharedHits", LOCAL_MAX_INT,
"Maximum silicon (pixel + SCT) sensors shared with other track"}

Definition at line 183 of file InDetTrackSelectionTool.h.

◆ m_maxOneSharedModule

Gaudi::Property<Bool_t> InDet::InDetTrackSelectionTool::m_maxOneSharedModule
private
Initial value:
{this, "maxOneSharedModule", false,
"Allow only 1 shared pixel hit or 2 shared SCT hits, not both"}

Definition at line 206 of file InDetTrackSelectionTool.h.

◆ m_maxSigmaD0

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxSigmaD0 {this, "maxSigmaD0", LOCAL_MAX_DOUBLE, "Maximum error on d0"}
private

Definition at line 152 of file InDetTrackSelectionTool.h.

◆ m_maxSigmaZ0

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxSigmaZ0 {this, "maxSigmaZ0", LOCAL_MAX_DOUBLE, "Maximum error on z0"}
private

Definition at line 154 of file InDetTrackSelectionTool.h.

◆ m_maxSigmaZ0SinTheta

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxSigmaZ0SinTheta {this, "maxSigmaZ0SinTheta", LOCAL_MAX_DOUBLE, "Maximum error on z0*sin(theta)"}
private

Definition at line 156 of file InDetTrackSelectionTool.h.

◆ m_maxTrtEtaAcceptance

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxTrtEtaAcceptance
private
Initial value:
{this, "maxTrtEtaAcceptance", LOCAL_MAX_DOUBLE,
"Maximum eta that ignores TRT hit cuts"}

Definition at line 230 of file InDetTrackSelectionTool.h.

◆ m_maxTrtHighEFraction

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxTrtHighEFraction
private
Initial value:
{this, "maxTrtHighEFraction", LOCAL_MAX_DOUBLE,
"Maximum TRT hits that are above high energy threshold"}

Definition at line 244 of file InDetTrackSelectionTool.h.

◆ m_maxTrtHighEFractionWithOutliers

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxTrtHighEFractionWithOutliers
private
Initial value:
{this, "maxTrtHighEFractionWithOutliers", LOCAL_MAX_DOUBLE,
"Maximum TRT hits that are above high energy threshold including outliers"}

Definition at line 247 of file InDetTrackSelectionTool.h.

◆ m_maxTrtOutlierFraction

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxTrtOutlierFraction
private
Initial value:
{this, "maxTrtOutlierFraction", LOCAL_MAX_DOUBLE,
"Maximum fraction of TRT outliers over TRT hits plus outliers"}

Definition at line 250 of file InDetTrackSelectionTool.h.

◆ m_maxZ0

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxZ0 {this, "maxZ0", LOCAL_MAX_DOUBLE, "Maximum longitudinal separation"}
private

Definition at line 148 of file InDetTrackSelectionTool.h.

◆ m_maxZ0overSigmaZ0

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxZ0overSigmaZ0 {this, "maxZ0overSigmaZ0", LOCAL_MAX_DOUBLE, "Significance cut on |z0|"}
private

Definition at line 160 of file InDetTrackSelectionTool.h.

◆ m_maxZ0SinTheta

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxZ0SinTheta {this, "maxZ0SinTheta", LOCAL_MAX_DOUBLE, "Maximum |z0|*sin(theta)"}
private

Definition at line 146 of file InDetTrackSelectionTool.h.

◆ m_maxZ0SinThetaoverSigmaZ0SinTheta

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_maxZ0SinThetaoverSigmaZ0SinTheta
private
Initial value:
{this, "maxZ0SinThetaoverSigmaZ0SinTheta", LOCAL_MAX_DOUBLE,
"Significance cut on |z0*sin(theta)|"}

Definition at line 162 of file InDetTrackSelectionTool.h.

◆ m_minEProbabilityHT

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_minEProbabilityHT
private
Initial value:
{this, "minEProbabilityHT", -1.,
"Minimum High Threshold electron probability"}

Definition at line 274 of file InDetTrackSelectionTool.h.

◆ m_minEtaForStrictNSiHitsCut

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_minEtaForStrictNSiHitsCut
private
Initial value:
{this, "minEtaForStrictNSiHitsCut", LOCAL_MAX_DOUBLE,
"Eta cutoff for strict silicon hits cut"}

Definition at line 200 of file InDetTrackSelectionTool.h.

◆ m_minNBothInnermostLayersHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNBothInnermostLayersHits
private
Initial value:
{this, "minNBothInnermostLayersHits", -1,
"Required hits on two innermost pixel layers"}

Definition at line 172 of file InDetTrackSelectionTool.h.

◆ m_minNInnermostLayerHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNInnermostLayerHits
private
Initial value:
{this, "minNInnermostLayerHits", -1,
"Required hits on the innermost pixel layer"}

Definition at line 166 of file InDetTrackSelectionTool.h.

◆ m_minNNextToInnermostLayerHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNNextToInnermostLayerHits
private
Initial value:
{this, "minNNextToInnermostLayerHits", -1,
"Required hits on the next to innermost pixel layer"}

Definition at line 169 of file InDetTrackSelectionTool.h.

◆ m_minNOverflowHitsdEdx

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNOverflowHitsdEdx {this, "minNOverflowHitsdEdx", -1, "Minimum overflow hits in IBL for dEdx"}
private

Definition at line 269 of file InDetTrackSelectionTool.h.

◆ m_minNPixelHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNPixelHits {this, "minNPixelHits", -1, "Required pixel hits"}
private

Definition at line 191 of file InDetTrackSelectionTool.h.

◆ m_minNPixelHitsPhysical

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNPixelHitsPhysical {this, "minNPixelHitsPhysical", -1, "Minimum physical pixel hits"}
private

Definition at line 216 of file InDetTrackSelectionTool.h.

◆ m_minNSctHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSctHits {this, "minNSctHits", -1, "Minimum SCT hits"}
private

Definition at line 220 of file InDetTrackSelectionTool.h.

◆ m_minNSctHitsPhysical

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSctHitsPhysical {this, "minNSctHitsPhysical", -1, "Minimum physical SCT hits"}
private

Definition at line 218 of file InDetTrackSelectionTool.h.

◆ m_minNSiHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSiHits {this, "minNSiHits", -1, "Minimum silicon (pixel + SCT) hits"}
private

Definition at line 181 of file InDetTrackSelectionTool.h.

◆ m_minNSiHitsAboveEtaCutoff

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSiHitsAboveEtaCutoff
private
Initial value:
{this, "minNSiHitsAboveEtaCutoff", -1,
"Minimum silicon hits at large pseudorapidity"}

Definition at line 203 of file InDetTrackSelectionTool.h.

◆ m_minNSiHitsIfSiSharedHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSiHitsIfSiSharedHits
private
Initial value:
{this, "minNSiHitsIfSiSharedHits", -1,
"Minimum number of silicon hits if there are any shared silicon hits"}

Definition at line 186 of file InDetTrackSelectionTool.h.

◆ m_minNSiHitsMod

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSiHitsMod
private
Initial value:
{this, "minNSiHitsMod", -1,
"Minimum number of Si hits, with pixel hits counting twice"}

Definition at line 283 of file InDetTrackSelectionTool.h.

◆ m_minNSiHitsModBottom

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSiHitsModBottom
private
Initial value:
{this, "minNSiHitsModBottom", -1,
"Min number of Si hits on bottom half (pixel counting twice)"}

Definition at line 289 of file InDetTrackSelectionTool.h.

◆ m_minNSiHitsModTop

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSiHitsModTop
private
Initial value:
{this, "minNSiHitsModTop", -1,
"Min number of Si hits on top half (pixel counting twice)"}

Definition at line 286 of file InDetTrackSelectionTool.h.

◆ m_minNSiHitsPhysical

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNSiHitsPhysical
private
Initial value:
{this, "minNSiHitsPhysical", -1,
"Minimum physical silicon hits (i.e. dead sensors do not count)"}

Definition at line 213 of file InDetTrackSelectionTool.h.

◆ m_minNTrtHighThresholdHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNTrtHighThresholdHits {this, "minNTrtHighThresholdHits", -1, "Minimum high E TRT hits"}
private

Definition at line 239 of file InDetTrackSelectionTool.h.

◆ m_minNTrtHighThresholdHitsPlusOutliers

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNTrtHighThresholdHitsPlusOutliers
private
Initial value:
{this, "minNTrtHighThresholdHitsPlusOutliers", -1,
"Minimum high E TRT hits including outliers"}

Definition at line 241 of file InDetTrackSelectionTool.h.

◆ m_minNTrtHits

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNTrtHits {this, "minNTrtHits", -1, "Minimum TRT hits"}
private

Definition at line 236 of file InDetTrackSelectionTool.h.

◆ m_minNTrtHitsPlusOutliers

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNTrtHitsPlusOutliers {this, "minNTrtHitsPlusOutliers", -1, "Minimum TRT hits including outliers"}
private

Definition at line 237 of file InDetTrackSelectionTool.h.

◆ m_minNUsedHitsdEdx

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_minNUsedHitsdEdx {this, "minNUsedHitsdEdx", -1, "Minimum hits used for dEdx"}
private

Definition at line 267 of file InDetTrackSelectionTool.h.

◆ m_minP

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_minP {this, "minP", -1., "Minimum momentum"}
private

Definition at line 142 of file InDetTrackSelectionTool.h.

◆ m_minProb

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_minProb {this, "minProb", -1., "Minimum p(chi^2, Ndof)"}
private

Definition at line 259 of file InDetTrackSelectionTool.h.

◆ m_minProbAbovePtCutoff

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_minProbAbovePtCutoff
private
Initial value:
{this, "minProbAbovePtCutoff", -1.,
"Minimum chi-sq probability above a pt cutoff"}

Definition at line 263 of file InDetTrackSelectionTool.h.

◆ m_minPt

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_minPt {this, "minPt", -1., "Minimum transverse momentum"}
private

Definition at line 141 of file InDetTrackSelectionTool.h.

◆ m_minPtForProbCut

Gaudi::Property<Double_t> InDet::InDetTrackSelectionTool::m_minPtForProbCut
private
Initial value:
{this, "minPtForProbCut", LOCAL_MAX_DOUBLE,
"Minimum pt for chi-sq probability cut"}

Definition at line 260 of file InDetTrackSelectionTool.h.

◆ m_msgHelper

std::unique_ptr<asg::AsgMessaging> InDet::InDetTrackSelectionTool::m_msgHelper
private

Definition at line 123 of file InDetTrackSelectionTool.h.

◆ m_mutex

std::mutex InDet::InDetTrackSelectionTool::m_mutex
mutableprivate

Definition at line 134 of file InDetTrackSelectionTool.h.

◆ m_numTracksPassed

std::atomic<ULong64_t> InDet::InDetTrackSelectionTool::m_numTracksPassed = 0
mutableprivate

a counter of the number of tracks that passed all cuts

Definition at line 132 of file InDetTrackSelectionTool.h.

◆ m_numTracksProcessed

std::atomic<ULong64_t> InDet::InDetTrackSelectionTool::m_numTracksProcessed = 0
mutableprivate

a counter of the number of tracks proccessed

Definition at line 131 of file InDetTrackSelectionTool.h.

◆ m_trackAccessors

std::unordered_map< std::string, std::shared_ptr<TrackAccessor> > InDet::InDetTrackSelectionTool::m_trackAccessors
private

list of the accessors that need to be run for each track

Definition at line 121 of file InDetTrackSelectionTool.h.

◆ m_trackParticleCuts

std::map< std::string, std::vector< std::function<bool(InDetAccessor::TrackParticleHelper helper, const asg::AsgMessaging &msgHelper)> > > InDet::InDetTrackSelectionTool::m_trackParticleCuts
private

First element is the name of the cut family, second element is the set of cuts.

Definition at line 125 of file InDetTrackSelectionTool.h.

◆ m_trackSumTool

ToolHandle<Trk::ITrackSummaryTool> InDet::InDetTrackSelectionTool::m_trackSumTool {this, "TrackSummaryTool", "Trk::TrackSummaryTool/TrackSummaryTool"}
private

Definition at line 364 of file InDetTrackSelectionTool.h.

◆ m_trackSumToolAvailable

Bool_t InDet::InDetTrackSelectionTool::m_trackSumToolAvailable = false
private

Whether the summary tool is available.

Definition at line 363 of file InDetTrackSelectionTool.h.

◆ m_trkTrackCuts

std::map< std::string, std::vector< std::function<bool(InDetAccessor::TrkTrackHelper helper, const asg::AsgMessaging &msgHelper)> > > InDet::InDetTrackSelectionTool::m_trkTrackCuts
private

First element is the name of the cut family, second element is the set of cuts.

Definition at line 128 of file InDetTrackSelectionTool.h.

◆ m_useEtaDependentMaxChiSq

Gaudi::Property<Bool_t> InDet::InDetTrackSelectionTool::m_useEtaDependentMaxChiSq
private
Initial value:
{this, "useEtaDependentMaxChiSq", false,
"Whether or not to use the eta-dependent chi squared per degree of freedom cut"}

Definition at line 209 of file InDetTrackSelectionTool.h.

◆ m_useExperimentalInnermostLayersCut

Gaudi::Property<Bool_t> InDet::InDetTrackSelectionTool::m_useExperimentalInnermostLayersCut
private
Initial value:
{this, "useExperimentalInnermostLayersCut", false,
"Use the experimental cut on pixel holes"}

Definition at line 278 of file InDetTrackSelectionTool.h.

◆ m_useMinBiasInnermostLayersCut

Gaudi::Property<Int_t> InDet::InDetTrackSelectionTool::m_useMinBiasInnermostLayersCut
private
Initial value:
{this, "useMinBiasInnermostLayersCut", 0,
"IBL hit if expected, otherwise next layer hit if expected"}

Definition at line 178 of file InDetTrackSelectionTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vecEtaCutoffsForD0Cut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForD0Cut {this, "vecEtaCutoffsForD0Cut", {}, "Minimum eta cutoffs for each D0 value"}
private

Definition at line 323 of file InDetTrackSelectionTool.h.

◆ m_vecEtaCutoffsForPtCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForPtCut {this, "vecEtaCutoffsForPtCut", {}, "Minimum eta cutoffs for each pT cut"}
private

Definition at line 300 of file InDetTrackSelectionTool.h.

◆ m_vecEtaCutoffsForSctHitsPlusDeadCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForSctHitsPlusDeadCut
private
Initial value:
{this, "vecEtaCutoffsForSctHitsPlusDeadCut", {},
"Minimum eta cutoffs for each SctHitsPlusDead value"}

Definition at line 341 of file InDetTrackSelectionTool.h.

◆ m_vecEtaCutoffsForSctHolesCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForSctHolesCut
private
Initial value:
{this, "vecEtaCutoffsForSctHolesCut", {},
"Minimum eta cutoffs for each SctHoles value"}

Definition at line 331 of file InDetTrackSelectionTool.h.

◆ m_vecEtaCutoffsForSiHitsCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForSiHitsCut
private
Initial value:
{this, "vecEtaCutoffsForSiHitsCut", {},
"Minimum eta cutoffs for each Silicon hit cut"}

Definition at line 294 of file InDetTrackSelectionTool.h.

◆ m_vecEtaCutoffsForZ0SinThetaCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForZ0SinThetaCut
private
Initial value:
{this, "vecEtaCutoffsForZ0SinThetaCut", {},
"Minimum eta cutoffs for each Z0SinTheta value"}

Definition at line 313 of file InDetTrackSelectionTool.h.

◆ m_vecMinNSctHitsAbovePt

Gaudi::Property<std::vector<Int_t> > InDet::InDetTrackSelectionTool::m_vecMinNSctHitsAbovePt
private
Initial value:
{this, "vecMinNSctHitsAbovePt", {},
"Minimum SCT hits above each pt cutoff"}

Definition at line 309 of file InDetTrackSelectionTool.h.

◆ m_vecMinNSiHitsAboveEta

Gaudi::Property<std::vector<Int_t> > InDet::InDetTrackSelectionTool::m_vecMinNSiHitsAboveEta
private
Initial value:
{this, "vecMinNSiHitsAboveEta", {},
"Minimum Silicon hits above each eta cutoff"}

Definition at line 297 of file InDetTrackSelectionTool.h.

◆ m_vecMinPtAboveEta

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecMinPtAboveEta
private
Initial value:
{this, "vecMinPtAboveEta", {},
"Minimum transverse momentum above each eta cutoff"}

Definition at line 302 of file InDetTrackSelectionTool.h.

◆ m_vecPtCutoffsForD0Cut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecPtCutoffsForD0Cut {this, "vecPtCutoffsForD0Cut", {}, "Minimum pt cutoffs for each D0 value"}
private

Definition at line 325 of file InDetTrackSelectionTool.h.

◆ m_vecPtCutoffsForSctHitsCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecPtCutoffsForSctHitsCut
private
Initial value:
{this, "vecPtCutoffsForSctHitsCut", {},
"Minimum pt cutoffs for each SCT hits"}

Definition at line 306 of file InDetTrackSelectionTool.h.

◆ m_vecPtCutoffsForSctHitsPlusDeadCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecPtCutoffsForSctHitsPlusDeadCut
private
Initial value:
{this, "vecPtCutoffsForSctHitsPlusDeadCut", {},
"Minimum pt cutoffs for each SctHitsPlusDead value"}

Definition at line 344 of file InDetTrackSelectionTool.h.

◆ m_vecPtCutoffsForSctHolesCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecPtCutoffsForSctHolesCut
private
Initial value:
{this, "vecPtCutoffsForSctHolesCut", {},
"Minimum pt cutoffs for each SctHoles value"}

Definition at line 334 of file InDetTrackSelectionTool.h.

◆ m_vecPtCutoffsForZ0SinThetaCut

Gaudi::Property<std::vector<Double_t> > InDet::InDetTrackSelectionTool::m_vecPtCutoffsForZ0SinThetaCut
private
Initial value:
{this, "vecPtCutoffsForZ0SinThetaCut", {},
"Minimum pt cutoffs for each Z0SinTheta value"}

Definition at line 316 of file InDetTrackSelectionTool.h.

◆ m_vecvecMaxD0AboveEtaPt

Gaudi::Property<std::vector<std::vector<Double_t> > > InDet::InDetTrackSelectionTool::m_vecvecMaxD0AboveEtaPt
private
Initial value:
{this, "vecvecMaxD0AboveEtaPt", {},
"Maximum D0 value above each eta and pT cutoff"}

Definition at line 327 of file InDetTrackSelectionTool.h.

◆ m_vecvecMaxSctHolesAboveEtaPt

Gaudi::Property<std::vector<std::vector<Double_t> > > InDet::InDetTrackSelectionTool::m_vecvecMaxSctHolesAboveEtaPt
private
Initial value:
{this, "vecvecMaxSctHolesAboveEtaPt", {},
"Maximum SctHoles value above each eta and pT cutoff"}

Definition at line 337 of file InDetTrackSelectionTool.h.

◆ m_vecvecMaxZ0SinThetaAboveEtaPt

Gaudi::Property<std::vector<std::vector<Double_t> > > InDet::InDetTrackSelectionTool::m_vecvecMaxZ0SinThetaAboveEtaPt
private
Initial value:
{this, "vecvecMaxZ0SinThetaAboveEtaPt", {},
"Maximum Z0SinTheta value above each eta and pT cutoff"}

Definition at line 319 of file InDetTrackSelectionTool.h.

◆ m_vecvecMinSctHitsPlusDeadAboveEtaPt

Gaudi::Property<std::vector<std::vector<Double_t> > > InDet::InDetTrackSelectionTool::m_vecvecMinSctHitsPlusDeadAboveEtaPt
private
Initial value:
{this, "vecvecMinSctHitsPlusDeadAboveEtaPt", {},
"Minimum SctHitsPlusDead value above each eta and pT cutoff"}

Definition at line 347 of file InDetTrackSelectionTool.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_warnInit

std::atomic_bool InDet::InDetTrackSelectionTool::m_warnInit = false
mutableprivate

Definition at line 109 of file InDetTrackSelectionTool.h.

◆ property

virtual void the cut level is best set through the CutLevel InDet::InDetTrackSelectionTool::property
private

Definition at line 105 of file InDetTrackSelectionTool.h.

◆ s_mapCutLevel

const std::unordered_map< std::string, InDet::CutLevel > InDet::InDetTrackSelectionTool::s_mapCutLevel
staticprivate
Initial value:
=
{
{"LoosePrimary", InDet::CutLevel::LoosePrimary},
{"TightPrimary", InDet::CutLevel::TightPrimary},
{"LooseMuon", InDet::CutLevel::LooseMuon},
{"LooseElectron", InDet::CutLevel::LooseElectron},
{"LooseTau", InDet::CutLevel::LooseTau},
{"MinBias", InDet::CutLevel::MinBias},
{"HILoose", InDet::CutLevel::HILoose},
{"HITight", InDet::CutLevel::HITight},
{"HILooseOptimized", InDet::CutLevel::HILooseOptimized},
{"HITightOptimized", InDet::CutLevel::HITightOptimized}
}

Definition at line 359 of file InDetTrackSelectionTool.h.


The documentation for this class was generated from the following files:
InDet::InDetTrackSelectionTool::m_maxEtaForTrtHitCuts
Gaudi::Property< Double_t > m_maxEtaForTrtHitCuts
Definition: InDetTrackSelectionTool.h:234
checkCorrelInHIST.getSummary
def getSummary(histos, correls, fractionNonZero)
Definition: checkCorrelInHIST.py:243
Trk::anyDirection
@ anyDirection
Definition: PropDirection.h:22
InDet::InDetTrackSelectionTool::m_minNSiHitsAboveEtaCutoff
Gaudi::Property< Int_t > m_minNSiHitsAboveEtaCutoff
Definition: InDetTrackSelectionTool.h:204
used
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
InDet::InDetTrackSelectionTool::m_vecvecMaxZ0SinThetaAboveEtaPt
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMaxZ0SinThetaAboveEtaPt
Definition: InDetTrackSelectionTool.h:320
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
InDet::InDetTrackSelectionTool::m_minNBothInnermostLayersHits
Gaudi::Property< Int_t > m_minNBothInnermostLayersHits
Definition: InDetTrackSelectionTool.h:173
InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForSctHitsPlusDeadCut
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForSctHitsPlusDeadCut
Definition: InDetTrackSelectionTool.h:342
python.ConfigText_unitTest.checkOrder
checkOrder
Definition: ConfigText_unitTest.py:489
InDet::InDetTrackSelectionTool::m_trackSumToolAvailable
Bool_t m_trackSumToolAvailable
Whether the summary tool is available.
Definition: InDetTrackSelectionTool.h:363
InDet::InDetTrackSelectionTool::m_trackSumTool
ToolHandle< Trk::ITrackSummaryTool > m_trackSumTool
Definition: InDetTrackSelectionTool.h:365
InDet::InDetTrackSelectionTool::m_vecPtCutoffsForSctHolesCut
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForSctHolesCut
Definition: InDetTrackSelectionTool.h:335
InDet::InDetTrackSelectionTool::m_minNNextToInnermostLayerHits
Gaudi::Property< Int_t > m_minNNextToInnermostLayerHits
Definition: InDetTrackSelectionTool.h:170
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
InDet::InDetTrackSelectionTool::m_maxOneSharedModule
Gaudi::Property< Bool_t > m_maxOneSharedModule
Definition: InDetTrackSelectionTool.h:207
InDet::InDetTrackSelectionTool::m_vecvecMinSctHitsPlusDeadAboveEtaPt
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMinSctHitsPlusDeadAboveEtaPt
Definition: InDetTrackSelectionTool.h:348
InDetAccessor::z0
@ z0
Definition: InDetAccessor.h:32
InDet::InDetTrackSelectionTool::m_minPt
Gaudi::Property< Double_t > m_minPt
Definition: InDetTrackSelectionTool.h:141
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
InDet::InDetTrackSelectionTool::m_warnInit
std::atomic_bool m_warnInit
Definition: InDetTrackSelectionTool.h:109
InDet::InDetTrackSelectionTool::m_maxNInnermostLayerSharedHits
Gaudi::Property< Int_t > m_maxNInnermostLayerSharedHits
Definition: InDetTrackSelectionTool.h:176
xAOD::numberOfSCTSharedHits
@ numberOfSCTSharedHits
number of SCT hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:272
InDet::InDetTrackSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *) const override
Get the decision using a generic IParticle pointer.
Definition: InDetTrackSelectionTool.cxx:1006
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
InDet::InDetTrackSelectionTool::m_maxChiSqperNdf
Gaudi::Property< Double_t > m_maxChiSqperNdf
Definition: InDetTrackSelectionTool.h:257
InDet::InDetTrackSelectionTool::m_maxTrtHighEFractionWithOutliers
Gaudi::Property< Double_t > m_maxTrtHighEFractionWithOutliers
Definition: InDetTrackSelectionTool.h:248
InDet::InDetTrackSelectionTool::maxDoubleIsSet
static bool maxDoubleIsSet(Double_t cutValue)
Definition: InDetTrackSelectionTool.h:136
InDet::InDetTrackSelectionTool::m_trkTrackCuts
std::map< std::string, std::vector< std::function< bool(InDetAccessor::TrkTrackHelper helper, const asg::AsgMessaging &msgHelper)> > > m_trkTrackCuts
First element is the name of the cut family, second element is the set of cuts.
Definition: InDetTrackSelectionTool.h:128
make_coralServer_rep.opt
opt
Definition: make_coralServer_rep.py:19
Trk::PerigeeSurface
Definition: PerigeeSurface.h:43
calibdata.modified
bool modified
Definition: calibdata.py:673
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
InDetDD::holes
@ holes
Definition: InDetDD_Defs.h:17
InDet::InDetTrackSelectionTool::m_minNSctHits
Gaudi::Property< Int_t > m_minNSctHits
Definition: InDetTrackSelectionTool.h:221
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
pool_uuid.regular
bool regular
Definition: pool_uuid.py:103
DMTest::P
P_v1 P
Definition: P.h:23
InDet::InDetTrackSelectionTool::m_maxTrtHighEFraction
Gaudi::Property< Double_t > m_maxTrtHighEFraction
Definition: InDetTrackSelectionTool.h:245
xAOD::numberOfTRTXenonHits
@ numberOfTRTXenonHits
number of TRT hits on track in straws with xenon [unit8_t].
Definition: TrackingPrimitives.h:284
InDet::InDetTrackSelectionTool::m_minNSiHitsMod
Gaudi::Property< Int_t > m_minNSiHitsMod
Definition: InDetTrackSelectionTool.h:284
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
InDet::InDetTrackSelectionTool::m_maxNPixelHoles
Gaudi::Property< Int_t > m_maxNPixelHoles
Definition: InDetTrackSelectionTool.h:197
InDet::InDetTrackSelectionTool::m_vecPtCutoffsForZ0SinThetaCut
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForZ0SinThetaCut
Definition: InDetTrackSelectionTool.h:317
python.SystemOfUnits.MeV
int MeV
Definition: SystemOfUnits.py:154
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
module_driven_slicing.layers
layers
Definition: module_driven_slicing.py:114
skel.it
it
Definition: skel.GENtoEVGEN.py:396
InDet::InDetTrackSelectionTool::m_maxAbsEta
Gaudi::Property< Double_t > m_maxAbsEta
Definition: InDetTrackSelectionTool.h:145
asg
Definition: DataHandleTestTool.h:28
test_pyathena.pt
pt
Definition: test_pyathena.py:11
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
Trk::one
@ one
Definition: TrkDetDescr/TrkSurfaces/TrkSurfaces/RealQuadraticEquation.h:22
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
InDetAccessor::TrackParticleHelper
Definition: InDetAccessor.h:50
InDetAccessor::getSiHitsTopBottom
std::tuple< uint8_t, uint8_t > getSiHitsTopBottom(const Trk::Track &track, const asg::AsgMessaging &msgHelper)
Definition: InDetAccessor.cxx:11
InDet::InDetTrackSelectionTool::m_useMinBiasInnermostLayersCut
Gaudi::Property< Int_t > m_useMinBiasInnermostLayersCut
Definition: InDetTrackSelectionTool.h:179
athena.value
value
Definition: athena.py:124
InDet::InDetTrackSelectionTool::m_vecMinNSctHitsAbovePt
Gaudi::Property< std::vector< Int_t > > m_vecMinNSctHitsAbovePt
Definition: InDetTrackSelectionTool.h:310
InDet::InDetTrackSelectionTool::m_minEProbabilityHT
Gaudi::Property< Double_t > m_minEProbabilityHT
Definition: InDetTrackSelectionTool.h:275
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
asg::AcceptInfo::getCutPosition
unsigned int getCutPosition(const std::string &cutName) const
Get the bit position of a cut.
Definition: AcceptInfo.h:73
xAOD::expectInnermostPixelLayerHit
@ expectInnermostPixelLayerHit
Do we expect a 0th-layer barrel hit for this track?
Definition: TrackingPrimitives.h:236
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
InDet::InDetTrackSelectionTool::m_maxD0overSigmaD0
Gaudi::Property< Double_t > m_maxD0overSigmaD0
Definition: InDetTrackSelectionTool.h:159
InDet::InDetTrackSelectionTool::m_initTrkTools
Gaudi::Property< Bool_t > m_initTrkTools
Definition: InDetTrackSelectionTool.h:362
InDet::InDetTrackSelectionTool::m_minNTrtHighThresholdHitsPlusOutliers
Gaudi::Property< Int_t > m_minNTrtHighThresholdHitsPlusOutliers
Definition: InDetTrackSelectionTool.h:242
InDet::InDetTrackSelectionTool::m_maxNSiSharedHits
Gaudi::Property< Int_t > m_maxNSiSharedHits
Definition: InDetTrackSelectionTool.h:184
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
InDet::InDetTrackSelectionTool::s_mapCutLevel
static const std::unordered_map< std::string, CutLevel > s_mapCutLevel
Definition: InDetTrackSelectionTool.h:359
InDet::InDetTrackSelectionTool::m_minNSiHits
Gaudi::Property< Int_t > m_minNSiHits
Definition: InDetTrackSelectionTool.h:182
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
Trk::Z0
@ Z0
Definition: ParameterType.h:18
InDet::InDetTrackSelectionTool::m_mutex
std::mutex m_mutex
Definition: InDetTrackSelectionTool.h:134
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
InDet::InDetTrackSelectionTool::m_minNInnermostLayerHits
Gaudi::Property< Int_t > m_minNInnermostLayerHits
Definition: InDetTrackSelectionTool.h:167
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
xAOD::numberOfTRTHighThresholdHits
@ numberOfTRTHighThresholdHits
number of TRT hits which pass the high threshold (only xenon counted) [unit8_t].
Definition: TrackingPrimitives.h:278
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
InDet::InDetTrackSelectionTool::m_vecMinPtAboveEta
Gaudi::Property< std::vector< Double_t > > m_vecMinPtAboveEta
Definition: InDetTrackSelectionTool.h:303
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
InDet::InDetTrackSelectionTool::m_maxSigmaZ0SinTheta
Gaudi::Property< Double_t > m_maxSigmaZ0SinTheta
Definition: InDetTrackSelectionTool.h:157
InDet::InDetTrackSelectionTool::m_minNUsedHitsdEdx
Gaudi::Property< Int_t > m_minNUsedHitsdEdx
Definition: InDetTrackSelectionTool.h:268
InDet::InDetTrackSelectionTool::maxIntIsSet
static bool maxIntIsSet(Int_t cutValue)
Definition: InDetTrackSelectionTool.h:137
InDetAccessor::d0
@ d0
Definition: InDetAccessor.h:31
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition: Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
InDet::InDetTrackSelectionTool::m_maxChiSq
Gaudi::Property< Double_t > m_maxChiSq
Definition: InDetTrackSelectionTool.h:255
InDet::InDetTrackSelectionTool::m_maxNSctHoles
Gaudi::Property< Int_t > m_maxNSctHoles
Definition: InDetTrackSelectionTool.h:226
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
python.PyAthena.module
module
Definition: PyAthena.py:131
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
InDet::InDetTrackSelectionTool::m_maxZ0SinTheta
Gaudi::Property< Double_t > m_maxZ0SinTheta
Definition: InDetTrackSelectionTool.h:147
xAOD::numberOfTRTHighThresholdOutliers
@ numberOfTRTHighThresholdOutliers
number of TRT high threshold outliers (only xenon counted) [unit8_t].
Definition: TrackingPrimitives.h:281
InDetAccessor::getEProbabilityHT
float getEProbabilityHT(const Trk_Helper &helper, const asg::AsgMessaging &msgHelper)
InDet::InDetTrackSelectionTool::setCutLevelPrivate
void setCutLevelPrivate(InDet::CutLevel level, Bool_t overwrite=true)
Definition: InDetTrackSelectionTool.cxx:1166
xAOD::numberOfPixelSharedHits
@ numberOfPixelSharedHits
number of Pixel all-layer hits shared by several tracks [unit8_t].
Definition: TrackingPrimitives.h:262
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
InDet::InDetTrackSelectionTool::m_vecPtCutoffsForSctHitsCut
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForSctHitsCut
Definition: InDetTrackSelectionTool.h:307
InDet::InDetTrackSelectionTool::m_maxNSiHoles
Gaudi::Property< Int_t > m_maxNSiHoles
Definition: InDetTrackSelectionTool.h:190
InDet::InDetTrackSelectionTool::m_maxNSctSharedHits
Gaudi::Property< Int_t > m_maxNSctSharedHits
Definition: InDetTrackSelectionTool.h:223
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::expectNextToInnermostPixelLayerHit
@ expectNextToInnermostPixelLayerHit
Do we expect a 1st-layer barrel hit for this track?
Definition: TrackingPrimitives.h:247
InDetAccessor::getFitChiSquare
double getFitChiSquare(const Trk_Helper &helper, const asg::AsgMessaging &msgHelper)
TRT
Definition: HitInfo.h:33
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
InDet::InDetTrackSelectionTool::m_minNTrtHits
Gaudi::Property< Int_t > m_minNTrtHits
Definition: InDetTrackSelectionTool.h:236
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
lumiFormat.i
int i
Definition: lumiFormat.py:85
sqr
#define sqr(t)
Definition: PolygonTriangulator.cxx:110
InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForZ0SinThetaCut
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForZ0SinThetaCut
Definition: InDetTrackSelectionTool.h:314
InDet::InDetTrackSelectionTool::m_vecPtCutoffsForD0Cut
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForD0Cut
Definition: InDetTrackSelectionTool.h:326
InDet::InDetTrackSelectionTool::m_minProbAbovePtCutoff
Gaudi::Property< Double_t > m_minProbAbovePtCutoff
Definition: InDetTrackSelectionTool.h:264
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForSctHolesCut
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForSctHolesCut
Definition: InDetTrackSelectionTool.h:332
sq
#define sq(x)
Definition: CurvedSegmentFinder.cxx:6
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
InDet::InDetTrackSelectionTool::m_vecvecMaxD0AboveEtaPt
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMaxD0AboveEtaPt
Definition: InDetTrackSelectionTool.h:328
InDet::InDetTrackSelectionTool::LOCAL_MAX_DOUBLE
constexpr static Double_t LOCAL_MAX_DOUBLE
Definition: InDetTrackSelectionTool.h:138
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
BindingsTest.cut
cut
This script demonstrates how to call a C++ class from Python Also how to use PyROOT is shown.
Definition: BindingsTest.py:13
plotBeamSpotVert.cuts
string cuts
Definition: plotBeamSpotVert.py:93
InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForSiHitsCut
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForSiHitsCut
Definition: InDetTrackSelectionTool.h:295
InDet::InDetTrackSelectionTool::m_vecMinNSiHitsAboveEta
Gaudi::Property< std::vector< Int_t > > m_vecMinNSiHitsAboveEta
Definition: InDetTrackSelectionTool.h:298
python.Utils.unixtools.where
def where(filename, prepath=[])
"which" for python files -------------------------------------------------—
Definition: unixtools.py:53
InDet::InDetTrackSelectionTool::m_cutLevel
Gaudi::Property< std::string > m_cutLevel
The string version of the cut level so that it can be set via jobOptions.
Definition: InDetTrackSelectionTool.h:356
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
InDet::InDetTrackSelectionTool::m_numTracksProcessed
std::atomic< ULong64_t > m_numTracksProcessed
a counter of the number of tracks proccessed
Definition: InDetTrackSelectionTool.h:131
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
Region::IBL
@ IBL
InDet::InDetTrackSelectionTool::m_maxTrtOutlierFraction
Gaudi::Property< Double_t > m_maxTrtOutlierFraction
Definition: InDetTrackSelectionTool.h:251
InDet::InDetTrackSelectionTool::m_minEtaForStrictNSiHitsCut
Gaudi::Property< Double_t > m_minEtaForStrictNSiHitsCut
Definition: InDetTrackSelectionTool.h:201
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
InDet::InDetTrackSelectionTool::m_extrapolator
ToolHandle< Trk::IExtrapolator > m_extrapolator
Definition: InDetTrackSelectionTool.h:367
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
InDet::InDetTrackSelectionTool::m_minNOverflowHitsdEdx
Gaudi::Property< Int_t > m_minNOverflowHitsdEdx
Definition: InDetTrackSelectionTool.h:270
InDet::InDetTrackSelectionTool::m_numTracksPassed
std::atomic< ULong64_t > m_numTracksPassed
a counter of the number of tracks that passed all cuts
Definition: InDetTrackSelectionTool.h:132
InDet::InDetTrackSelectionTool::m_useExperimentalInnermostLayersCut
Gaudi::Property< Bool_t > m_useExperimentalInnermostLayersCut
Definition: InDetTrackSelectionTool.h:279
python.Include.include
include
Definition: Include.py:318
InDet::InDetTrackSelectionTool::m_maxZ0overSigmaZ0
Gaudi::Property< Double_t > m_maxZ0overSigmaZ0
Definition: InDetTrackSelectionTool.h:161
perfmonmt-printer.required
required
Definition: perfmonmt-printer.py:184
SCT
Definition: SCT_ChipUtils.h:14
InDet::InDetTrackSelectionTool::m_minNSctHitsPhysical
Gaudi::Property< Int_t > m_minNSctHitsPhysical
Definition: InDetTrackSelectionTool.h:219
InDetAccessor::getNumberOfUsedHitsdEdx
Int_t getNumberOfUsedHitsdEdx(Trk_Helper &helper, const asg::AsgMessaging &msgHelper)
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
InDet::InDetTrackSelectionTool::m_isInitialized
bool m_isInitialized
Definition: InDetTrackSelectionTool.h:108
python.CaloBCIDAvgAlgConfig.only
list only
Definition: CaloBCIDAvgAlgConfig.py:32
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
InDet::InDetTrackSelectionTool::m_vecPtCutoffsForSctHitsPlusDeadCut
Gaudi::Property< std::vector< Double_t > > m_vecPtCutoffsForSctHitsPlusDeadCut
Definition: InDetTrackSelectionTool.h:345
InDet::InDetTrackSelectionTool::m_minP
Gaudi::Property< Double_t > m_minP
Definition: InDetTrackSelectionTool.h:142
InDet::InDetTrackSelectionTool::m_minNSiHitsModBottom
Gaudi::Property< Int_t > m_minNSiHitsModBottom
Definition: InDetTrackSelectionTool.h:290
InDet::InDetTrackSelectionTool::m_minNPixelHitsPhysical
Gaudi::Property< Int_t > m_minNPixelHitsPhysical
Definition: InDetTrackSelectionTool.h:217
InDet::InDetTrackSelectionTool::m_minPtForProbCut
Gaudi::Property< Double_t > m_minPtForProbCut
Definition: InDetTrackSelectionTool.h:261
InDet::InDetTrackSelectionTool::m_useEtaDependentMaxChiSq
Gaudi::Property< Bool_t > m_useEtaDependentMaxChiSq
Definition: InDetTrackSelectionTool.h:210
xAOD::numberOfNextToInnermostPixelLayerHits
@ numberOfNextToInnermostPixelLayerHits
these are the hits in the 1st pixel barrel layer
Definition: TrackingPrimitives.h:248
InDetAccessor::getFitNDoF
double getFitNDoF(const TrkHelper &helper, const asg::AsgMessaging &msgHelper)
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
InDet::InDetTrackSelectionTool::m_vecvecMaxSctHolesAboveEtaPt
Gaudi::Property< std::vector< std::vector< Double_t > > > m_vecvecMaxSctHolesAboveEtaPt
Definition: InDetTrackSelectionTool.h:338
python.selection.number
number
Definition: selection.py:20
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
InDet::InDetTrackSelectionTool::LOCAL_MAX_INT
constexpr static Int_t LOCAL_MAX_INT
Definition: InDetTrackSelectionTool.h:139
InDetAccessor::getNumberOfIBLOverflowsdEdx
Int_t getNumberOfIBLOverflowsdEdx(Trk_Helper &helper, const asg::AsgMessaging &msgHelper)
asg::AsgMessaging
Class mimicking the AthMessaging class from the offline software.
Definition: AsgMessaging.h:40
Ringer::NoCut
@ NoCut
Definition: RingerSelectorToolsEnums.h:121
threshold
Definition: chainparser.cxx:74
InDet::InDetTrackSelectionTool::m_minNPixelHits
Gaudi::Property< Int_t > m_minNPixelHits
Definition: InDetTrackSelectionTool.h:192
InDetAccessor::getDefiningParametersCov
double getDefiningParametersCov(Trk_Helper &helper, [[maybe_unused]] const asg::AsgMessaging &msgHelper, unsigned int index_i, unsigned int index_j)
InDet::InDetTrackSelectionTool::m_minNSiHitsIfSiSharedHits
Gaudi::Property< Int_t > m_minNSiHitsIfSiSharedHits
Definition: InDetTrackSelectionTool.h:187
InDet::InDetTrackSelectionTool::m_maxZ0
Gaudi::Property< Double_t > m_maxZ0
Definition: InDetTrackSelectionTool.h:149
InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForD0Cut
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForD0Cut
Definition: InDetTrackSelectionTool.h:324
Cut::all
@ all
Definition: SUSYToolsAlg.cxx:67
CxxUtils::to
CONT to(RANGE &&r)
Definition: ranges.h:39
InDet::InDetTrackSelectionTool::m_minNTrtHighThresholdHits
Gaudi::Property< Int_t > m_minNTrtHighThresholdHits
Definition: InDetTrackSelectionTool.h:240
InDetAccessor::theta
@ theta
Definition: InDetAccessor.h:34
xAOD::numberOfTRTOutliers
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
Definition: TrackingPrimitives.h:276
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
InDet::InDetTrackSelectionTool::m_maxNPixelSharedHits
Gaudi::Property< Int_t > m_maxNPixelSharedHits
Definition: InDetTrackSelectionTool.h:194
InDet::InDetTrackSelectionTool::m_minNTrtHitsPlusOutliers
Gaudi::Property< Int_t > m_minNTrtHitsPlusOutliers
Definition: InDetTrackSelectionTool.h:238
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
InDet::InDetTrackSelectionTool::m_minNSiHitsModTop
Gaudi::Property< Int_t > m_minNSiHitsModTop
Definition: InDetTrackSelectionTool.h:287
Prompt::Def::Pt
@ Pt
Definition: VarHolder.h:76
a
TList * a
Definition: liststreamerinfos.cxx:10
h
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
InDet::InDetTrackSelectionTool::m_msgHelper
std::unique_ptr< asg::AsgMessaging > m_msgHelper
Definition: InDetTrackSelectionTool.h:123
InDetAccessor::TrkTrackHelper
Definition: InDetAccessor.h:71
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
InDet::InDetTrackSelectionTool::m_maxD0
Gaudi::Property< Double_t > m_maxD0
Definition: InDetTrackSelectionTool.h:151
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:273
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
InDet::InDetTrackSelectionTool::m_acceptInfo
asg::AcceptInfo m_acceptInfo
Object used to store the last decision.
Definition: InDetTrackSelectionTool.h:352
InDet::InDetTrackSelectionTool::m_eProbHTonlyForXe
Gaudi::Property< Bool_t > m_eProbHTonlyForXe
Definition: InDetTrackSelectionTool.h:272
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
TauGNNUtils::Variables::absEta
bool absEta(const xAOD::TauJet &tau, double &out)
Definition: TauGNNUtils.cxx:234
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
xAOD::numberOfInnermostPixelLayerSharedHits
@ numberOfInnermostPixelLayerSharedHits
number of Pixel 0th layer barrel hits shared by several tracks.
Definition: TrackingPrimitives.h:239
L1CaloPhase1Monitoring.applied
applied
Definition: L1CaloPhase1Monitoring.py:452
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
Trk::hole
@ hole
Definition: MeasurementType.h:36
Trk::outside
@ outside
Definition: PropDirection.h:29
Track
Definition: TriggerChamberClusterOnTrackCreator.h:21
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:266
top
@ top
Definition: TruthClasses.h:64
InDet::InDetTrackSelectionTool::m_maxZ0SinThetaoverSigmaZ0SinTheta
Gaudi::Property< Double_t > m_maxZ0SinThetaoverSigmaZ0SinTheta
Definition: InDetTrackSelectionTool.h:163
InDet::InDetTrackSelectionTool::m_maxTrtEtaAcceptance
Gaudi::Property< Double_t > m_maxTrtEtaAcceptance
Definition: InDetTrackSelectionTool.h:231
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
calibdata.copy
bool copy
Definition: calibdata.py:27
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
xAOD::numberOfSCTDoubleHoles
@ numberOfSCTDoubleHoles
number of Holes in both sides of a SCT module [unit8_t].
Definition: TrackingPrimitives.h:271
pix
Definition: PixelMapping.cxx:16
InDet::InDetTrackSelectionTool::m_minProb
Gaudi::Property< Double_t > m_minProb
Definition: InDetTrackSelectionTool.h:259
asg::AcceptData
Definition: AcceptData.h:30
SG::DataProxy
Definition: DataProxy.h:45
InDet::InDetTrackSelectionTool::m_minNSiHitsPhysical
Gaudi::Property< Int_t > m_minNSiHitsPhysical
Definition: InDetTrackSelectionTool.h:214
InDet::InDetTrackSelectionTool::m_maxSigmaD0
Gaudi::Property< Double_t > m_maxSigmaD0
Definition: InDetTrackSelectionTool.h:153
PlotCalibFromCool.be
be
Definition: PlotCalibFromCool.py:398
asg::AsgTool::initialize
virtual StatusCode initialize()
Dummy implementation of the initialisation function.
Definition: AsgTool.h:133
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::InDetTrackSelectionTool::m_maxNSctDoubleHoles
Gaudi::Property< Int_t > m_maxNSctDoubleHoles
Definition: InDetTrackSelectionTool.h:228
InDet::InDetTrackSelectionTool::m_trackParticleCuts
std::map< std::string, std::vector< std::function< bool(InDetAccessor::TrackParticleHelper helper, const asg::AsgMessaging &msgHelper)> > > m_trackParticleCuts
First element is the name of the cut family, second element is the set of cuts.
Definition: InDetTrackSelectionTool.h:125
python.SystemOfUnits.degree
tuple degree
Definition: SystemOfUnits.py:106
InDet::InDetTrackSelectionTool::m_maxSigmaZ0
Gaudi::Property< Double_t > m_maxSigmaZ0
Definition: InDetTrackSelectionTool.h:155
InDet::InDetTrackSelectionTool::m_vecEtaCutoffsForPtCut
Gaudi::Property< std::vector< Double_t > > m_vecEtaCutoffsForPtCut
Definition: InDetTrackSelectionTool.h:301
Eta
@ Eta
Definition: RPCdef.h:8
SiliconTech::pixel
@ pixel
python.Dumpers.FitQuality
FitQuality
Definition: Dumpers.py:63
ReadFromCoolCompare.no
no
Definition: ReadFromCoolCompare.py:232
fitman.k
k
Definition: fitman.py:528
xAOD::numberOfInnermostPixelLayerHits
@ numberOfInnermostPixelLayerHits
these are the hits in the 0th pixel barrel layer
Definition: TrackingPrimitives.h:237
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
asg::AcceptInfo::addCut
int addCut(const std::string &cutName, const std::string &cutDescription)
Add a cut; returning the cut position.
Definition: AcceptInfo.h:53
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65