InDetTrackSelectionTool.h

Go to the documentation of this file.

// -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETTRACKSELECTIONTOOL_INDETTRACKSELECTIONTOOL_H
#define INDETTRACKSELECTIONTOOL_INDETTRACKSELECTIONTOOL_H
 
// Local include(s):
#include "InDetTrackSelectionTool/IInDetTrackSelectionTool.h"
// Framework include(s):
#include "AsgTools/AsgTool.h"
#include "AsgMessaging/AsgMessaging.h"
#ifndef XAOD_ANALYSIS
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ServiceHandle.h"
#include "TrkToolInterfaces/ITrackSummaryTool.h"
#include "TrkExInterfaces/IExtrapolator.h"
#endif
 
#include <atomic>
#include <limits>
#include <map>
#include <mutex>
#include <unordered_map>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>
 
namespace InDetAccessor {
 
   class TrackParticleHelper;
 
#ifndef XAOD_ANALYSIS
   class TrkTrackHelper;
#endif
}
 
namespace InDet {
 
  // forward declaration of helper classes
  class TrackAccessor;
  class TrackCut;
 
  class InDetTrackSelectionTool :
    public virtual IInDetTrackSelectionTool,
    public asg::AsgTool {
    
    friend class TrackCut;
 
    ASG_TOOL_CLASS2( InDetTrackSelectionTool,
             IAsgSelectionTool,
             InDet::IInDetTrackSelectionTool )
    
  public:
    InDetTrackSelectionTool( const std::string& name, const std::string& cutLevel = "" );
 
    // The default destructor is OK but it must be defined in the
    // implementation file in order to forward declare with unique_ptr
    ~InDetTrackSelectionTool();
 
    
    virtual StatusCode initialize() override;
    virtual StatusCode finalize() override;
    
    
    
    virtual const asg::AcceptInfo& getAcceptInfo() const override;
    
    virtual  asg::AcceptData accept( const xAOD::IParticle* ) const override;
    
    
    
    virtual  asg::AcceptData accept( const xAOD::TrackParticle& track,
                     const xAOD::Vertex* vertex = nullptr ) const override;
 
#ifndef XAOD_ANALYSIS
    virtual  asg::AcceptData accept( const Trk::Track& track,
                     const Trk::Vertex* vertex = nullptr ) const override;
#endif
    
 
    virtual void setCutLevel( InDet::CutLevel level, Bool_t overwrite = true ) override
      __attribute__ ((deprecated("For consistency with the athena interface, the cut level is best set through the \"CutLevel\" property.")));
 
  private:
    bool m_isInitialized = false; // flag whether or not the tool has been initialized, to check erroneous use cases.
    mutable std::atomic_bool m_warnInit = false; // flag to keep track of whether we have warned about a lack of initialization
 
    // this is the setCutLevel function that actually does the work, so that it doesn't warn if called in athena.
    void setCutLevelPrivate( InDet::CutLevel level, Bool_t overwrite = true );
 
    // helper method to setup the cut functions for TrackParticles and Trk::Tracks
    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;
 
    std::unordered_map< std::string, std::shared_ptr<TrackAccessor> > m_trackAccessors; 
 
    std::unique_ptr<asg::AsgMessaging> m_msgHelper;
    std::map< std::string, std::vector< std::function<bool(InDetAccessor::TrackParticleHelper helper, const asg::AsgMessaging &msgHelper)> > >
           m_trackParticleCuts; 
#ifndef XAOD_ANALYSIS
    std::map< std::string, std::vector< std::function<bool(InDetAccessor::TrkTrackHelper helper, const asg::AsgMessaging &msgHelper)> > >
           m_trkTrackCuts; 
#endif
 
    mutable std::atomic<ULong64_t> m_numTracksProcessed = 0; 
    mutable std::atomic<ULong64_t> m_numTracksPassed = 0; 
    mutable std::vector<ULong64_t> m_numTracksPassedCuts ATLAS_THREAD_SAFE; 
    mutable std::mutex m_mutex;
 
    static inline bool maxDoubleIsSet(Double_t cutValue) {return cutValue < InDet::InDetTrackSelectionTool::LOCAL_MAX_DOUBLE && cutValue >= 0.;}
    static inline bool maxIntIsSet(Int_t cutValue){return cutValue < InDet::InDetTrackSelectionTool::LOCAL_MAX_INT && cutValue >= 0;}
    constexpr static Double_t LOCAL_MAX_DOUBLE = 1.0e16;
    constexpr static Int_t LOCAL_MAX_INT = std::numeric_limits<Int_t>::max();
 
    Double_t m_minPt = -1.; 
    Double_t m_maxAbsEta = LOCAL_MAX_DOUBLE; 
    Double_t m_maxZ0SinTheta = LOCAL_MAX_DOUBLE; 
    Double_t m_maxZ0 = LOCAL_MAX_DOUBLE; 
    Double_t m_maxD0 = LOCAL_MAX_DOUBLE; 
    Double_t m_maxSigmaD0 = LOCAL_MAX_DOUBLE; 
    Double_t m_maxSigmaZ0 = LOCAL_MAX_DOUBLE; 
    Double_t m_maxSigmaZ0SinTheta = LOCAL_MAX_DOUBLE; 
    Double_t m_maxD0overSigmaD0 = LOCAL_MAX_DOUBLE; 
    Double_t m_maxZ0overSigmaZ0 = LOCAL_MAX_DOUBLE; 
    Double_t m_maxZ0SinThetaoverSigmaZ0SinTheta = LOCAL_MAX_DOUBLE; 
    Int_t m_minNInnermostLayerHits = -1; 
    Int_t m_minNNextToInnermostLayerHits = -1; 
    Int_t m_minNBothInnermostLayersHits = -1; 
    Int_t m_maxNInnermostLayerSharedHits = LOCAL_MAX_INT; 
    Int_t m_useMinBiasInnermostLayersCut = 0; 
    Int_t m_minNSiHits = -1; 
    Int_t m_maxNSiSharedHits = LOCAL_MAX_INT; 
    Int_t m_minNSiHitsIfSiSharedHits = -1; 
    Int_t m_maxNSiHoles = LOCAL_MAX_INT; 
    Int_t m_minNPixelHits = -1; 
    Int_t m_maxNPixelSharedHits = LOCAL_MAX_INT; 
    Int_t m_maxNPixelHoles = LOCAL_MAX_INT; 
    Double_t m_minEtaForStrictNSiHitsCut = LOCAL_MAX_DOUBLE; 
    Int_t m_minNSiHitsAboveEtaCutoff = -1; 
    Bool_t m_maxOneSharedModule = false; 
    Bool_t m_useEtaDependentMaxChiSq = false; 
    Double_t m_minP = -1.; 
    Int_t m_minNSiHitsPhysical = -1; 
    Int_t m_minNPixelHitsPhysical = -1; 
    Int_t m_minNSctHitsPhysical = -1; 
    Int_t m_minNSctHits = -1; 
    Int_t m_maxNSctSharedHits = LOCAL_MAX_INT; 
    Int_t m_maxNSctHoles = LOCAL_MAX_INT; 
    Int_t m_maxNSctDoubleHoles = LOCAL_MAX_INT; 
    Double_t m_maxTrtEtaAcceptance = LOCAL_MAX_DOUBLE; 
    Double_t m_maxEtaForTrtHitCuts = -1.; 
    Int_t m_minNTrtHits = -1; 
    Int_t m_minNTrtHitsPlusOutliers = -1; 
    Int_t m_minNTrtHighThresholdHits = -1; 
    Int_t m_minNTrtHighThresholdHitsPlusOutliers = -1; 
    Double_t m_maxTrtHighEFraction = LOCAL_MAX_DOUBLE; 
    Double_t m_maxTrtHighEFractionWithOutliers = LOCAL_MAX_DOUBLE; 
    Double_t m_maxTrtOutlierFraction = LOCAL_MAX_DOUBLE; 
    Double_t m_maxChiSq = LOCAL_MAX_DOUBLE; 
    Double_t m_maxChiSqperNdf = LOCAL_MAX_DOUBLE; 
    Double_t m_minProb = -1.; 
    Double_t m_minPtForProbCut = LOCAL_MAX_DOUBLE; 
    Double_t m_minProbAbovePtCutoff = -1.; 
    Int_t m_minNUsedHitsdEdx = -1; 
    Int_t m_minNOverflowHitsdEdx = -1; 
    Bool_t m_eProbHTonlyForXe = false; 
    Double_t m_minEProbabilityHT = -1.; 
    Int_t m_useExperimentalInnermostLayersCut = false; 
#ifndef XAOD_ANALYSIS
    Int_t m_minNSiHitsMod = -1; 
    Int_t m_minNSiHitsModTop = -1; 
    Int_t m_minNSiHitsModBottom = -1; 
#endif
    std::vector< Double_t > m_vecEtaCutoffsForSiHitsCut; 
    std::vector< Int_t > m_vecMinNSiHitsAboveEta; 
    std::vector< Double_t > m_vecEtaCutoffsForPtCut; 
    std::vector< Double_t > m_vecMinPtAboveEta; 
 
    std::vector< Double_t > m_vecPtCutoffsForSctHitsCut; 
    std::vector< Int_t > m_vecMinNSctHitsAbovePt; 
 
    std::vector< Double_t > m_vecEtaCutoffsForZ0SinThetaCut; 
    std::vector< Double_t > m_vecPtCutoffsForZ0SinThetaCut; 
    std::vector< std::vector< Double_t >> m_vecvecMaxZ0SinThetaAboveEtaPt; 
 
    std::vector< Double_t > m_vecEtaCutoffsForD0Cut;
    std::vector< Double_t > m_vecPtCutoffsForD0Cut; 
    std::vector< std::vector< Double_t >> m_vecvecMaxD0AboveEtaPt; 
 
    std::vector< Double_t > m_vecEtaCutoffsForSctHolesCut;
    std::vector< Double_t > m_vecPtCutoffsForSctHolesCut; 
    std::vector< std::vector< Double_t >> m_vecvecMaxSctHolesAboveEtaPt; 
 
    std::vector< Double_t > m_vecEtaCutoffsForSctHitsPlusDeadCut;
    std::vector< Double_t > m_vecPtCutoffsForSctHitsPlusDeadCut; 
    std::vector< std::vector< Double_t >> m_vecvecMinSctHitsPlusDeadAboveEtaPt; 
    
    asg::AcceptInfo m_acceptInfo; 
 
    // to set to a pre-defined cut level in Athena, we need to save the cut level
    // as a string so we can do a soft set in initialize()
    std::string m_cutLevel; 
 
    // we need a map from strings (for use in Athena) to the CutLevel enum
    static const std::unordered_map<std::string, CutLevel> s_mapCutLevel;
 
#ifndef XAOD_ANALYSIS
    Bool_t m_initTrkTools = false; 
    Bool_t m_trackSumToolAvailable = false; 
    ToolHandle<Trk::ITrackSummaryTool> m_trackSumTool; 
    ToolHandle<Trk::IExtrapolator> m_extrapolator; 
 
#endif // XAOD_ANALYSIS
 
  }; // class InDetTrackSelectionTool
 
} // namespace InDet
 
#endif // INDETTRACKSELECTIONTOOL_INDETTRACKSELECTIONTOOL_H