CP::MuonSelectionTool Class Reference

Implementation of the muon selector tool. More...

#include <MuonSelectionTool.h>

Inheritance diagram for CP::MuonSelectionTool:

Classes
struct	hitSummary
	struct to handle easily number of hits in different parts of the MS More...

Public Types
enum	ResolutionCategory {   unclassified = -1 , missingInner = 1 , missingMiddle = 1 << 1 , missingOuter = 1 << 2 ,   highPt2station = 1 << 3 , highPt = 1 << 4 , spoiledCSC = 1 << 5 , BEoverlap = 1 << 6 ,   BIS78 = 1 << 7 , missingBEE = 1 << 8 , oneStation = 1 << 9 , CategoryZero = missingInner | spoiledCSC | BEoverlap | BIS78 | missingBEE ,   CategoryOne = missingMiddle | oneStation , CategoryTwo = missingOuter , CategoryThree = highPt2station , CategoryFour = highPt }
	Declare the interface that the class provides. More...

Public Member Functions
	MuonSelectionTool (const std::string &name="MuonSelection")
	Create a proper constructor for Athena.
virtual	~MuonSelectionTool ()
std::vector< const xAOD::MuonSegment * >	getSegmentsSorted (const xAOD::Muon &mu) const
	Returns a vector of the muon's segments, sorted according to chamber index.
bool	isBIS78 (const float eta, const float phi) const
	Check if muon eta/phi falls in BIS7/8 chambers.
bool	isBEE (const float eta, const float phi) const
	Check if muon eta/phi falls in BEE chambers.
bool	isBMG (const float eta, const float phi) const
	Check if muon eta/phi falls in BMG chambers.
float	qOverPsignificance (const xAOD::Muon &muon) const
	Returns q/p significance of the muon (see definition in https://cds.cern.ch/record/2665711 )
float	rhoPrime (const xAOD::Muon &muon) const
	Returns rhoPrime of the muon (see definition in https://cds.cern.ch/record/2665711 )
template<class P, class T, class S>
void	retrieveSummaryValue (const P &muon, T &value, const S type, bool ignoreMissing=false) const
	helper function to retrieve a hitSummary value
void	fillSummary (const xAOD::Muon &muon, hitSummary &summary) const
	functions that fills a hitSummary for a muon
virtual float	getTightNNScore (const xAOD::Muon &muon) const override
	Returns the TightNNscore of the muon, an experimental ML-based score for the identification of muons from HF hadron decays.
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Function(s) implementing the asg::IAsgTool interface
virtual StatusCode	initialize () override
	Function initialising the tool.
Function(s) implementing the IAsgSelectionTool interface
virtual const asg::AcceptInfo &	getAcceptInfo () const override
	Get an object describing the "selection steps" of the tool.
virtual asg::AcceptData	accept (const xAOD::IParticle *p) const override
	Get the decision using a generic IParticle pointer.
Function(s) implementing the IMuonSelectorTool interface
virtual asg::AcceptData	accept (const xAOD::Muon &mu) const override
	Get the decision for a specific Muon object.
virtual void	setPassesIDCuts (xAOD::Muon &) const override
	set the passes ID cuts variable of the muon
virtual void	setQuality (xAOD::Muon &mu) const override
	set the passes low pT cuts variable of the muon
virtual bool	passedIDCuts (const xAOD::Muon &) const override
	Returns true if the muon passes the standard MCP ID cuts.
virtual bool	passedMuonCuts (const xAOD::Muon &) const override
	Returns true if the muon passes a standardized loose preselection.
virtual bool	passedIDCuts (const xAOD::TrackParticle &) const override
	Returns true if the track particle passes the standard MCP ID cuts.
virtual bool	passedHighPtCuts (const xAOD::Muon &) const override
	Returns true if the muon passes the standard MCP High Pt cuts.
virtual bool	passedLowPtEfficiencyCuts (const xAOD::Muon &) const override
	Returns true if the muon passes the standard MCP low pt cuts.
virtual bool	passedLowPtEfficiencyCuts (const xAOD::Muon &, xAOD::Muon::Quality thisMu_quality) const override
virtual bool	passedErrorCutCB (const xAOD::Muon &) const override
	Returns true if a CB muon passes a pt- and eta-dependent cut on the relative CB q/p error.
virtual bool	isBadMuon (const xAOD::Muon &) const override
	Returns true if a CB muon fails some loose quaility requirements designed to remove pathological tracks.
virtual xAOD::Muon::Quality	getQuality (const xAOD::Muon &mu) const override
	Returns the quality of the muon. To set the value on the muon, instead call setQuality(xAOD::Muon&) const.
virtual bool	passedCaloTagQuality (const xAOD::Muon &mu) const override
	Returns true if the muon passed additional calo-tag quality cuts.
virtual bool	passedCaloScore (const xAOD::Muon &mu) const override
	Returns true if the muon passed the CaloScore calo-tag working point.
virtual int	getResolutionCategory (const xAOD::Muon &) const override
	Returns an integer corresponding to categorization of muons with different resolutions.
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	passedLowPtEfficiencyMVACut (const xAOD::Muon &) const
bool	passedLowPtEfficiencyMVACutRun3 (const xAOD::Muon &) const
bool	passTight (const xAOD::Muon &mu, float rho, float oneOverPSig) const
	Returns true if the muon passed the tight working point cuts.
bool	passedBMVmimicCut (const xAOD::Muon &) const
	Returns true if the muon passes a cut which mimics the effect of the combined error cut This is necessary only when the resolution is very optimistic in the MC such that a large smearing is applied.
StatusCode	getHist (TFile *file, const std::string &histName, std::unique_ptr< TH1 > &hist) const
	Checks for each histogram.
unsigned int	getRunNumber (bool needOnlyCorrectYear=false) const
void	IdMsPt (const xAOD::Muon &muon, float &idPt, float &msPt) const
void	checkSanity () const
bool	isRun3 (bool forceOnTheFly=false) const
void	retrieveParam (const xAOD::Muon &muon, float &value, const xAOD::Muon::ParamDef param) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
asg::AcceptInfo	m_acceptInfo
	Store selection information.
Gaudi::Property< double >	m_maxEta {this, "MaxEta", 2.7, "Maximum eta range to select the muons"}
Gaudi::Property< int >	m_quality {this, "MuQuality", 1,"Quality to select. Values correspond to 0=Tight, 1=Medium, 2=Loose, 3=VeryLoose (only for debug, not supported), 4=HighPt, 5=LowPtEfficiency"}
Gaudi::Property< bool >	m_toroidOff {this, "ToroidOff", false, "Run the tool in Toroid off setup"}
Gaudi::Property< bool >	m_isRun3 {this, "IsRun3Geo", false, "Switch to toggle the run 2 & run 3 geometry cuts. The tool will throw an exception if the run number does not match the expectations later"}
Gaudi::Property< bool >	m_excludeNSWFromPrecisionLayers {this, "ExcludeNSWFromPrecisionLayers", false, "Cut on the nprecisionlayers ignoring the NSW"}
Gaudi::Property< bool >	m_recalcPrecisionLayerswNSW {this, "RecalcPrecisionLayerswNSW", true, "Recalculate nprecisionlayers with internal criteria for NSW"}
Gaudi::Property< bool >	m_useCaloScore {this, "UseCaloScore", true, "Use CaloScore for calo-tags in the Loose working point. False will revert back to CaloMuonIDTag (not recommended in Rel.22)"}
Gaudi::Property< int >	m_caloScoreWP {this, "CaloScoreWP", 4,"Currently there are 4 CaloScore WPs for testing; WP4 is the recommended one"}
Gaudi::Property< bool >	m_useLRT {this, "UseLRT", false, "Enable support for LRT muons"}
Gaudi::Property< bool >	m_turnOffMomCorr {this, "TurnOffMomCorr", false}
Gaudi::Property< bool >	m_disablePtCuts {this, "DisablePtCuts", false}
Gaudi::Property< bool >	m_developMode {this, "ExpertDevelopMode", false}
Gaudi::Property< bool >	m_TrtCutOff {this, "TrtCutOff", true}
Gaudi::Property< bool >	m_SctCutOff {this, "SctCutOff", false}
Gaudi::Property< bool >	m_PixCutOff {this, "PixCutOff", false}
Gaudi::Property< bool >	m_SiHolesCutOff {this, "SiHolesCutOff", false}
Gaudi::Property< bool >	m_useAllAuthors {this, "UseAllAuthors", true}
Gaudi::Property< bool >	m_use2stationMuonsHighPt {this, "Use2stationMuonsHighPt", true, "for users of high-pT working point to choose whether to include 'safe' 2-station muons"}
Gaudi::Property< bool >	m_useMVALowPt {this, "UseMVALowPt", false, "for users of low-pT working point to choose whether to use MVA and whether to include MuTagIMO muons. Not yet supported in release 22, crrently only for development studies."}
Gaudi::Property< bool >	m_useSegmentTaggedLowPt {this, "UseSegmentTaggedLowPt", false, "Use MVA low-pt WP. In development phase"}
Gaudi::Property< bool >	m_geoOnTheFly {this, "AllowSettingGeometryOnTheFly", false,"avoids crash if run2/run3 geo is wrongly set"}
Gaudi::Property< bool >	m_doBadMuonVetoMimic {this, "DoBadMuonVetoMimic", false}
Gaudi::Property< bool >	m_allowComm {this, "AcceptCommChain", true, "Accepts muons from the EMEO chain if set to true"}
Gaudi::Property< bool >	m_useBEEBISInHighPtRun3 {this, "UseBEEBISInHighPtRun3", true, "Include BEE and BIS7/8 in high-pT WP in Run3"}
Gaudi::Property< int >	m_expertMode_RunNumber {this, "expertMode_RunNumber", 0, "Expert only option. Overwrites RunNumber"}
Gaudi::Property< unsigned long long >	m_expertMode_EvtNumber {this, "expertMode_EvtNumber", 0, "Expert only option. Overwrites EventNumber"}
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfo {this, "EventInfoContName", "EventInfo", "event info key"}
Gaudi::Property< std::string >	m_MVAreaderFile_EVEN_MuidCB
Gaudi::Property< std::string >	m_MVAreaderFile_ODD_MuidCB
Gaudi::Property< std::string >	m_MVAreaderFile_EVEN_MuGirl
Gaudi::Property< std::string >	m_MVAreaderFile_ODD_MuGirl
Gaudi::Property< std::string >	m_MVAreaderFile_MuTagIMO_etaBin1
Gaudi::Property< std::string >	m_MVAreaderFile_MuTagIMO_etaBin2
Gaudi::Property< std::string >	m_MVAreaderFile_MuTagIMO_etaBin3
Gaudi::Property< std::string >	m_calibration_version {this, "CalibrationRelease", "PreRec2016_2016-04-13"}
Gaudi::Property< std::string >	m_custom_dir {this, "CustomInputFolder", ""}
Gaudi::Property< std::string >	m_BMVcutFile
	file for bad muon veto mimic cut functions
std::unique_ptr< TH1 >	m_tightWP_lowPt_rhoCuts
std::unique_ptr< TH1 >	m_tightWP_lowPt_qOverPCuts
std::unique_ptr< TH1 >	m_tightWP_mediumPt_rhoCuts
std::unique_ptr< TH1 >	m_tightWP_highPt_rhoCuts
std::unique_ptr< TF1 >	m_BMVcutFunction_barrel
std::unique_ptr< TF1 >	m_BMVcutFunction_endcap
std::unique_ptr< TMVA::Reader >	m_readerE_MUID {nullptr}
std::unique_ptr< TMVA::Reader >	m_readerO_MUID {nullptr}
std::unique_ptr< TMVA::Reader >	m_readerE_MUGIRL {nullptr}
std::unique_ptr< TMVA::Reader >	m_readerO_MUGIRL {nullptr}
std::unique_ptr< TMVA::Reader >	m_reader_MUTAGIMO_etaBin1 {nullptr}
std::unique_ptr< TMVA::Reader >	m_reader_MUTAGIMO_etaBin2 {nullptr}
std::unique_ptr< TMVA::Reader >	m_reader_MUTAGIMO_etaBin3 {nullptr}
std::unique_ptr< MVAUtils::BDT >	m_MuidCO {nullptr}
std::vector< double >	m_lowPtMuidCO_means
std::vector< double >	m_lowPtMuidCO_scaler
std::unique_ptr< MVAUtils::BDT >	m_MuGirl {nullptr}
std::vector< double >	m_lowPtMuGirl_means
std::vector< double >	m_lowPtMuGirl_scaler
std::mutex	m_low_pt_mva_mutex
Gaudi::Property< bool >	m_calculateTightNNScore {this, "CalculateTightNNScore", false}
ToolHandle< AthInfer::IAthInferenceTool >	m_onnxTool {this, "ORTInferenceTool", "AthOnnx::OnnxRuntimeInferenceTool"}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Implementation of the muon selector tool.

Example implementation of how an object selector tool should look according to the TF3 recommendations.

Author

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Revision

299883

Date

2014-03-28 18:34:16 +0100 (Fri, 28 Mar 2014)

Definition at line 41 of file MuonSelectionTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

ResolutionCategory

enum CP::IMuonSelectionTool::ResolutionCategory

inherited

Declare the interface that the class provides.

Enum for resolution categories, the "merged" categories Zero to Four group together categories with similar resolution

Enumerator
unclassified
missingInner
missingMiddle
missingOuter
highPt2station
highPt
spoiledCSC
BEoverlap
BIS78
missingBEE
oneStation
CategoryZero
CategoryOne
CategoryTwo
CategoryThree
CategoryFour

Definition at line 31 of file IMuonSelectionTool.h.

                                {
            unclassified = -1,
            missingInner = 1,
            missingMiddle = 1 << 1,
            missingOuter = 1 << 2,
            highPt2station = 1 << 3,
            highPt = 1 << 4,
            spoiledCSC = 1 << 5,
            BEoverlap = 1 << 6,
            BIS78 = 1 << 7,
            missingBEE = 1 << 8,
            oneStation = 1 << 9,
            CategoryZero = missingInner | spoiledCSC | BEoverlap | BIS78 | missingBEE,
            CategoryOne = missingMiddle | oneStation,
            CategoryTwo = missingOuter,
            CategoryThree = highPt2station,
            CategoryFour = highPt
        };

Constructor & Destructor Documentation

MuonSelectionTool()

CP::MuonSelectionTool::MuonSelectionTool

(

const std::string &

name = "MuonSelection"

)

Create a proper constructor for Athena.

Constructor for standalone usage

Definition at line 56 of file MuonSelectionTool.cxx.

                                                                   : asg::AsgTool(tool_name), m_acceptInfo("MuonSelection"){
 
        if (!m_calculateTightNNScore) m_onnxTool.setTypeAndName("");
 
    }

~MuonSelectionTool()

CP::MuonSelectionTool::~MuonSelectionTool ( )

virtualdefault

Member Function Documentation

accept() [1/2]

asg::AcceptData CP::MuonSelectionTool::accept ( const xAOD::IParticle * p ) const

overridevirtual

Get the decision using a generic IParticle pointer.

Implements IAsgSelectionTool.

Definition at line 316 of file MuonSelectionTool.cxx.

                                                                        {
        // Check if this is a muon:
        if (p->type() != xAOD::Type::Muon) {
            ATH_MSG_ERROR("accept(...) Function received a non-muon");
            return asg::AcceptData(&m_acceptInfo);
        }
 
        // Cast it to a muon:
        const xAOD::Muon* mu = dynamic_cast<const xAOD::Muon*>(p);
        if (!mu) {
            ATH_MSG_FATAL("accept(...) Failed to cast particle to muon");
            return asg::AcceptData(&m_acceptInfo);
        }
 
        // Let the specific function do the work:
        return accept(*mu);
    }

accept() [2/2]

asg::AcceptData CP::MuonSelectionTool::accept ( const xAOD::Muon & mu ) const

overridevirtual

Get the decision for a specific Muon object.

Implements CP::IMuonSelectionTool.

Definition at line 364 of file MuonSelectionTool.cxx.

                                                                    {
        // Verbose information
        ATH_MSG_VERBOSE("-----------------------------------");
        ATH_MSG_VERBOSE("New muon passed to accept function:");
        if (mu.muonType() == xAOD::Muon::Combined)
            ATH_MSG_VERBOSE("Muon type: combined");
        else if (mu.muonType() == xAOD::Muon::MuonStandAlone)
            ATH_MSG_VERBOSE("Muon type: stand-alone");
        else if (mu.muonType() == xAOD::Muon::SegmentTagged)
            ATH_MSG_VERBOSE("Muon type: segment-tagged");
        else if (mu.muonType() == xAOD::Muon::CaloTagged)
            ATH_MSG_VERBOSE("Muon type: calorimeter-tagged");
        else if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon)
            ATH_MSG_VERBOSE("Muon type: silicon-associated forward");
        ATH_MSG_VERBOSE("Muon pT [GeV]: " << mu.pt() * MeVtoGeV);
        ATH_MSG_VERBOSE("Muon eta: " << mu.eta());
        ATH_MSG_VERBOSE("Muon phi: " << mu.phi());
 
        checkSanity();
 
        asg::AcceptData acceptData(&m_acceptInfo);
 
        // Do the eta cut:
        if (std::abs(mu.eta()) >= m_maxEta) {
            ATH_MSG_VERBOSE("Failed eta cut");
            return acceptData;
        }
        acceptData.setCutResult("Eta", true);
 
        // Passes ID hit cuts
        bool passIDCuts = passedIDCuts(mu);
        ATH_MSG_VERBOSE("Passes ID Hit cuts " << passIDCuts);
        acceptData.setCutResult("IDHits", passIDCuts);
 
        // passes muon preselection
        bool passMuonCuts = passedMuonCuts(mu);
        ATH_MSG_VERBOSE("Passes preselection cuts " << passMuonCuts);
        acceptData.setCutResult("Preselection", passMuonCuts);
 
        if (!passIDCuts || !passMuonCuts) { return acceptData; }
 
        // Passes quality requirements
        xAOD::Muon::Quality thisMu_quality = getQuality(mu);
        bool thisMu_highpt = false;
        thisMu_highpt = passedHighPtCuts(mu);
        bool thisMu_lowptE = false;
        thisMu_lowptE = passedLowPtEfficiencyCuts(mu, thisMu_quality);
        ATH_MSG_VERBOSE("Summary of quality information for this muon: ");
        ATH_MSG_VERBOSE("Muon quality: " << thisMu_quality << " passes HighPt: " << thisMu_highpt
                                         << " passes LowPtEfficiency: " << thisMu_lowptE);
        if (m_quality < 4 && thisMu_quality > m_quality) { return acceptData; }
        if (m_quality == 4 && !thisMu_highpt) { return acceptData; }
        if (m_quality == 5 && !thisMu_lowptE) { return acceptData; }
        acceptData.setCutResult("Quality", true);
        // Return the result:
        return acceptData;
    }

checkSanity()

void CP::MuonSelectionTool::checkSanity ( ) const

private

Definition at line 335 of file MuonSelectionTool.cxx.

                                              {
 
        static std::atomic<bool> checkDone{false};
        
        if(!checkDone) {
            // Check that the user either set the correct geometry or enabled on-the-fly determination
            // This can happen intentionally in developer mode. In any case don't throw an exception 
            // (we should either trust the user or ignore in the first place and force on-the-fly determination).
            if (isRun3() != isRun3(true)) { 
                ATH_MSG_WARNING("MuonSelectionTool is configured with isRun3Geo="<<isRun3()
                              <<" while on-the fly check for runNumber "<<getRunNumber(true)<<" indicates isRun3Geo="<<isRun3(true));
            }
 
            // Check that the requested WP is currently supported by the MCP group.
            if (isRun3()) {
                if(m_quality!=0 && m_quality!=1 && m_quality!=2 && m_quality!=4 && m_quality!=5) {
                    ATH_MSG_WARNING("MuonSelectionTool currently supports Loose, Medium, Tight, HighPt, and LowPtEfficiency WPs for Run3; all other WPs can only be used in ExpertDevelopMode mode");
                }
                
                if(m_quality==0 && !m_developMode && (m_excludeNSWFromPrecisionLayers || !m_recalcPrecisionLayerswNSW)) {
                    ATH_MSG_WARNING("For Run3, Tight WP is supported only when ExcludeNSWFromPrecisionLayers=False and RecalcPrecisionLayerswNSW=True");
                }
            }
 
            checkDone = true;
        }
    }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ 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

fillSummary()

void CP::MuonSelectionTool::fillSummary	(	const xAOD::Muon &	muon,
		hitSummary &	summary ) const

functions that fills a hitSummary for a muon

Definition at line 1633 of file MuonSelectionTool.cxx.

                                                                                       {
    
        checkSanity();
    
        retrieveSummaryValue(muon, summary.nprecisionLayers, xAOD::SummaryType::numberOfPrecisionLayers);
        retrieveSummaryValue(muon, summary.nprecisionHoleLayers, xAOD::SummaryType::numberOfPrecisionHoleLayers);
        retrieveSummaryValue(muon, summary.nGoodPrecLayers, xAOD::numberOfGoodPrecisionLayers);
        retrieveSummaryValue(muon, summary.innerSmallHits, xAOD::MuonSummaryType::innerSmallHits);
        retrieveSummaryValue(muon, summary.innerLargeHits, xAOD::MuonSummaryType::innerLargeHits);
        retrieveSummaryValue(muon, summary.middleSmallHits, xAOD::MuonSummaryType::middleSmallHits);
        retrieveSummaryValue(muon, summary.middleLargeHits, xAOD::MuonSummaryType::middleLargeHits);
        retrieveSummaryValue(muon, summary.outerSmallHits, xAOD::MuonSummaryType::outerSmallHits);
        retrieveSummaryValue(muon, summary.outerLargeHits, xAOD::MuonSummaryType::outerLargeHits);
        retrieveSummaryValue(muon, summary.extendedSmallHits, xAOD::MuonSummaryType::extendedSmallHits);
        retrieveSummaryValue(muon, summary.extendedLargeHits, xAOD::MuonSummaryType::extendedLargeHits);
        retrieveSummaryValue(muon, summary.extendedSmallHoles, xAOD::MuonSummaryType::extendedSmallHoles);
        retrieveSummaryValue(muon, summary.isSmallGoodSectors, xAOD::MuonSummaryType::isSmallGoodSectors);
    
        if (!isRun3()) {
            // ignore missing of cscUnspoiledEtaHits in case we are running in expert developer mode
            // e.g. for when we want to apply Run2 WPs in Run3
            retrieveSummaryValue(muon, summary.cscUnspoiledEtaHits, xAOD::MuonSummaryType::cscUnspoiledEtaHits, m_developMode); 
 
            if (std::abs(muon.eta()) > 2.0) {
                ATH_MSG_VERBOSE("Recalculating number of precision layers for combined muon");
                summary.nprecisionLayers = (summary.innerSmallHits > 1 || summary.innerLargeHits > 1)
                                         + (summary.middleSmallHits > 2 || summary.middleLargeHits > 2)
                                         + (summary.outerSmallHits > 2 || summary.outerLargeHits > 2);
            }
 
        } else if (std::abs(muon.eta()) > 1.3 && (m_excludeNSWFromPrecisionLayers || m_recalcPrecisionLayerswNSW)) {
            summary.nprecisionLayers = (summary.middleSmallHits > 2 || summary.middleLargeHits > 2)
                                     + (summary.outerSmallHits > 2 || summary.outerLargeHits > 2)
                                     + (summary.extendedSmallHits > 2 || summary.extendedLargeHits > 2);
 
            if (!m_excludeNSWFromPrecisionLayers && m_recalcPrecisionLayerswNSW) {
 
                if (!eta1stgchits_acc.isAvailable(muon) || !eta2stgchits_acc.isAvailable(muon) || !mmhits_acc.isAvailable(muon)) {
                    ATH_MSG_FATAL(__FILE__ << ":" << __LINE__ << " Failed to retrieve NSW hits!"
                                           << " (Please use DxAODs with p-tags >= p5834 OR set ExcludeNSWFromPrecisionLayers to True (tests only)");
                    throw std::runtime_error("Failed to retrieve NSW hits");
                }
 
                retrieveSummaryValue(muon, summary.etaLayer1STGCHits, xAOD::MuonSummaryType::etaLayer1STGCHits);
                retrieveSummaryValue(muon, summary.etaLayer2STGCHits, xAOD::MuonSummaryType::etaLayer2STGCHits);
                retrieveSummaryValue(muon, summary.MMHits, xAOD::MuonSummaryType::MMHits);
                summary.nprecisionLayers += ((summary.etaLayer1STGCHits + summary.etaLayer2STGCHits) > 3 || summary.MMHits > 3);
            }
        }
    }

getAcceptInfo()

const asg::AcceptInfo & CP::MuonSelectionTool::getAcceptInfo ( ) const

overridevirtual

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

Implements IAsgSelectionTool.

Definition at line 314 of file MuonSelectionTool.cxx.

{ return m_acceptInfo; }

getHist()

StatusCode CP::MuonSelectionTool::getHist ( TFile * file, const std::string & histName, std::unique_ptr< TH1 > & hist ) const

private

Checks for each histogram.

Definition at line 293 of file MuonSelectionTool.cxx.

                                                                                                                {
        //
        if (!file) {
            ATH_MSG_ERROR(" getHist(...) TFile is nullptr! Check that the Tight cut map is loaded correctly");
            return StatusCode::FAILURE;
        }
        TH1* h_ptr = nullptr;
        file->GetObject(histName.c_str(), h_ptr);
        //
        //
        if (!h_ptr) {
            ATH_MSG_ERROR("Cannot retrieve histogram " << histName);
            return StatusCode::FAILURE;
        }
        hist = std::unique_ptr<TH1>{h_ptr};
        hist->SetDirectory(nullptr);
        ATH_MSG_INFO("Successfully read tight working point histogram: " << hist->GetName());
        //
        return StatusCode::SUCCESS;
    }

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

ptr	The 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.

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

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

ptr	The 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.

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

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

getQuality()

xAOD::Muon::Quality CP::MuonSelectionTool::getQuality ( const xAOD::Muon & mu ) const

overridevirtual

Returns the quality of the muon. To set the value on the muon, instead call setQuality(xAOD::Muon&) const.

Implements CP::IMuonSelectionTool.

Definition at line 480 of file MuonSelectionTool.cxx.

                                                                          {
        ATH_MSG_VERBOSE("Evaluating muon quality...");
        if (isRun3() && mu.isAuthor(xAOD::Muon::Author::Commissioning) && !m_allowComm) {
            ATH_MSG_VERBOSE("Reject authors from the commissioning chain");
            return xAOD::Muon::VeryLoose;
        }
 
        // SegmentTagged muons
        if (mu.muonType() == xAOD::Muon::SegmentTagged) {
            ATH_MSG_VERBOSE("Muon is segment-tagged");
 
            if (std::abs(mu.eta()) < 0.1) {
                ATH_MSG_VERBOSE("Muon is loose");
                return xAOD::Muon::Loose;
            } else {
                ATH_MSG_VERBOSE("Do not allow segment-tagged muon at |eta| > 0.1 - return VeryLoose");
                return xAOD::Muon::VeryLoose;
            }
        }
 
        // CaloTagged muons
        if (mu.muonType() == xAOD::Muon::CaloTagged) {
            ATH_MSG_VERBOSE("Muon is calorimeter-tagged");
 
            if (std::abs(mu.eta()) < 0.1 && passedCaloTagQuality(mu)) {
                ATH_MSG_VERBOSE("Muon is loose");
                return xAOD::Muon::Loose;
            }
        }
 
        // Combined muons
        hitSummary summary{};
        fillSummary(mu, summary);
        
        if (mu.muonType() == xAOD::Muon::Combined) {
            ATH_MSG_VERBOSE("Muon is combined");
            if (mu.author() == xAOD::Muon::STACO) {
                ATH_MSG_VERBOSE("Muon is STACO - return VeryLoose");
                return xAOD::Muon::VeryLoose;
            }
 
            // rejection muons with out-of-bounds hits
            uint8_t combinedTrackOutBoundsPrecisionHits{0};
            retrieveSummaryValue(mu, combinedTrackOutBoundsPrecisionHits, xAOD::MuonSummaryType::combinedTrackOutBoundsPrecisionHits);
 
            if (combinedTrackOutBoundsPrecisionHits > 0) {
                ATH_MSG_VERBOSE("Muon has out-of-bounds precision hits - return VeryLoose");
                return xAOD::Muon::VeryLoose;
            }
 
            // LOOSE / MEDIUM / TIGHT WP
            const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
            const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
            if (idtrack && metrack && metrack->definingParametersCovMatrix()(4, 4) > 0) {
                const float qOverPsignif = qOverPsignificance(mu);
                const float rho = rhoPrime(mu);
                const float reducedChi2 = mu.primaryTrackParticle()->chiSquared() / mu.primaryTrackParticle()->numberDoF();
 
                ATH_MSG_VERBOSE("Relevant cut variables:");
                ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers);
                ATH_MSG_VERBOSE("reduced Chi2 = " << reducedChi2);
                ATH_MSG_VERBOSE("qOverP significance = " << qOverPsignif);
 
                // NEW TIGHT WP
                if (summary.nprecisionLayers > 1 && reducedChi2 < 8 && std::abs(qOverPsignif) < 7) {
                    if (passTight(mu, rho, qOverPsignif)) {
                        ATH_MSG_VERBOSE("Muon is tight");
                        return xAOD::Muon::Tight;
                    }
                }
 
                ATH_MSG_VERBOSE("Muon did not pass requirements for tight combined muon");
 
                // MEDIUM WP
                if ((std::abs(qOverPsignif) < 7 || m_toroidOff) &&
                    (summary.nprecisionLayers > 1 ||(summary.nprecisionLayers == 1 && summary.nprecisionHoleLayers < 2 && std::abs(mu.eta()) < 0.1))
                    
                   ) {
                    ATH_MSG_VERBOSE("Muon is medium");
                    return xAOD::Muon::Medium;
                }
 
                ATH_MSG_VERBOSE("Muon did not pass requirements for medium combined muon");
 
            } else {
                ATH_MSG_VERBOSE("Muon is missing the ID and/or ME tracks...");
 
                // CB muons with missing ID or ME track
                if ((summary.nprecisionLayers > 1 ||
                     (summary.nprecisionLayers == 1 && summary.nprecisionHoleLayers < 2 && std::abs(mu.eta()) < 0.1))) {
                    // In toroid-off data ME/MS tracks often missing - need special treatment  => flagging as "Medium"
                    // In toroid-on data ME/MS tracks missing only for <1% of CB muons, mostly MuGirl (to be fixed) => flagging as "Loose"
                    if (m_toroidOff) {
                        ATH_MSG_VERBOSE("...this is toroid-off data - returning medium");
                        return xAOD::Muon::Medium;
                    } else {
                        ATH_MSG_VERBOSE("...this is not toroid-off data - returning loose");
                        return xAOD::Muon::Loose;
                    }
                }
            }
 
            // Improvement for Loose targeting low-pT muons (pt<7 GeV)
            if ((m_disablePtCuts || mu.pt() * MeVtoGeV < 7.) && std::abs(mu.eta()) < 1.3 && summary.nprecisionLayers > 0 &&
                (mu.author() == xAOD::Muon::MuGirl && mu.isAuthor(xAOD::Muon::MuTagIMO))) {
                ATH_MSG_VERBOSE("Muon passed selection for loose working point at low pT");
                return xAOD::Muon::Loose;
            }
 
            // didn't pass the set of requirements for a medium or tight combined muon
            ATH_MSG_VERBOSE("Did not pass selections for combined muon - returning VeryLoose");
            return xAOD::Muon::VeryLoose;
        }
 
        // SA muons
        if (mu.author() == xAOD::Muon::MuidSA) {
            ATH_MSG_VERBOSE("Muon is stand-alone");
            
            if (std::abs(mu.eta()) > 2.5) {
                ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers);
 
                // 3 station requirement for medium
                if (summary.nprecisionLayers > 2 && !m_toroidOff) {
                    ATH_MSG_VERBOSE("Muon is medium");
                    return xAOD::Muon::Medium;
                }
            }
 
            // didn't pass the set of requirements for a medium SA muon
            ATH_MSG_VERBOSE("Muon did not pass selection for medium stand-alone muon - return VeryLoose");
            return xAOD::Muon::VeryLoose;
        }
 
        // SiliconAssociatedForward (SAF) muons
        if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
            ATH_MSG_VERBOSE("Muon is silicon-associated forward muon");
            
            const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
            const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
 
            if (cbtrack && metrack) {
                if (std::abs(cbtrack->eta()) > 2.5) {
                    ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers);
 
                    if (summary.nprecisionLayers > 2 && !m_toroidOff) {
                        if (mu.trackParticle(xAOD::Muon::Primary) == mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle) &&
                            !m_developMode) {
                            ATH_MSG_FATAL(
                                "SiliconForwardAssociated muon has ID track as primary track particle. "
                                << "This is a bug fixed starting with xAODMuon-00-17-07, which should be present in this release. "
                                << "Please report this to the Muon CP group!");
                        }
                        ATH_MSG_VERBOSE("Muon is medium");
                        return xAOD::Muon::Medium;
                    }
                }
            }
 
            // didn't pass the set of requirements for a medium SAF muon
            ATH_MSG_VERBOSE("Muon did not pass selection for medium silicon-associated forward muon - return VeryLoose");
            return xAOD::Muon::VeryLoose;
        }
 
        ATH_MSG_VERBOSE("Muon did not pass selection for loose/medium/tight for any muon type - return VeryLoose");
        return xAOD::Muon::VeryLoose;
    }

getResolutionCategory()

int CP::MuonSelectionTool::getResolutionCategory ( const xAOD::Muon & mu ) const

overridevirtual

Returns an integer corresponding to categorization of muons with different resolutions.

Implements CP::IMuonSelectionTool.

Definition at line 1695 of file MuonSelectionTool.cxx.

                                                                         {
        // Resolutions have only been evaluated for medium combined muons
        if (mu.muonType() != xAOD::Muon::Combined || getQuality(mu) > xAOD::Muon::Medium) return ResolutionCategory::unclassified;
 
        // :: Access MS hits information
        hitSummary summary{};
        fillSummary(mu, summary);
 
        // For muons passing the high-pT working point, distinguish between 2-station tracks and the rest
        if (passedHighPtCuts(mu)) {
            if (summary.nprecisionLayers == 2)
                return ResolutionCategory::highPt2station;
            else
                return ResolutionCategory::highPt;
        }
 
        const xAOD::TrackParticle* CB_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
        const xAOD::TrackParticle* MS_track = mu.trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
        if (!MS_track) {
            ATH_MSG_VERBOSE("getResolutionCategory - No MS track available for muon. Using combined track.");
            MS_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
        }
 
        if (!MS_track || !CB_track) return ResolutionCategory::unclassified;
        const float etaMS = MS_track->eta();
        const float etaCB = CB_track->eta();
        const float phiMS = MS_track->phi();
 
        int category = ResolutionCategory::unclassified;
 
        if ((summary.isSmallGoodSectors && summary.innerSmallHits < 3) || (!summary.isSmallGoodSectors && summary.innerLargeHits < 3))
            category = ResolutionCategory::missingInner;  // missing-inner
 
        if ((summary.isSmallGoodSectors && summary.middleSmallHits < 3) || (!summary.isSmallGoodSectors && summary.middleLargeHits < 3))
            category = ResolutionCategory::missingMiddle;  // missing-middle
 
        if ((summary.isSmallGoodSectors && summary.outerSmallHits < 3 && summary.extendedSmallHits < 3) ||
            (!summary.isSmallGoodSectors && summary.outerLargeHits < 3 && summary.extendedLargeHits < 3))
            category = ResolutionCategory::missingOuter;  // missing-outer
 
        if (!isRun3() && (std::abs(etaMS) > 2.0 || std::abs(etaCB) > 2.0) && summary.cscUnspoiledEtaHits == 0)
            category = ResolutionCategory::spoiledCSC;  // spoiled CSC
 
        if ((1.01 < std::abs(etaMS) && std::abs(etaMS) < 1.1) || (1.01 < std::abs(etaCB) && std::abs(etaCB) < 1.1))
            category = ResolutionCategory::BEoverlap;  // barrel-end-cap overlap
 
        if (isBIS78(etaMS, phiMS)) category = ResolutionCategory::BIS78;  // BIS7/8
 
        //::: BEE
        if (isBEE(etaMS, phiMS) || (std::abs(etaCB) > 1.4 && (summary.extendedSmallHits > 0 || summary.extendedSmallHoles > 0))) {
            if (summary.extendedSmallHits < 3 && summary.middleSmallHits >= 3 && summary.outerSmallHits >= 3)
                category = ResolutionCategory::missingBEE;  // missing-BEE
 
            if (summary.extendedSmallHits >= 3 && summary.outerSmallHits < 3) category = ResolutionCategory::missingOuter;  // missing-outer
 
            if (!summary.isSmallGoodSectors)
                category = ResolutionCategory::unclassified;  // ambiguity due to eta/phi differences between MS and CB track
        }
 
        if (summary.nprecisionLayers == 1) category = ResolutionCategory::oneStation;  // one-station track
 
        return category;
    }

getRunNumber()

unsigned int CP::MuonSelectionTool::getRunNumber ( bool needOnlyCorrectYear = false ) const

private

Definition at line 1761 of file MuonSelectionTool.cxx.

                                                                                 {
 
        static const SG::AuxElement::ConstAccessor<unsigned int> acc_rnd("RandomRunNumber");
 
        SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
    //overwrite run number
        unsigned int runNumber = 0;
        if(m_expertMode_RunNumber.value()!=0) runNumber=m_expertMode_RunNumber.value();
        else runNumber = eventInfo->runNumber();
 
        // Case of data
        if (!eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
            ATH_MSG_DEBUG("The current event is a data event. Return runNumber.");
            return runNumber;
        }
 
        // Case of MC 
        // attempt to get the run number assigned by the PRW tool
        static std::atomic<bool> issuedWarningPRW{false};
        if (acc_rnd.isAvailable(*eventInfo)) {
            unsigned int rn = acc_rnd(*eventInfo);
            if (rn != 0) return acc_rnd(*eventInfo);
 
            if (!issuedWarningPRW) {
                ATH_MSG_WARNING("Pile up tool has assigned runNumber = 0");
                issuedWarningPRW = true;
            }
        }
 
        // otherwise return a dummy run number
        if (needOnlyCorrectYear) {
            if (runNumber < 300000) {        // mc16a (2016): 284500
                ATH_MSG_DEBUG("Random run number not available and this is mc16a or mc20a, returning dummy 2016 run number.");
                return 311071;
                    
            } else if (runNumber < 310000) { // mc16d (2017): 300000
                ATH_MSG_DEBUG("Random run number not available and this is mc16d or mc20d, returning dummy 2017 run number.");
                return 340072;
                    
            } else if (runNumber < 320000) { // mc16e (2018): 310000
                ATH_MSG_DEBUG("Random run number not available and this is mc16e or mc20e, returning dummy 2018 run number.");
                return 351359;
 
            } else if (runNumber < 600000) { //mc21: 330000, mc23a: 410000, mc23c: 450000
                ATH_MSG_DEBUG("Random run number not available and this is mc21/mc23, for the time being we're returing a dummy run number.");
                return 399999;
            } else {
                ATH_MSG_DEBUG("Detected some run 4 / phase II runnumber "<<runNumber<<". ");
                return 666666;
            }
 
            ATH_MSG_FATAL("Random run number not available, fallback option of using runNumber failed since "<<runNumber<<" cannot be recognised");
            throw std::runtime_error("MuonSelectionTool() - need RandomRunNumber decoration by the PileupReweightingTool");
        }
 
        ATH_MSG_FATAL("Failed to find the RandomRunNumber decoration by the PileupReweightingTool");
        throw std::runtime_error("MuonSelectionTool() - need RandomRunNumber decoration from PileupReweightingTool");
    }

getSegmentsSorted()

std::vector< const xAOD::MuonSegment * > CP::MuonSelectionTool::getSegmentsSorted

(

const xAOD::Muon &

mu

)

const

Returns a vector of the muon's segments, sorted according to chamber index.

Definition at line 851 of file MuonSelectionTool.cxx.

                                                                                                   {
        std::vector<const xAOD::MuonSegment*> segments_sorted;
        segments_sorted.reserve(mu.nMuonSegments());
 
        for (unsigned int i = 0; i < mu.nMuonSegments(); i++) {
            if (!mu.muonSegment(i))
                ATH_MSG_WARNING("The muon reports more segments than are available. Please report this to the muon software community!");
            else
                segments_sorted.push_back(mu.muonSegment(i));
        }
 
        std::sort(segments_sorted.begin(), segments_sorted.end(), chamberIndexCompare);
 
        return segments_sorted;
    }

getTightNNScore()

float CP::MuonSelectionTool::getTightNNScore ( const xAOD::Muon & muon ) const

overridevirtual

Returns the TightNNscore of the muon, an experimental ML-based score for the identification of muons from HF hadron decays.

Implements CP::IMuonSelectionTool.

Definition at line 1872 of file MuonSelectionTool.cxx.

                                                                     {
        if (!m_calculateTightNNScore)
        {
            ATH_MSG_ERROR("TightNNScore calculation is disabled. Please set the property CalculateTightNNScore to true.");
            throw std::runtime_error("cannot calculate TightNNScore");  
        }
        //this score currently only can be calculated for combined muons
        if (mu.muonType() != xAOD::Muon::Combined) return -999;
        const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
            const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
        if(!idtrack || !metrack) return -999;
        //the score is only calculated for muons which pass the Medium WP
        if (getQuality(mu) > xAOD::Muon::Medium) return -999;
        //only muons with pt > 4 GeV and |eta|<2.5 are considered
        if (std::abs(mu.eta())>2.5) return -999;
        if(mu.pt()<4000.) return -999;
 
        std::vector<float> input_features;
        // 1. Fill input features
        int mu_author=mu.author();
        float mu_rhoPrime=rhoPrime(mu);
        float mu_scatteringCurvatureSignificance=0.;
        retrieveParam(mu, mu_scatteringCurvatureSignificance, xAOD::Muon::scatteringCurvatureSignificance);
        float mu_scatteringNeighbourSignificance=0.;
        retrieveParam(mu, mu_scatteringNeighbourSignificance, xAOD::Muon::scatteringNeighbourSignificance);
        float mu_momentumBalanceSignificance=0.;
        retrieveParam(mu, mu_momentumBalanceSignificance, xAOD::Muon::momentumBalanceSignificance);
        float mu_qOverPSignificance=qOverPsignificance(mu);
        float mu_reducedChi2=mu.primaryTrackParticle()->chiSquared() / mu.primaryTrackParticle()->numberDoF();
        float mu_reducedChi2_ID=idtrack->chiSquared() / idtrack->numberDoF();
        float mu_reducedChi2_ME=metrack->chiSquared() / metrack->numberDoF();
        float mu_spectrometerFieldIntegral=0.;
        retrieveParam(mu, mu_spectrometerFieldIntegral, xAOD::Muon::spectrometerFieldIntegral);
        float mu_segmentDeltaEta=0;
        retrieveParam(mu, mu_segmentDeltaEta, xAOD::Muon::segmentDeltaEta);
        uint8_t mu_numberOfPixelHits=0;
        retrieveSummaryValue(mu, mu_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
        uint8_t mu_numberOfPixelDeadSensors=0;
        retrieveSummaryValue(mu, mu_numberOfPixelDeadSensors, xAOD::SummaryType::numberOfPixelDeadSensors);
        uint8_t mu_innerLargeHits=0;
        retrieveSummaryValue(mu, mu_innerLargeHits, xAOD::MuonSummaryType::innerLargeHits);
        uint8_t mu_innerSmallHits=0;
        retrieveSummaryValue(mu, mu_innerSmallHits, xAOD::MuonSummaryType::innerSmallHits);
        uint8_t mu_middleLargeHits=0;
        retrieveSummaryValue(mu, mu_middleLargeHits, xAOD::MuonSummaryType::middleLargeHits);
        uint8_t mu_middleSmallHits=0;
        retrieveSummaryValue(mu, mu_middleSmallHits, xAOD::MuonSummaryType::middleSmallHits);
        uint8_t mu_outerLargeHits=0;
        retrieveSummaryValue(mu, mu_outerLargeHits, xAOD::MuonSummaryType::outerLargeHits);
        uint8_t mu_outerSmallHits=0;
        retrieveSummaryValue(mu, mu_outerSmallHits, xAOD::MuonSummaryType::outerSmallHits);
 
        if(!isRun3())
        {
            input_features =     {(float)mu_author,
                                mu_rhoPrime,
                                mu_scatteringCurvatureSignificance,
                                mu_scatteringNeighbourSignificance,
                                mu_momentumBalanceSignificance,
                                mu_qOverPSignificance,
                                mu_reducedChi2,
                                mu_reducedChi2_ID,
                                mu_reducedChi2_ME,
                                mu_spectrometerFieldIntegral,
                                mu_segmentDeltaEta,
                                (float)mu_numberOfPixelHits,
                                (float)mu_numberOfPixelDeadSensors,
                                (float)mu_innerLargeHits,
                                (float)mu_innerSmallHits,
                                (float)mu_middleLargeHits,
                                (float)mu_middleSmallHits,
                                (float)mu_outerLargeHits,
                                (float)mu_outerSmallHits};
        }
        else
        {
            uint8_t mu_phiLayer1STGCHits=0;
            retrieveSummaryValue(mu, mu_phiLayer1STGCHits, xAOD::MuonSummaryType::phiLayer1STGCHits);
            uint8_t mu_phiLayer2STGCHits=0;
            retrieveSummaryValue(mu, mu_phiLayer2STGCHits, xAOD::MuonSummaryType::phiLayer2STGCHits);
            uint8_t mu_etaLayer1STGCHits=0;
            retrieveSummaryValue(mu, mu_etaLayer1STGCHits, xAOD::MuonSummaryType::etaLayer1STGCHits);
            uint8_t mu_etaLayer2STGCHits=0;
            retrieveSummaryValue(mu, mu_etaLayer2STGCHits, xAOD::MuonSummaryType::etaLayer2STGCHits);
            uint8_t mu_MMHits=0;
            retrieveSummaryValue(mu, mu_MMHits, xAOD::MuonSummaryType::MMHits);
            input_features =     {(float)mu_author,
                                mu_rhoPrime,
                                mu_scatteringCurvatureSignificance,
                                mu_scatteringNeighbourSignificance,
                                mu_momentumBalanceSignificance,
                                mu_qOverPSignificance,
                                mu_reducedChi2,
                                mu_reducedChi2_ID,
                                mu_reducedChi2_ME,
                                mu_spectrometerFieldIntegral,
                                mu_segmentDeltaEta,
                                (float)mu_numberOfPixelHits,
                                (float)mu_numberOfPixelDeadSensors,
                                (float)mu_innerLargeHits,
                                (float)mu_innerSmallHits,
                                (float)mu_middleLargeHits,
                                (float)mu_middleSmallHits,
                                (float)mu_outerLargeHits,
                                (float)mu_outerSmallHits,
                                (float)mu_phiLayer1STGCHits,
                                (float)mu_phiLayer2STGCHits,
                                (float)mu_etaLayer1STGCHits,
                                (float)mu_etaLayer2STGCHits,
                                (float)mu_MMHits};
        }
 
        float score=-999.;
        std::vector<int64_t> inputShape = {1, static_cast<int64_t>(input_features.size())};
 
        AthInfer::InputDataMap inputData;
        inputData["flatten_input"] = std::make_pair(
            inputShape, std::move(input_features)
        );
 
        AthInfer::OutputDataMap outputData;
        outputData["sequential"] = std::make_pair(
            std::vector<int64_t>{1, 1}, std::vector<float>{}
        );
 
        if (!m_onnxTool->inference(inputData, outputData).isSuccess()) {
            ATH_MSG_WARNING("ONNX inference failed!");
            return -999.;
        }
        const auto& variant = outputData["sequential"].second;
        if (std::holds_alternative<std::vector<float>>(variant)) {
            const auto& vec = std::get<std::vector<float>>(variant);
            if (!vec.empty()) score = vec[0];
            else {
                ATH_MSG_WARNING("ONNX output vector is empty!");
                return -999.;
            }
        } else {
            ATH_MSG_WARNING("ONNX output is not a float vector!");
            return -999.;
        }
        
        ATH_MSG_DEBUG("TightNNScore for muon with pT " << mu.pt() << " GeV, eta " << mu.eta() << " is " << score);
 
        return score;
    }

IdMsPt()

void CP::MuonSelectionTool::IdMsPt ( const xAOD::Muon & muon, float & idPt, float & msPt ) const

private

Definition at line 426 of file MuonSelectionTool.cxx.

                                                                                     {
        const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
        const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
        if (!idtrack || !metrack) idPt = mePt = -1.;
        else if (m_turnOffMomCorr) {
            mePt = metrack->pt();
            idPt = idtrack->pt();
        } else {
            if (!mePt_acc.isAvailable(mu) || !idPt_acc.isAvailable(mu)) {
                ATH_MSG_FATAL("The muon with pT " << mu.pt() * MeVtoGeV << " eta: " << mu.eta() << ", phi:" << mu.phi()
                                                  << " q:" << mu.charge() << ", author:" << mu.author()
                                                  << " is not decorated with calibrated momenta. Please fix");
                throw std::runtime_error("MuonSelectionTool() - qOverP significance calculation failed");
            }
            mePt = mePt_acc(mu);
            idPt = idPt_acc(mu);
        }
    }

initialize()

StatusCode CP::MuonSelectionTool::initialize ( void )

overridevirtual

Function initialising the tool.

Reimplemented from asg::AsgTool.

Definition at line 64 of file MuonSelectionTool.cxx.

                                             {
    
        // Greet the user:
        ATH_MSG_INFO("Initialising...");
        
        m_geoOnTheFly ? ATH_MSG_INFO("Is Run-3 geometry: On-the-fly determination. THIS OPTION IS DEPRECATED AND WILL BE REMOVED SOON. Use IsRun3Geo property instead.") 
                      : ATH_MSG_INFO("Is Run-3 geometry: " << m_isRun3.value());
        ATH_MSG_INFO("Maximum muon |eta|: " << m_maxEta.value());
        ATH_MSG_INFO("Muon quality: "<< m_quality.value());
        if (m_toroidOff) ATH_MSG_INFO("!! CONFIGURED FOR TOROID-OFF COLLISIONS !!");
        if (m_SctCutOff) ATH_MSG_WARNING("!! SWITCHING SCT REQUIREMENTS OFF !! FOR DEVELOPMENT USE ONLY !!");
        if (m_PixCutOff) ATH_MSG_WARNING("!! SWITCHING PIXEL REQUIREMENTS OFF !! FOR DEVELOPMENT USE ONLY !!");
        if (m_SiHolesCutOff) ATH_MSG_WARNING("!! SWITCHING SILICON HOLES REQUIREMENTS OFF !! FOR DEVELOPMENT USE ONLY !!");
        if (m_custom_dir != "")
            ATH_MSG_WARNING("!! SETTING UP WITH USER SPECIFIED INPUT LOCATION \"" << m_custom_dir << "\"!! FOR DEVELOPMENT USE ONLY !! ");
        if (!m_useAllAuthors)
            ATH_MSG_WARNING(
                "Not using allAuthors variable as currently missing in many derivations; LowPtEfficiency working point will always return "
                "false, but this is expected at the moment. Have a look here: "
                "https://twiki.cern.ch/twiki/bin/view/Atlas/MuonSelectionToolR21#New_LowPtEfficiency_working_poin");
 
        // Print message to ensure that users excluding 2-station muons in the high-pT selection are aware of this
        if (!m_use2stationMuonsHighPt)
            ATH_MSG_INFO("You have opted to select only 3-station muons in the high-pT selection! "
                         << "Please feed 'HighPt3Layers' to the 'WorkingPoint' property to retrieve the appropriate scale-factors");
 
        // Only an MVA-based selection is defined for segment-tagged muons for the Low-pT working point
        if (m_useSegmentTaggedLowPt && !m_useMVALowPt) {
            ATH_MSG_WARNING("No cut-based selection is defined for segment-tagged muons in the Low-pT working point. "
                            << "Please set UseMVALowPt=true if you want to try the UseSegmentTaggedLowPt=true option.");
            m_useSegmentTaggedLowPt = false;
        }
        if (m_useLRT) { 
            ATH_MSG_INFO("MuonSelectionTool will assume both Standard and LRT Muons are being used, and that the necessary information is available to identify the type (standard or LRT).");
            if (m_quality!=1) ATH_MSG_WARNING("Currently, only Medium quality is supported for LRT muons. Your chosen WP will be applied (w/o ID cuts), but no recommendations are available for this quality.");
        }
 
        // Set up the TAccept object:
        m_acceptInfo.addCut("Eta", "Selection of muons according to their pseudorapidity");
        m_acceptInfo.addCut("IDHits", "Selection of muons according to whether they passed the MCP ID Hit cuts");
        m_acceptInfo.addCut("Preselection", "Selection of muons according to their type/author");
        m_acceptInfo.addCut("Quality", "Selection of muons according to their tightness");
        // Sanity check
        if (m_quality > 5) {
            ATH_MSG_ERROR(
                "Invalid quality (i.e. selection WP) set: "
                << m_quality
                << " - it must be an integer between 0 and 5! (0=Tight, 1=Medium, 2=Loose, 3=Veryloose, 4=HighPt, 5=LowPtEfficiency)");
            return StatusCode::FAILURE;
        }
        if (m_quality == 5 && !m_useAllAuthors) {
            ATH_MSG_ERROR("Cannot use lowPt working point if allAuthors is not available!");
            return StatusCode::FAILURE;
        }
        
        if(m_caloScoreWP<1 || m_caloScoreWP>4){
          ATH_MSG_FATAL("CaloScoreWP property must be set to 1, 2, 3 or 4");
          return StatusCode::FAILURE;
        }
 
        // Load Tight WP cut-map
        ATH_MSG_INFO("Initialising tight working point histograms...");
        std::string tightWP_rootFile_fullPath;
        if (!m_custom_dir.empty()) {
            tightWP_rootFile_fullPath = PathResolverFindCalibFile(m_custom_dir + "/muonSelection_tightWPHisto.root");
        } else {
            tightWP_rootFile_fullPath = PathResolverFindCalibFile(
                Form("MuonSelectorTools/%s/muonSelection_tightWPHisto.root", m_calibration_version.value().c_str()));
        }
 
        ATH_MSG_INFO("Reading muon tight working point histograms from " << tightWP_rootFile_fullPath);
        //
        std::unique_ptr<TFile> file(TFile::Open(tightWP_rootFile_fullPath.c_str(), "READ"));
 
        if (!file->IsOpen()) {
            ATH_MSG_ERROR("Cannot read tight working point file from " << tightWP_rootFile_fullPath);
            return StatusCode::FAILURE;
        }
 
        // Retrieve all the relevant histograms
        ATH_CHECK(getHist(file.get(), "tightWP_lowPt_rhoCuts", m_tightWP_lowPt_rhoCuts));
        ATH_CHECK(getHist(file.get(), "tightWP_lowPt_qOverPCuts", m_tightWP_lowPt_qOverPCuts));
        ATH_CHECK(getHist(file.get(), "tightWP_mediumPt_rhoCuts", m_tightWP_mediumPt_rhoCuts));
        ATH_CHECK(getHist(file.get(), "tightWP_highPt_rhoCuts", m_tightWP_highPt_rhoCuts));
        //
        file->Close();
 
        // Read bad muon veto efficiency histograms
        std::string BMVcutFile_fullPath = PathResolverFindCalibFile(m_BMVcutFile);
 
        ATH_MSG_INFO("Reading bad muon veto cut functions from " << BMVcutFile_fullPath);
        //
        std::unique_ptr<TFile> BMVfile(TFile::Open(BMVcutFile_fullPath.c_str(), "READ"));
 
        if (!BMVfile->IsOpen()) {
            ATH_MSG_ERROR("Cannot read bad muon veto cut function file from " << BMVcutFile_fullPath);
            return StatusCode::FAILURE;
        }
 
        m_BMVcutFunction_barrel = std::unique_ptr<TF1>((TF1*)BMVfile->Get("BMVcutFunction_barrel"));
        m_BMVcutFunction_endcap = std::unique_ptr<TF1>((TF1*)BMVfile->Get("BMVcutFunction_endcap"));
 
        BMVfile->Close();
 
        if (!m_BMVcutFunction_barrel || !m_BMVcutFunction_endcap) {
            ATH_MSG_ERROR("Cannot read bad muon veto cut functions");
            return StatusCode::FAILURE;
        }
 
        if (m_useMVALowPt) {
            if (m_isRun3) {
                // Helper lambda to load BDT model and scaler
                auto loadLowPtMVABDTModel = [&](const std::string& calibFile, 
                                    std::unique_ptr<MVAUtils::BDT>& bdt,
                                    std::vector<double>& means,
                                    std::vector<double>& scales) -> StatusCode {
                    const std::string modelFile = PathResolverFindCalibFile(calibFile);
                    std::unique_ptr<TFile> rootFile(TFile::Open(modelFile.c_str(), "READ"));
                    
                    if (!rootFile || rootFile->IsZombie()) {
                        ATH_MSG_ERROR("Failed to open model file for Run-3 LowPtMVA: " << modelFile);
                        return StatusCode::FAILURE;
                    }
                    
                    // Load BDT model
                    auto* bdt_tree = static_cast<TTree*>(rootFile->Get("xgboost"));
                    bdt = std::make_unique<MVAUtils::BDT>(bdt_tree);
                    
                    // Load scaler
                    std::unique_ptr<TTree> scaler_tree(static_cast<TTree*>(rootFile->Get("scaler")));
                    std::vector<double>* mean_ptr = nullptr;
                    std::vector<double>* scale_ptr = nullptr;
                    scaler_tree->SetBranchAddress("mean", &mean_ptr);
                    scaler_tree->SetBranchAddress("scale", &scale_ptr);
                    
                    for (Long64_t i = 0; i < scaler_tree->GetEntries(); ++i) {
                        scaler_tree->GetEntry(i);
                        for (size_t j = 0; j < mean_ptr->size(); ++j) {
                            means.push_back((*mean_ptr)[j]);
                            scales.push_back((*scale_ptr)[j]);
                        }
                    }
                    return StatusCode::SUCCESS;
                };
 
                // Load MuidCO model for Run-3 LowPtMVA
                ATH_CHECK(loadLowPtMVABDTModel("MuonSelectorTools/260130_LowPtMVA_r24run3/xgb_lowPtMVA_MuidCO_wScaler.root",
                            m_MuidCO, m_lowPtMuidCO_means, m_lowPtMuidCO_scaler));
 
                // Load MuGirl model for Run-3 LowPtMVA
                ATH_CHECK(loadLowPtMVABDTModel("MuonSelectorTools/260130_LowPtMVA_r24run3/xgb_lowPtMVA_MuGirl_wScaler.root",
                            m_MuGirl, m_lowPtMuGirl_means, m_lowPtMuGirl_scaler));
            }
            else{
                // Set up TMVA readers for MVA-based low-pT working point
                // E and O refer to even and odd event numbers to avoid applying the MVA on events used for training
                TString weightPath_EVEN_MuidCB = PathResolverFindCalibFile(m_MVAreaderFile_EVEN_MuidCB);
                TString weightPath_ODD_MuidCB = PathResolverFindCalibFile(m_MVAreaderFile_ODD_MuidCB);
                TString weightPath_EVEN_MuGirl = PathResolverFindCalibFile(m_MVAreaderFile_EVEN_MuGirl);
                TString weightPath_ODD_MuGirl = PathResolverFindCalibFile(m_MVAreaderFile_ODD_MuGirl);
 
                auto make_mva_reader = [](TString file_path) {
                    std::vector<std::string> mva_var_names{"momentumBalanceSignificance",
                                                        "scatteringCurvatureSignificance",
                                                        "scatteringNeighbourSignificance",
                                                        "EnergyLoss",
                                                        "middleLargeHoles+middleSmallHoles",
                                                        "muonSegmentDeltaEta",
                                                        "muonSeg1ChamberIdx",
                                                        "muonSeg2ChamberIdx"};
                    std::unique_ptr<TMVA::Reader> reader = std::make_unique<TMVA::Reader>(mva_var_names);
                    reader->BookMVA("BDTG", file_path);
                    return reader;
                };
                m_readerE_MUID = make_mva_reader(weightPath_EVEN_MuidCB);
 
                m_readerO_MUID = make_mva_reader(weightPath_ODD_MuidCB);
 
                m_readerE_MUGIRL = make_mva_reader(weightPath_EVEN_MuGirl);
 
                m_readerO_MUGIRL = make_mva_reader(weightPath_ODD_MuGirl);
 
                if (m_useSegmentTaggedLowPt) {
                    TString weightPath_MuTagIMO_etaBin1 = PathResolverFindCalibFile(m_MVAreaderFile_MuTagIMO_etaBin1);
                    TString weightPath_MuTagIMO_etaBin2 = PathResolverFindCalibFile(m_MVAreaderFile_MuTagIMO_etaBin2);
                    TString weightPath_MuTagIMO_etaBin3 = PathResolverFindCalibFile(m_MVAreaderFile_MuTagIMO_etaBin3);
 
                    auto make_mva_reader_MuTagIMO = [](TString file_path, bool useSeg2ChamberIndex) {
                        std::vector<std::string> mva_var_names;
                        if (useSeg2ChamberIndex) mva_var_names.push_back("muonSeg2ChamberIndex");
                        mva_var_names.push_back("muonSeg1ChamberIndex");
                        mva_var_names.push_back("muonSeg1NPrecisionHits");
                        mva_var_names.push_back("muonSegmentDeltaEta");
                        mva_var_names.push_back("muonSeg1GlobalR");
                        mva_var_names.push_back("muonSeg1Chi2OverDoF");
                        mva_var_names.push_back("muonSCS");
 
                        std::unique_ptr<TMVA::Reader> reader = std::make_unique<TMVA::Reader>(mva_var_names);
                        reader->BookMVA("BDT", file_path);
                        return reader;
                    };
 
                    m_reader_MUTAGIMO_etaBin1 = make_mva_reader_MuTagIMO(weightPath_MuTagIMO_etaBin1, false);
                    m_reader_MUTAGIMO_etaBin2 = make_mva_reader_MuTagIMO(weightPath_MuTagIMO_etaBin2, false);
                    m_reader_MUTAGIMO_etaBin3 = make_mva_reader_MuTagIMO(weightPath_MuTagIMO_etaBin3, true);
                }
            }
        }
        
        ATH_MSG_INFO("TightNNScore calculation is " << (m_calculateTightNNScore ? "enabled." : "disabled."));
 
        if (m_calculateTightNNScore) {
            if (m_onnxTool.empty()) {
                ATH_MSG_ERROR("Cannot calculate TightNNScore: ONNX tool not configured! "
                            "Please set the ORTInferenceTool property to a valid AthOnnx::OnnxRuntimeInferenceTool instance.");
                return StatusCode::FAILURE;
            }
 
            ATH_MSG_INFO("Retrieving ONNX tool: " << m_onnxTool.name());
            ATH_CHECK(m_onnxTool.retrieve());
        } else ATH_MSG_INFO("ONNX tool not configured — skipping retrieval.");
 
        ATH_MSG_INFO("Finished ONNX tool setup");
        
        ATH_CHECK(m_eventInfo.initialize());
        // Return gracefully:
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isBadMuon()

bool CP::MuonSelectionTool::isBadMuon ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if a CB muon fails some loose quaility requirements designed to remove pathological tracks.

Implements CP::IMuonSelectionTool.

Definition at line 684 of file MuonSelectionTool.cxx.

                                                              {
        if (mu.muonType() != xAOD::Muon::Combined) return false;
        // ::
        const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
        const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
        const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
        // ::
        // Some spurious muons are found to have negative ME track fit covariance, and are typically poorly reconstructed
        if (metrack && metrack->definingParametersCovMatrix()(4, 4) < 0.0) return true;
        // ::
        bool IsBadMuon = false;
        if (idtrack && metrack && cbtrack) {
            // ::
            double qOverP_ID = idtrack->qOverP();
            double qOverPerr_ID = std::sqrt(idtrack->definingParametersCovMatrix()(4, 4));
            double qOverP_ME = metrack->qOverP();
            double qOverPerr_ME = std::sqrt(metrack->definingParametersCovMatrix()(4, 4));
            double qOverP_CB = cbtrack->qOverP();
            double qOverPerr_CB = std::sqrt(cbtrack->definingParametersCovMatrix()(4, 4));
            // ::
            if (m_quality == 4) {
                // recipe for high-pt selection
                IsBadMuon = !passedErrorCutCB(mu);
 
                hitSummary summary{};
                fillSummary(mu, summary);
 
                // temporarily apply same recipe as for other working points in addition to CB error
                // cut for 2-station muons, pending better treatment of ID/MS misalignments
                if (m_use2stationMuonsHighPt && summary.nprecisionLayers == 2) {
                    double IdCbRatio = std::abs((qOverPerr_ID / qOverP_ID) / (qOverPerr_CB / qOverP_CB));
                    double MeCbRatio = std::abs((qOverPerr_ME / qOverP_ME) / (qOverPerr_CB / qOverP_CB));
                    IsBadMuon = (IdCbRatio < 0.8 || MeCbRatio < 0.8 || IsBadMuon);
                }
            } else {
                // recipe for other WP
                double IdCbRatio = std::abs((qOverPerr_ID / qOverP_ID) / (qOverPerr_CB / qOverP_CB));
                double MeCbRatio = std::abs((qOverPerr_ME / qOverP_ME) / (qOverPerr_CB / qOverP_CB));
                IsBadMuon = (IdCbRatio < 0.8 || MeCbRatio < 0.8);
            }
        } else {
            return true;
        }
        return IsBadMuon;
    }

isBEE()

bool CP::MuonSelectionTool::isBEE	(	const float	eta,
		const float	phi ) const

Check if muon eta/phi falls in BEE chambers.

Definition at line 1840 of file MuonSelectionTool.cxx.

                                                                        {
        static constexpr std::array<float, 2> BEE_eta{1.440, 1.692};
        static constexpr std::array<float, 8> BEE_phi{0.301, 0.478, 1.086, 1.263, 1.872, 2.049, 2.657, 2.834};
 
        float abs_eta = std::abs(eta);
        float abs_phi = std::abs(phi);
 
        if (abs_eta >= BEE_eta[0] && abs_eta <= BEE_eta[1]) {
            if ((abs_phi >= BEE_phi[0] && abs_phi <= BEE_phi[1]) || (abs_phi >= BEE_phi[2] && abs_phi <= BEE_phi[3]) ||
                (abs_phi >= BEE_phi[4] && abs_phi <= BEE_phi[5]) || (abs_phi >= BEE_phi[6] && abs_phi <= BEE_phi[7])) {
                return true;
            }
        }
 
        return false;
    }

isBIS78()

bool CP::MuonSelectionTool::isBIS78	(	const float	eta,
		const float	phi ) const

Check if muon eta/phi falls in BIS7/8 chambers.

Definition at line 1822 of file MuonSelectionTool.cxx.

                                                                          {
        static constexpr std::array<float, 2> BIS78_eta{1.05, 1.3};
        static constexpr std::array<float, 8> BIS78_phi{0.21, 0.57, 1.00, 1.33, 1.78, 2.14, 2.57, 2.93};
 
        float abs_eta = std::abs(eta);
        float abs_phi = std::abs(phi);
 
        if (abs_eta >= BIS78_eta[0] && abs_eta <= BIS78_eta[1]) {
            if ((abs_phi >= BIS78_phi[0] && abs_phi <= BIS78_phi[1]) || (abs_phi >= BIS78_phi[2] && abs_phi <= BIS78_phi[3]) ||
                (abs_phi >= BIS78_phi[4] && abs_phi <= BIS78_phi[5]) || (abs_phi >= BIS78_phi[6] && abs_phi <= BIS78_phi[7])) {
                return true;
            }
        }
 
        return false;
    }

isBMG()

bool CP::MuonSelectionTool::isBMG	(	const float	eta,
		const float	phi ) const

Check if muon eta/phi falls in BMG chambers.

Definition at line 1858 of file MuonSelectionTool.cxx.

                                                                        {
        static constexpr std::array<float, 6> BMG_eta{0.35, 0.47, 0.68, 0.80, 0.925, 1.04};
        static constexpr std::array<float, 4> BMG_phi{-1.93, -1.765, -1.38, -1.21};
 
        float abs_eta = std::abs(eta);
 
        if ((abs_eta >= BMG_eta[0] && abs_eta <= BMG_eta[1]) || (abs_eta >= BMG_eta[2] && abs_eta <= BMG_eta[3]) ||
            (abs_eta >= BMG_eta[4] && abs_eta <= BMG_eta[5])) {
            if ((phi >= BMG_phi[0] && phi <= BMG_phi[1]) || (phi >= BMG_phi[2] && phi <= BMG_phi[3])) { return true; }
        }
 
        return false;
    }

isRun3()

bool CP::MuonSelectionTool::isRun3 ( bool forceOnTheFly = false ) const

inlineprivate

Definition at line 291 of file MuonSelectionTool.h.

                                                      {
          if (!m_geoOnTheFly && !forceOnTheFly) return m_isRun3;
          int rn = getRunNumber(true);
          return rn>=399999;
        }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

passedBMVmimicCut()

bool CP::MuonSelectionTool::passedBMVmimicCut ( const xAOD::Muon & mu ) const

private

Returns true if the muon passes a cut which mimics the effect of the combined error cut This is necessary only when the resolution is very optimistic in the MC such that a large smearing is applied.

Definition at line 1433 of file MuonSelectionTool.cxx.

                                                                      {
        TF1* cutFunction;
        double p1, p2;
        if (std::abs(mu.eta()) < 1.05) {
            cutFunction = m_BMVcutFunction_barrel.get();
            p1 = 0.066265;
            p2 = 0.000210047;
        } else {
            cutFunction = m_BMVcutFunction_endcap.get();
            p1 = 0.0629747;
            p2 = 0.000196466;
        }
 
        double qOpRelResolution = std::hypot(p1, p2 * mu.primaryTrackParticle()->pt() * MeVtoGeV);
 
        double qOverPabs_unsmeared = std::abs(mu.primaryTrackParticle()->definingParameters()[4]);
        double qOverPabs_smeared = 1.0 / (mu.pt() * std::cosh(mu.eta()));
 
        if ((qOverPabs_smeared - qOverPabs_unsmeared) / (qOpRelResolution * qOverPabs_unsmeared) <
            cutFunction->Eval(mu.primaryTrackParticle()->pt() * MeVtoGeV))
            return false;
        else
            return true;
    }

passedCaloScore()

bool CP::MuonSelectionTool::passedCaloScore ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if the muon passed the CaloScore calo-tag working point.

Implements CP::IMuonSelectionTool.

Definition at line 1530 of file MuonSelectionTool.cxx.

                                                                    {
        // We use a working point with a pT-dependent cut on the NN discriminant, designed to achieve a constant
        // fakes rejection as function of pT in Z->mumu MC
 
        // Extract the relevant score variable (NN discriminant)
       
        float CaloMuonScore{-999.0};
        retrieveParam(mu, CaloMuonScore, xAOD::Muon::CaloMuonScore);
        
        if(m_caloScoreWP==1) return (CaloMuonScore >= 0.92);
        if(m_caloScoreWP==2) return (CaloMuonScore >= 0.56);
        else if(m_caloScoreWP==3 || m_caloScoreWP==4)
        {
          // Cut on the score variable
          float pT = mu.pt() * MeVtoGeV;  // GeV
 
          if (pT > 20.0)  // constant cut above 20 GeV
              return (CaloMuonScore >= 0.77);
          else {
              // pT-dependent cut below 20 GeV
              // The pT-dependent cut is based on a fit of a third-degree polynomial, with coefficients as given below
              
              if(m_caloScoreWP==3) return (CaloMuonScore >= (-1.98e-4 * std::pow(pT, 3) +6.04e-3 * std::pow(pT, 2) -6.13e-2 * pT + 1.16));
              if(m_caloScoreWP==4) return (CaloMuonScore >= (-1.80e-4 * std::pow(pT, 3) +5.02e-3 * std::pow(pT, 2) -4.62e-2 * pT + 1.12));
          }
        }
        
        return false;
    }

passedCaloTagQuality()

bool CP::MuonSelectionTool::passedCaloTagQuality ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if the muon passed additional calo-tag quality cuts.

Implements CP::IMuonSelectionTool.

Definition at line 1509 of file MuonSelectionTool.cxx.

                                                                         {
        // Use CaloScore variable based on Neural Network if enabled
        // The neural network is only trained until eta = 1 
        // cf. https://cds.cern.ch/record/2802605/files/CERN-THESIS-2021-290.pdf
        constexpr float eta_range = 1.;
        if (std::abs(mu.eta()) < eta_range && m_useCaloScore) return passedCaloScore(mu);
 
        // Otherwise we use CaloMuonIDTag
        int CaloMuonIDTag = -20;
 
        // Extract CaloMuonIDTag variable
        bool readID = mu.parameter(CaloMuonIDTag, xAOD::Muon::CaloMuonIDTag);
        if (!readID) {
            ATH_MSG_WARNING("Unable to read CaloMuonIDTag Quality information! Rejecting the CALO muon!");
            return false;
        }
 
        // Cut on CaloMuonIDTag variable
        return (CaloMuonIDTag > 10);
    }

passedErrorCutCB()

bool CP::MuonSelectionTool::passedErrorCutCB ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if a CB muon passes a pt- and eta-dependent cut on the relative CB q/p error.

Implements CP::IMuonSelectionTool.

Definition at line 1328 of file MuonSelectionTool.cxx.

                                                                     {
        // ::
        if (mu.muonType() != xAOD::Muon::Combined) return false;
        // ::
        double start_cut = 3.0;
        double end_cut = 1.6;
        double abs_eta = std::abs(mu.eta());
        
        // parametrization of expected q/p error as function of pT
        double p0(8.0), p1(0.), p2(0.);
        if(isRun3()) //MC21 optimization
        {
          if(abs_eta<=1.05){
              p1=0.046;
              p2=0.00005;
          }
          else if (abs_eta > 1.05 && abs_eta <= 1.3) {
              p1 = 0.052;
              p2 = 0.00008;
          } else if (abs_eta > 1.3 && abs_eta <= 1.7) {
              p1 = 0.068;
              p2 = 0.00006;
          } else if (abs_eta > 1.7 && abs_eta <= 2.0) {
              p1 = 0.048;
              p2 = 0.00006;
          } else if (abs_eta > 2.0) {
              p1 = 0.037;
              p2 = 0.00006;
          }
        }
        else
        {
          if(abs_eta<=1.05){
              p1=0.039;
              p2=0.00006;
          }
          else if (abs_eta > 1.05 && abs_eta <= 1.3) {
              p1 = 0.040;
              p2 = 0.00009;
          } else if (abs_eta > 1.3 && abs_eta <= 1.7) {
              p1 = 0.056;
              p2 = 0.00008;
          } else if (abs_eta > 1.7 && abs_eta <= 2.0) {
              p1 = 0.041;
              p2 = 0.00006;
          } else if (abs_eta > 2.0) {
              p1 = 0.031;
              p2 = 0.00006;
          }
        }
        // ::
        hitSummary summary{};
        fillSummary(mu, summary);
 
        // independent parametrization for 2-station muons
        if (m_use2stationMuonsHighPt && summary.nprecisionLayers == 2) {
            start_cut = 1.1;
            end_cut=0.7; 
            p1 = 0.0739568;
            p2 = 0.00012443;
            if (abs_eta > 1.05 && abs_eta < 1.3) {
                p1 = 0.0674484;
                p2 = 0.000119879;
            } else if (abs_eta >= 1.3 && abs_eta < 1.7) {
                p1 = 0.041669;
                p2 = 0.000178349;
            } else if (abs_eta >= 1.7 && abs_eta < 2.0) {
                p1 = 0.0488664;
                p2 = 0.000137648;
            } else if (abs_eta >= 2.0) {
                p1 = 0.028077;
                p2 = 0.000152707;
            }
        }
        // ::
        bool passErrorCutCB = false;
        const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
        if (cbtrack) {
            // ::
            double pt_CB = (cbtrack->pt() * MeVtoGeV < 5000.) ? cbtrack->pt() * MeVtoGeV : 5000.;  // GeV
            double qOverP_CB = cbtrack->qOverP();
            double qOverPerr_CB = std::sqrt(cbtrack->definingParametersCovMatrix()(4, 4));
            // sigma represents the average expected error at the muon's pt/eta
            double sigma = std::sqrt(std::pow(p0 / pt_CB, 2) + std::pow(p1, 2) + std::pow(p2 * pt_CB, 2));
            // cutting at start_cut*sigma for pt <=1 TeV depending on eta region,
            // then linearly tightening until end_cut*sigma is reached at pt >= 5TeV.
            double a = (end_cut - start_cut) / 4000.0;
            double b = end_cut - a * 5000.0;
            double coefficient = (pt_CB > 1000.) ? (a * pt_CB + b) : start_cut;
            if (std::abs(qOverPerr_CB / qOverP_CB) < coefficient * sigma) { passErrorCutCB = true; }
        }
        // ::
        if (m_use2stationMuonsHighPt && m_doBadMuonVetoMimic && summary.nprecisionLayers == 2) {
            SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
 
            if (eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
                ATH_MSG_DEBUG("The current event is a MC event. Use bad muon veto mimic.");
                return passErrorCutCB && passedBMVmimicCut(mu);
            }
        }
 
        // ::
        return passErrorCutCB;
    }

passedHighPtCuts()

bool CP::MuonSelectionTool::passedHighPtCuts ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if the muon passes the standard MCP High Pt cuts.

Implements CP::IMuonSelectionTool.

Definition at line 1150 of file MuonSelectionTool.cxx.

                                                                     {
        ATH_MSG_VERBOSE("Checking whether muon passes high-pT selection...");
 
        // :: Request combined muons
        if (mu.muonType() != xAOD::Muon::Combined) {
            ATH_MSG_VERBOSE("Muon is not combined - fail high-pT");
            return false;
        }
        if (mu.author() == xAOD::Muon::STACO) {
            ATH_MSG_VERBOSE("Muon is STACO - fail high-pT");
            return false;
        }
 
        // :: Reject muons with out-of-bounds hits
        uint8_t combinedTrackOutBoundsPrecisionHits{0};
        retrieveSummaryValue(mu, combinedTrackOutBoundsPrecisionHits, xAOD::MuonSummaryType::combinedTrackOutBoundsPrecisionHits);
        if (combinedTrackOutBoundsPrecisionHits > 0) {
            ATH_MSG_VERBOSE("Muon has out-of-bounds precision hits - fail high-pT");
            return false;
        }
 
        // :: Access MS hits information
        hitSummary summary{};
        fillSummary(mu, summary);
        
        
        ATH_MSG_VERBOSE("number of precision layers: " << (int)summary.nprecisionLayers);
 
        //::: Apply MS Chamber Vetoes
        // Given according to their eta-phi locations in the muon spectrometer
        // FORM: CHAMBERNAME[ array of four values ] = { eta 1, eta 2, phi 1, phi 2}
        // The vetoes are applied based on the MS track if available. If the MS track is not available,
        // the vetoes are applied according to the combined track, and runtime warning is printed to
        // the command line.
        const xAOD::TrackParticle* CB_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
        const xAOD::TrackParticle* MS_track = mu.trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
        if (!MS_track) {
            ATH_MSG_VERBOSE("passedHighPtCuts - No MS track available for muon. Using combined track.");
            MS_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
        }
 
        if (MS_track && CB_track) {
            float etaMS = MS_track->eta();
            float phiMS = MS_track->phi();
            float etaCB = CB_track->eta();
 
            //::: no unspoiled clusters in CSC
            if (!isRun3() && (std::abs(etaMS) > 2.0 || std::abs(etaCB) > 2.0)) {
                if (summary.cscUnspoiledEtaHits == 0) {
                    ATH_MSG_VERBOSE("Muon has only spoiled CSC clusters - fail high-pT");
                    return false;
                }
            }
 
            // veto bad CSC giving troubles with scale factors
            if (!isRun3() && mu.eta() < -1.899 && std::abs(mu.phi()) < 0.211) {
                ATH_MSG_VERBOSE("Muon is in eta/phi region vetoed due to disabled chambers in MC - fail high-pT");
                return false;
            }
 
            //::: Barrel/Endcap overlap region
            if ((1.01 < std::abs(etaMS) && std::abs(etaMS) < 1.1) || (1.01 < std::abs(etaCB) && std::abs(etaCB) < 1.1)) {
                ATH_MSG_VERBOSE("Muon is in barrel/endcap overlap region - fail high-pT");
                return false;
            }
 
            //::: BIS78
            if (isBIS78(etaMS, phiMS)) {
                if (!isRun3() || !m_useBEEBISInHighPtRun3) {
                    ATH_MSG_VERBOSE("Muon is in BIS7/8 eta/phi region - fail high-pT");
                    return false;
                }   
            }
            
            //if (getRunNumber(true) >= 324320) {
                //if (isBMG(etaMS, phiMS)) {
                    //ATH_MSG_VERBOSE("Muon is in BMG eta/phi region - fail high-pT");
                    //return false;
                //}
            //}
 
            //::: BEE
            if (isBEE(etaMS, phiMS)) {
                // in Run3, large mis-alignment on the BEE chamber was found. temporarily mask the BEE region
                if (isRun3() && !m_useBEEBISInHighPtRun3) {
                    ATH_MSG_VERBOSE("Muon is in BEE eta/phi region - fail high-pT");
                    return false;
                }
                // Muon falls in the BEE eta-phi region: asking for 4 good precision layers
                // if( nGoodPrecLayers < 4 ) return false; // postponed (further studies needed)
                if (summary.nprecisionLayers < 4) {
                    ATH_MSG_VERBOSE("Muon is in BEE eta/phi region and does not have 4 precision layers - fail high-pT");
                    return false;
                }
            }
            if (std::abs(etaCB) > 1.4) {
                // Veto residual 3-station muons in BEE region due to MS eta/phi resolution effects
                // if( nGoodPrecLayers<4 && (extendedSmallHits>0||extendedSmallHoles>0) ) return false; // postponed (further studies
                // needed)
                if (summary.nprecisionLayers < 4 && (summary.extendedSmallHits > 0 || summary.extendedSmallHoles > 0)) {
                    ATH_MSG_VERBOSE("Muon is in BEE eta/phi region and does not have 4 precision layers - fail high-pT");
                    return false;
                }
            }
        } else {
            ATH_MSG_WARNING("passedHighPtCuts - MS or CB track missing in muon! Failing High-pT selection...");
            return false;
        }
 
        //::: Apply 1/p significance cut
        const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
        const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
        if (idtrack && metrack && metrack->definingParametersCovMatrix()(4, 4) > 0) {            const float qOverPsignif = qOverPsignificance(mu);
 
            ATH_MSG_VERBOSE("qOverP significance: " << qOverPsignif);
 
            if (std::abs(qOverPsignif) > 7) {
                ATH_MSG_VERBOSE("Muon failed qOverP significance cut");
                return false;
            }
        } else {
            ATH_MSG_VERBOSE("Muon missing ID or ME tracks - fail high-pT");
            return false;
        }
 
        // Accept good 2-station muons if the user has opted to include these
        if (m_use2stationMuonsHighPt && summary.nprecisionLayers == 2) {
            // should not accept EM+EO muons due to ID/MS alignment issues
            if (std::abs(mu.eta()) > 1.2 && summary.extendedSmallHits < 3 && summary.extendedLargeHits < 3) {
                ATH_MSG_VERBOSE("2-station muon with EM+EO - fail high-pT");
                return false;
            }
 
            // only select muons missing the inner precision layer
            // apply strict veto on overlap between small and large sectors
 
            if (summary.innerLargeHits == 0 && summary.middleLargeHits == 0 && summary.outerLargeHits == 0 &&
                summary.extendedLargeHits == 0 && summary.middleSmallHits > 2 &&
                (summary.outerSmallHits > 2 || summary.extendedSmallHits > 2)) {
                ATH_MSG_VERBOSE("Accepted 2-station muon in small sector");
                return true;
            }
 
            if (summary.innerSmallHits == 0 && summary.middleSmallHits == 0 && summary.outerSmallHits == 0 &&
                summary.extendedSmallHits == 0 && summary.middleLargeHits > 2 &&
                (summary.outerLargeHits > 2 || summary.extendedLargeHits > 2)) {
                ATH_MSG_VERBOSE("Accepted 2-station muon in large sector");
                return true;
            }
        }
 
        //::: Require 3 (good) station muons
        if (summary.nprecisionLayers < 3) {
            ATH_MSG_VERBOSE("Muon has less than 3 precision layers - fail high-pT");
            return false;
        }
 
        // Remove 3-station muons with small-large sectors overlap
        if (summary.isSmallGoodSectors) {
            if (!(summary.innerSmallHits > 2 && summary.middleSmallHits > 2 &&
                  (summary.outerSmallHits > 2 || summary.extendedSmallHits > 2))) {
                ATH_MSG_VERBOSE("Muon has small/large sectors overlap - fail high-pT");
                return false;
            }
        } else {
            if (!(summary.innerLargeHits > 2 && summary.middleLargeHits > 2 &&
                  (summary.outerLargeHits > 2 || summary.extendedLargeHits > 2))) {
                ATH_MSG_VERBOSE("Muon has small/large sectors overlap - fail high-pT");
                return false;
            }
        }
 
        ATH_MSG_VERBOSE("Muon passed high-pT selection");
        return true;
    }

passedIDCuts() [1/2]

bool CP::MuonSelectionTool::passedIDCuts ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if the muon passes the standard MCP ID cuts.

No ID cuts should be applied on LRT muons, so always set this flag to true.

If the isLRT decor is not available, try to see if patternRecoInfo is available for the corresponding ID track.

All LRT muons should have ID tracks. The muons without ID tracks have to come from the standard muon container.

Implements CP::IMuonSelectionTool.

Definition at line 649 of file MuonSelectionTool.cxx.

                                                                 {
        if (m_useLRT) {
            static const SG::AuxElement::Accessor<char> isLRTmuon("isLRT");
            if (isLRTmuon.isAvailable(mu)) {
                if (isLRTmuon(mu)) return true; 
            }
            else { 
                static const SG::AuxElement::Accessor<uint64_t> patternAcc("patternRecoInfo");
                const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
                if(idtrack) { 
                    if(!patternAcc.isAvailable(*idtrack)) {
                        ATH_MSG_FATAL("No information available to tell if the muon is LRT or standard. Either run MuonLRTMergingAlg to decorate with `isLRT` flag, or supply the patternRecoInfo for the original ID track.");
                        throw std::runtime_error("MuonSelectionTool() - isLRT decor and patternRecoInfo both unavailable for a muon.");
                    }
                    std::bitset<xAOD::NumberOfTrackRecoInfo> patternBitSet(patternAcc(*idtrack));
                    if (patternBitSet.test(xAOD::SiSpacePointsSeedMaker_LargeD0)) return true;
                }
            }
        }
        // do not apply the ID hit requirements for SA muons for |eta| > 2.5
        if (mu.author() == xAOD::Muon::MuidSA && std::abs(mu.eta()) > 2.5) {
            return true;
        } else if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
            const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
            if (cbtrack && std::abs(cbtrack->eta()) > 2.5) { return true; }
            return false;
        } else {
            if (mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle))
                return passedIDCuts(*mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle));
            else if (mu.primaryTrackParticle())
                return passedIDCuts(*mu.primaryTrackParticle());
        }
        return false;
    }

passedIDCuts() [2/2]

virtual bool CP::MuonSelectionTool::passedIDCuts ( const xAOD::TrackParticle & ) const

overridevirtual

Returns true if the track particle passes the standard MCP ID cuts.

Implements CP::IMuonSelectionTool.

passedLowPtEfficiencyCuts() [1/2]

bool CP::MuonSelectionTool::passedLowPtEfficiencyCuts ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if the muon passes the standard MCP low pt cuts.

To set the value on the muon, instead call setPassesLowPtEfficiencyCuts(xAOD::Muon&) const

Implements CP::IMuonSelectionTool.

Definition at line 730 of file MuonSelectionTool.cxx.

                                                                              {
        xAOD::Muon::Quality thisMu_quality = getQuality(mu);
        return passedLowPtEfficiencyCuts(mu, thisMu_quality);
    }

passedLowPtEfficiencyCuts() [2/2]

bool CP::MuonSelectionTool::passedLowPtEfficiencyCuts ( const xAOD::Muon & mu, xAOD::Muon::Quality thisMu_quality ) const

overridevirtual

Implements CP::IMuonSelectionTool.

Definition at line 735 of file MuonSelectionTool.cxx.

                                                                                                              {
        ATH_MSG_VERBOSE("Checking whether muon passes low-pT selection...");
        
        if (!m_useAllAuthors) {  // no allAuthors, always fail the WP
            ATH_MSG_VERBOSE("Do not have allAuthors variable - fail low-pT");
            return false;
        }
 
        // requiring combined muons, unless segment-tags are included
        if (!m_useSegmentTaggedLowPt) {
            if (mu.muonType() != xAOD::Muon::Combined) {
                ATH_MSG_VERBOSE("Muon is not combined - fail low-pT");
                return false;
            }
        } else {
            if (mu.muonType() != xAOD::Muon::Combined && mu.muonType() != xAOD::Muon::SegmentTagged) {
                ATH_MSG_VERBOSE("Muon is not combined or segment-tagged - fail low-pT");
                return false;
            }
        }
 
        // author check
        if (!m_useSegmentTaggedLowPt) {
            if (mu.author() != xAOD::Muon::MuGirl && mu.author() != xAOD::Muon::MuidCo) {
                ATH_MSG_VERBOSE("Muon is neither MuGirl nor MuidCo - fail low-pT");
                return false;
            }
        } else {
            if (mu.author() != xAOD::Muon::MuGirl && mu.author() != xAOD::Muon::MuidCo && mu.author() != xAOD::Muon::MuTagIMO) {
                ATH_MSG_VERBOSE("Muon is neither MuGirl / MuidCo / MuTagIMO - fail low-pT");
                return false;
            }
        }
 
        // applying Medium selection above pT = 18 GeV
        if (mu.pt() * MeVtoGeV > 18.) {
            ATH_MSG_VERBOSE("pT > 18 GeV - apply medium selection");
            if (thisMu_quality <= xAOD::Muon::Medium) {
                ATH_MSG_VERBOSE("Muon passed low-pT selection");
                return true;
            } else {
                ATH_MSG_VERBOSE("Muon failed low-pT selection");
                return false;
            }
        }
 
        // requiring Medium in forward regions
        if (!m_useMVALowPt && std::abs(mu.eta()) > 1.55 && thisMu_quality > xAOD::Muon::Medium) {
            ATH_MSG_VERBOSE("Not using MVA selection, failing low-pT selection due to medium requirement in forward region");
            return false;
        }
 
        // rejection of muons with out-of-bounds hits
        uint8_t combinedTrackOutBoundsPrecisionHits{0};
        retrieveSummaryValue(mu, combinedTrackOutBoundsPrecisionHits, xAOD::MuonSummaryType::combinedTrackOutBoundsPrecisionHits);
        if (combinedTrackOutBoundsPrecisionHits > 0) {
            ATH_MSG_VERBOSE("Muon has out-of-bounds precision hits - fail low-pT");
            return false;
        }
 
        // requiring explicitely >=1 station (2 in the |eta|>1.3 region when Medium selection is not explicitely required)
        if (mu.muonType() == xAOD::Muon::Combined) {
            hitSummary summary{};
            fillSummary(mu, summary);
            uint nStationsCut = (std::abs(mu.eta()) > 1.3 && std::abs(mu.eta()) < 1.55) ? 2 : 1;
            if (summary.nprecisionLayers < nStationsCut) {
                ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers << " is lower than cut value " << nStationsCut
                                                                << " - fail low-pT");
                return false;
            }
        }
 
        // reject MuGirl muon if not found also by MuTagIMO
        if (m_useAllAuthors) {
            if (mu.author() == xAOD::Muon::MuGirl && !mu.isAuthor(xAOD::Muon::MuTagIMO)) {
                ATH_MSG_VERBOSE("MuGirl muon is not confirmed by MuTagIMO - fail low-pT");
                return false;
            }
        } else
            return false;
 
        if (m_useMVALowPt) {
            if (isRun3()) {
                ATH_MSG_VERBOSE("Applying Run-3 MVA-based selection");
                return passedLowPtEfficiencyMVACutRun3(mu);
            } else {
                ATH_MSG_VERBOSE("Applying Run-2 MVA-based selection");
                return passedLowPtEfficiencyMVACut(mu);
            }
            
        }
 
        ATH_MSG_VERBOSE("Applying cut-based selection");
 
        // apply some loose quality requirements
        float momentumBalanceSignificance{0.}, scatteringCurvatureSignificance{0.}, scatteringNeighbourSignificance{0.};
 
        retrieveParam(mu, momentumBalanceSignificance, xAOD::Muon::momentumBalanceSignificance);
        retrieveParam(mu, scatteringCurvatureSignificance, xAOD::Muon::scatteringCurvatureSignificance);
        retrieveParam(mu, scatteringNeighbourSignificance, xAOD::Muon::scatteringNeighbourSignificance);
 
        ATH_MSG_VERBOSE("momentum balance significance: " << momentumBalanceSignificance);
        ATH_MSG_VERBOSE("scattering curvature significance: " << scatteringCurvatureSignificance);
        ATH_MSG_VERBOSE("scattering neighbour significance: " << scatteringNeighbourSignificance);
 
        if (std::abs(momentumBalanceSignificance) > 3. || std::abs(scatteringCurvatureSignificance) > 3. ||
            std::abs(scatteringNeighbourSignificance) > 3.) {
            ATH_MSG_VERBOSE("Muon failed cut-based low-pT selection");
            return false;
        }
 
        // passed low pt selection
        ATH_MSG_VERBOSE("Muon passed cut-based low-pT selection");
        return true;
    }

passedLowPtEfficiencyMVACut()

bool CP::MuonSelectionTool::passedLowPtEfficiencyMVACut ( const xAOD::Muon & mu ) const

private

Definition at line 867 of file MuonSelectionTool.cxx.

                                                                                {
        //LowPt Not supported in run3 for the time being
        if(isRun3() && !m_developMode){
            ATH_MSG_VERBOSE("LowPt WP currently not supported for run3 if not in expert mode");
            return false;
        }
        if (!m_useMVALowPt) {
            ATH_MSG_DEBUG("Low pt MVA disabled. Return... ");
            return false;
        }
        std::lock_guard<std::mutex> guard(m_low_pt_mva_mutex);
        // set values for all BDT input variables from the muon in question
        float momentumBalanceSig{-1}, CurvatureSig{-1}, energyLoss{-1}, muonSegmentDeltaEta{-1}, scatteringNeigbour{-1};
        retrieveParam(mu, momentumBalanceSig, xAOD::Muon::momentumBalanceSignificance);
        retrieveParam(mu, CurvatureSig, xAOD::Muon::scatteringCurvatureSignificance);
        retrieveParam(mu, scatteringNeigbour, xAOD::Muon::scatteringNeighbourSignificance);
        retrieveParam(mu, energyLoss, xAOD::Muon::EnergyLoss);
        retrieveParam(mu, muonSegmentDeltaEta, xAOD::Muon::segmentDeltaEta);      
 
        uint8_t middleSmallHoles{0}, middleLargeHoles{0};
        retrieveSummaryValue(mu, middleSmallHoles, xAOD::MuonSummaryType::middleSmallHoles);
        retrieveSummaryValue(mu, middleLargeHoles, xAOD::MuonSummaryType::middleLargeHoles);
 
        float seg1ChamberIdx{-1.}, seg2ChamberIdx{-1.}, middleHoles{-1.}, seg1NPrecisionHits{-1.}, seg1GlobalR{-1.}, seg1Chi2OverDoF{-1.};
 
        std::vector<const xAOD::MuonSegment*> muonSegments = getSegmentsSorted(mu);
 
        if (mu.author() == xAOD::Muon::MuTagIMO && muonSegments.size() == 0)
            ATH_MSG_WARNING("passedLowPtEfficiencyMVACut - found segment-tagged muon with no segments!");
 
        using namespace Muon::MuonStationIndex;
        seg1ChamberIdx = (!muonSegments.empty())   ? toInt(muonSegments[0]->chamberIndex()) : -9;
        seg2ChamberIdx = (muonSegments.size() > 1) ? toInt(muonSegments[1]->chamberIndex()) : -9;
 
        // these variables are only used for MuTagIMO
        if (mu.author() == xAOD::Muon::MuTagIMO) {
            seg1NPrecisionHits = (!muonSegments.empty()) ? muonSegments[0]->nPrecisionHits() : -1;
            seg1GlobalR = (!muonSegments.empty())
                              ? std::hypot(muonSegments[0]->x(), muonSegments[0]->y(), muonSegments[0]->z())
                              : 0;
            seg1Chi2OverDoF = (!muonSegments.empty()) ? muonSegments[0]->chiSquared() / muonSegments[0]->numberDoF() : -1;
        }
 
        middleHoles = middleSmallHoles + middleLargeHoles;
 
        // get event number from event info
        SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
    //overwrite event number
    unsigned long long eventNumber = 0;
        if(m_expertMode_EvtNumber.value()!=0) eventNumber=m_expertMode_EvtNumber.value();
        else eventNumber = eventInfo->eventNumber();
    
        // variables for the BDT
        std::vector<float> var_vector;
        if (mu.author() == xAOD::Muon::MuidCo || mu.author() == xAOD::Muon::MuGirl) {
            var_vector = {momentumBalanceSig, CurvatureSig,        scatteringNeigbour, energyLoss,
                          middleHoles,        muonSegmentDeltaEta, seg1ChamberIdx,     seg2ChamberIdx};
        } else {
            if (std::abs(mu.eta()) >= 1.3)
                var_vector = {seg2ChamberIdx, seg1ChamberIdx,  seg1NPrecisionHits,    muonSegmentDeltaEta,
                              seg1GlobalR,    seg1Chi2OverDoF, std::abs(CurvatureSig)};
            else
                var_vector = {seg1ChamberIdx, seg1NPrecisionHits, muonSegmentDeltaEta,
                              seg1GlobalR,    seg1Chi2OverDoF,    std::abs(CurvatureSig)};
        }
 
        // use different trainings for even/odd numbered events
        TMVA::Reader *reader_MUID, *reader_MUGIRL;
        if (eventNumber % 2 == 1) {
            reader_MUID = m_readerE_MUID.get();
            reader_MUGIRL = m_readerE_MUGIRL.get();
        } else {
            reader_MUID = m_readerO_MUID.get();
            reader_MUGIRL = m_readerO_MUGIRL.get();
        }
 
        // BDT for MuTagIMO is binned in |eta|
        TMVA::Reader* reader_MUTAGIMO;
        if (std::abs(mu.eta()) < 0.7)
            reader_MUTAGIMO = m_reader_MUTAGIMO_etaBin1.get();
        else if (std::abs(mu.eta()) < 1.3)
            reader_MUTAGIMO = m_reader_MUTAGIMO_etaBin2.get();
        else
            reader_MUTAGIMO = m_reader_MUTAGIMO_etaBin3.get();
 
        // get the BDT discriminant response
        float BDTdiscriminant;
 
        if (mu.author() == xAOD::Muon::MuidCo)
            BDTdiscriminant = reader_MUID->EvaluateMVA(var_vector, "BDTG");
        else if (mu.author() == xAOD::Muon::MuGirl)
            BDTdiscriminant = reader_MUGIRL->EvaluateMVA(var_vector, "BDTG");
        else if (mu.author() == xAOD::Muon::MuTagIMO && m_useSegmentTaggedLowPt)
            BDTdiscriminant = reader_MUTAGIMO->EvaluateMVA(var_vector, "BDT");
        else {
            ATH_MSG_WARNING("Invalid author for low-pT MVA, failing selection...");
            return false;
        }
 
        // cut on dicriminant
        float BDTcut = (mu.author() == xAOD::Muon::MuTagIMO) ? 0.12 : -0.6;
 
        if (BDTdiscriminant > BDTcut) {
            ATH_MSG_VERBOSE("Passed low-pT MVA cut");
            return true;
        } else {
            ATH_MSG_VERBOSE("Failed low-pT MVA cut");
            return false;
        }
    }

passedLowPtEfficiencyMVACutRun3()

bool CP::MuonSelectionTool::passedLowPtEfficiencyMVACutRun3 ( const xAOD::Muon & mu ) const

private

Definition at line 978 of file MuonSelectionTool.cxx.

                                                                                    {
        if (!m_useMVALowPt) {
            ATH_MSG_DEBUG("Low pt MVA disabled. Return... ");
            return false;
        }
 
        if (mu.author() == xAOD::Muon::MuidCo) {
            ATH_MSG_VERBOSE("passedLowPtEfficiencyMVACutRun3() for MuidCO");
 
            //-- Prepare BDT input feature variables
            float momentumBalanceSig{-1}, CurvatureSig{-1}, scatteringNeigbour{-1};
            int CaloMuonIDTag{-1};
            uint8_t nPixelHits{0}, nTRTOutliers{0};
            float reducedChi2{-1};
            float etaBalanceSig{-1}, phiBalanceSig{-1};
            float seg1ChamberIdx{-1};
 
            retrieveParam(mu, momentumBalanceSig, xAOD::Muon::momentumBalanceSignificance);
            retrieveParam(mu, CurvatureSig, xAOD::Muon::scatteringCurvatureSignificance);
            retrieveParam(mu, scatteringNeigbour, xAOD::Muon::scatteringNeighbourSignificance);
 
            retrieveSummaryValue(mu, nPixelHits, xAOD::SummaryType::numberOfPixelHits);
            retrieveSummaryValue(mu, nTRTOutliers, xAOD::SummaryType::numberOfTRTOutliers);
 
            mu.parameter(CaloMuonIDTag, xAOD::Muon::CaloMuonIDTag);
 
            reducedChi2 = mu.primaryTrackParticle()->chiSquared() / mu.primaryTrackParticle()->numberDoF();
 
            const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
            const xAOD::TrackParticle* metrk = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
 
            etaBalanceSig = std::abs(idtrack->eta() - metrk->eta());
            phiBalanceSig = std::abs(idtrack->phi() - metrk->phi());
                    
            std::vector<const xAOD::MuonSegment*> muonSegments = getSegmentsSorted(mu);
            using namespace Muon::MuonStationIndex;
            seg1ChamberIdx = (!muonSegments.empty()) ? toInt(muonSegments[0]->chamberIndex()) : -9;
 
            hitSummary summary{};
            fillSummary(mu, summary);
 
            //-- Apply clipping
            etaBalanceSig = std::min(etaBalanceSig, 1.0f);
            reducedChi2 = std::min(reducedChi2, 100.0f);
            CurvatureSig = std::clamp(CurvatureSig, -10.0f, 10.0f);
            scatteringNeigbour = std::clamp(scatteringNeigbour, -10.0f, 10.0f);
 
            //-- Prepare BDT input feature variables vector
            std::vector<float> muidCO_feature_vector = {
                static_cast<float>(nPixelHits),
                static_cast<float>(nTRTOutliers),
                static_cast<float>(CaloMuonIDTag),
                static_cast<float>(mu.energyLossType()),
                etaBalanceSig,
                momentumBalanceSig,
                static_cast<float>(summary.nprecisionLayers),
                phiBalanceSig,
                reducedChi2,
                CurvatureSig,
                scatteringNeigbour,
                seg1ChamberIdx
            };
 
            //-- Apply scaling
            for (size_t j=0; j<muidCO_feature_vector.size(); ++j){
                muidCO_feature_vector[j] = (muidCO_feature_vector[j] - m_lowPtMuidCO_means[j]) / m_lowPtMuidCO_scaler[j];
            }
 
            //-- Get BDT response
            float bdt_score = m_MuidCO->GetClassification(muidCO_feature_vector);
            ATH_MSG_VERBOSE(" Low-pT MVA BDT score (MuidCo, Run-3) : " << bdt_score);
 
            //-- cut on discriminant (value motivated by study, slide 10):
            // https://indico.cern.ch/event/1639238/contributions/6896745/attachments/3208593/5714230/Run-3%20LowPt%20MVA%20WP%20Update.pdf
            float lowPtMVARun3_MuidCO_cut_value = 0.1300;
            return (bdt_score > lowPtMVARun3_MuidCO_cut_value);
            
        } else if (mu.author() == xAOD::Muon::MuGirl && mu.isAuthor(xAOD::Muon::MuTagIMO)) {
            ATH_MSG_VERBOSE("passedLowPtEfficiencyMVACutRun3() for MuGirl");
 
            //-- Prepare BDT input feature variables
            uint8_t nTRTOutliers{0}, middleClosePrecisionHits{0}, outerClosePrecisionHits{0};
            float momentumBalanceSig{-1}, seg1ChamberIdx{-1}, energyLoss{-1};
            int CaloMuonIDTag{-1};
            float reducedChi2{-1}, etaBalanceSig{-1}, phiBalanceSig{-1};
            float segmentDeltaEta{-1}, etaPrime{-1}, innerHits{-1};
            float middleHoles{-1}, nGoodPrecLayers{-1};
            float nprecisionHoleLayers{-1}, outerHoles{-1};
 
            retrieveParam(mu, momentumBalanceSig, xAOD::Muon::momentumBalanceSignificance);
            retrieveParam(mu, segmentDeltaEta, xAOD::Muon::segmentDeltaEta);
            retrieveParam(mu, energyLoss, xAOD::Muon::EnergyLoss);
 
            uint8_t middleSmallHoles{0}, middleLargeHoles{0};
            retrieveSummaryValue(mu, middleSmallHoles, xAOD::MuonSummaryType::middleSmallHoles);
            retrieveSummaryValue(mu, middleLargeHoles, xAOD::MuonSummaryType::middleLargeHoles);
            uint8_t outerSmallHoles{0}, outerLargeHoles{0};
            retrieveSummaryValue(mu, outerSmallHoles, xAOD::MuonSummaryType::outerSmallHoles);
            retrieveSummaryValue(mu, outerLargeHoles, xAOD::MuonSummaryType::outerLargeHoles);
            retrieveSummaryValue(mu, nTRTOutliers, xAOD::SummaryType::numberOfTRTOutliers);
            retrieveSummaryValue(mu, middleClosePrecisionHits, xAOD::MuonSummaryType::middleClosePrecisionHits);
            retrieveSummaryValue(mu, outerClosePrecisionHits, xAOD::MuonSummaryType::outerClosePrecisionHits);
 
            mu.parameter(CaloMuonIDTag, xAOD::Muon::CaloMuonIDTag);
 
            middleHoles = middleSmallHoles + middleLargeHoles;
            outerHoles = outerSmallHoles + outerLargeHoles;
            reducedChi2 = mu.primaryTrackParticle()->chiSquared() / mu.primaryTrackParticle()->numberDoF();
            
            const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
            const xAOD::TrackParticle* metrk = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
        
            etaBalanceSig = std::abs(idtrack->eta() - metrk->eta());
            etaPrime = std::abs((idtrack->eta() - metrk->eta())/mu.eta());
            phiBalanceSig = std::abs(idtrack->phi() - metrk->phi());
 
            std::vector<const xAOD::MuonSegment*> muonSegments = getSegmentsSorted(mu);
            using namespace Muon::MuonStationIndex;
            seg1ChamberIdx = (!muonSegments.empty())   ? toInt(muonSegments[0]->chamberIndex()) : -9;
 
            hitSummary summary{};
            fillSummary(mu, summary);
            innerHits = summary.innerSmallHits + summary.innerLargeHits;
            nGoodPrecLayers = summary.nGoodPrecLayers;
            nprecisionHoleLayers = summary.nprecisionHoleLayers;
            
            //-- Apply clipping
            etaBalanceSig = std::min(etaBalanceSig, 1.0f);
            reducedChi2 = std::min(reducedChi2, 100.0f);
            etaPrime = std::clamp(etaPrime, -10.0f, 10.0f);
 
            //-- Prepare BDT input feature variables vector
            std::vector<float> muGirl_feature_vector = {
                static_cast<float>(nTRTOutliers),
                static_cast<float>(CaloMuonIDTag),
                energyLoss,
                etaBalanceSig,
                etaPrime,
                innerHits,
                static_cast<float>(middleClosePrecisionHits),
                middleHoles,
                momentumBalanceSig,
                nGoodPrecLayers,
                nprecisionHoleLayers,
                static_cast<float>(summary.nprecisionLayers),
                static_cast<float>(outerClosePrecisionHits),
                outerHoles,
                phiBalanceSig,
                reducedChi2,
                seg1ChamberIdx,
                segmentDeltaEta
            };
 
            //-- Apply scaling
            for (size_t j=0; j<muGirl_feature_vector.size(); ++j){
                muGirl_feature_vector[j] = (muGirl_feature_vector[j] - m_lowPtMuGirl_means[j]) / m_lowPtMuGirl_scaler[j];
            }
 
            //-- Get BDT response
            float bdt_score = m_MuGirl->GetClassification(muGirl_feature_vector);
            ATH_MSG_VERBOSE(" Low-pT MVA BDT score (MuGirl, Run-3) : " << bdt_score);
 
            //-- cut on discriminant (value motivated by study, slide 11):
            // https://indico.cern.ch/event/1639238/contributions/6896745/attachments/3208593/5714230/Run-3%20LowPt%20MVA%20WP%20Update.pdf
            float lowPtMVARun3_MuGirl_cut_value = 0.1550;
            return (bdt_score > lowPtMVARun3_MuGirl_cut_value);
        } else {
            ATH_MSG_WARNING("Invalid author for low-pT MVA in Run-3, failing selection...");
            return false;
        }
    }

passedMuonCuts()

bool CP::MuonSelectionTool::passedMuonCuts ( const xAOD::Muon & mu ) const

overridevirtual

Returns true if the muon passes a standardized loose preselection.

Implements CP::IMuonSelectionTool.

Definition at line 1458 of file MuonSelectionTool.cxx.

                                                                   {
        // ::
        if (mu.muonType() == xAOD::Muon::Combined) { return mu.author() != xAOD::Muon::STACO; }
        // ::
        if (mu.muonType() == xAOD::Muon::CaloTagged && std::abs(mu.eta()) < 0.105)
            return passedCaloTagQuality(mu);
        // ::
        if (mu.muonType() == xAOD::Muon::SegmentTagged && (std::abs(mu.eta()) < 0.105 || m_useSegmentTaggedLowPt)) return true;
        // ::
        if (mu.author() == xAOD::Muon::MuidSA && std::abs(mu.eta()) > 2.4) return true;
        // ::
        if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
            const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
            return (cbtrack && std::abs(cbtrack->eta()) > 2.4);
        }
        // ::
        return false;
    }

passTight()

bool CP::MuonSelectionTool::passTight ( const xAOD::Muon & mu, float rho, float oneOverPSig ) const

private

Returns true if the muon passed the tight working point cuts.

Definition at line 1560 of file MuonSelectionTool.cxx.

                                                                                            {
 
        if(isRun3() && !m_developMode && (m_excludeNSWFromPrecisionLayers || !m_recalcPrecisionLayerswNSW)){
          ATH_MSG_VERBOSE("for run3, Tight WP is only supported when ExcludeNSWFromPrecisionLayers=False and RecalcPrecisionLayerswNSW=True");
          return false;
        }
        float symmetric_eta = std::abs(mu.eta());
        float pt = mu.pt() * MeVtoGeV;  // GeV
 
        // Impose pT and eta cuts; the bounds of the cut maps
        if (pt < 4.0 || symmetric_eta >= 2.5) return false;
        ATH_MSG_VERBOSE("Muon is passing tight WP kinematic cuts with pT,eta " << mu.pt() << "  ,  " << mu.eta());
 
        // ** Low pT specific cuts ** //
        if (pt < 20.0) {
            double rhoCut = m_tightWP_lowPt_rhoCuts->Interpolate(pt, symmetric_eta);
            double qOverPCut = m_tightWP_lowPt_qOverPCuts->Interpolate(pt, symmetric_eta);
 
            ATH_MSG_VERBOSE("Applying tight WP cuts to a low pt muon with (pt,eta) ( " << pt << " , " << mu.eta() << " ) ");
            ATH_MSG_VERBOSE("Rho value " << rho << ", required to be less than " << rhoCut);
            ATH_MSG_VERBOSE("Momentum significance value " << oneOverPSig << ", required to be less than " << qOverPCut);
 
            if (rho > rhoCut) return false;
            ATH_MSG_VERBOSE("Muon passed tight WP, low pT rho cut!");
 
            if (oneOverPSig > qOverPCut) return false;
            ATH_MSG_VERBOSE("Muon passed tight WP, low pT momentum significance cut");
 
            // Tight muon!
            return true;
 
        }
 
        // ** Medium pT specific cuts ** //
        else if (pt < 100.0) {
            double rhoCut = m_tightWP_mediumPt_rhoCuts->Interpolate(pt, symmetric_eta);
            //
            ATH_MSG_VERBOSE("Applying tight WP cuts to a medium pt muon with (pt,eta) (" << pt << "," << mu.eta() << ")");
            ATH_MSG_VERBOSE("Rho value " << rho << " required to be less than " << rhoCut);
 
            // Apply cut
            if (rho > rhoCut) return false;
            ATH_MSG_VERBOSE("Muon passed tight WP, medium pT rho cut!");
 
            // Tight muon!
            return true;
        }
 
        // ** High pT specific cuts
        else if (pt < 500.0) {
            //
            ATH_MSG_VERBOSE("Applying tight WP cuts to a high pt muon with (pt,eta) (" << pt << "," << mu.eta() << ")");
            // No interpolation, since bins with -1 mean we should cut really loose
            double rhoCut = m_tightWP_highPt_rhoCuts->GetBinContent(m_tightWP_highPt_rhoCuts->FindFixBin(pt, symmetric_eta));
            ATH_MSG_VERBOSE("Rho value " << rho << ", required to be less than " << rhoCut << " unless -1, in which no cut is applied");
            //
            if (rhoCut < 0.0) return true;
            if (rho > rhoCut) return false;
            ATH_MSG_VERBOSE("Muon passed tight WP, high pT rho cut!");
 
            return true;
        }
        // For muons with pT > 500 GeV, no extra cuts
        else {
            ATH_MSG_VERBOSE("Not applying any tight WP cuts to a very high pt muon with (pt,eta) (" << pt << "," << mu.eta() << ")");
            return true;
        }
 
        // you should never reach this point
        return false;
    }

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

qOverPsignificance()

float CP::MuonSelectionTool::qOverPsignificance

(

const xAOD::Muon &

muon

)

const

Returns q/p significance of the muon (see definition in https://cds.cern.ch/record/2665711 )

Definition at line 445 of file MuonSelectionTool.cxx.

                                                                          {
        // Avoid spurious FPEs in the clang build.
        CXXUTILS_TRAPPING_FP;
 
        if (m_disablePtCuts) {
            ATH_MSG_VERBOSE(__FILE__ << ":"<<__LINE__
                                     << " Momentum dependent cuts are disabled. Return 0.");
            return 0.;
        }
        const xAOD::TrackParticle* idtrack = muon.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
        const xAOD::TrackParticle* metrack = muon.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
        if (!idtrack || !metrack) {
            ATH_MSG_VERBOSE("No ID / MS track. Return dummy large value of 1 mio");
            return 1.e6;
        }
        float mePt{-1.}, idPt{-1.};
        IdMsPt(muon, idPt, mePt);
 
        const float meP = mePt / std::sin(metrack->theta());
        const float idP = idPt / std::sin(idtrack->theta());
 
        float qOverPsigma = std::sqrt(idtrack->definingParametersCovMatrix()(4, 4) + metrack->definingParametersCovMatrix()(4, 4));
        return std::abs((metrack->charge() / meP) - (idtrack->charge() / idP)) / qOverPsigma;
    }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

retrieveParam()

void CP::MuonSelectionTool::retrieveParam ( const xAOD::Muon & muon, float & value, const xAOD::Muon::ParamDef param ) const

private

Definition at line 1685 of file MuonSelectionTool.cxx.

                                                                                                                {
        if (!muon.parameter(value, param)) {
            ATH_MSG_FATAL(__FILE__ << ":" << __LINE__ << " Failed to retrieve parameter " << param
                                   << " for muon with pT:" << muon.pt() * MeVtoGeV << ", eta:" << muon.eta() << ", phi: " << muon.phi()
                                   << ", q:" << muon.charge() << ", author: " << muon.author());
            throw std::runtime_error("Failed to retrieve Parameter");
        }
    }

retrieveSummaryValue()

template<class P, class T, class S>

void CP::MuonSelectionTool::retrieveSummaryValue ( const P & muon, T & value, const S type, bool ignoreMissing = false ) const

inline

helper function to retrieve a hitSummary value

Definition at line 158 of file MuonSelectionTool.h.

                                                                                                                                                       {
            if (!muon.summaryValue(value, type) && !ignoreMissing) {
                ATH_MSG_FATAL(__FILE__ << ":" << __LINE__ << " Failed to retrieve summary value " << type);
                throw std::runtime_error("MuonSelectorTool summary retrieval failed");
            }
        }

rhoPrime()

float CP::MuonSelectionTool::rhoPrime

(

const xAOD::Muon &

muon

)

const

Returns rhoPrime of the muon (see definition in https://cds.cern.ch/record/2665711 )

Definition at line 469 of file MuonSelectionTool.cxx.

                                                                {
        if (m_disablePtCuts) {
            ATH_MSG_VERBOSE(__FILE__ << ":"<<__LINE__
                                     << "Momentum dependent cuts are disabled. Return 0.");
            return 0.;
        }
        float mePt{-1.}, idPt{-1.};
        IdMsPt(muon, idPt, mePt);
        return std::abs(idPt - mePt) / muon.pt();
    }

setPassesIDCuts()

void CP::MuonSelectionTool::setPassesIDCuts ( xAOD::Muon & mu ) const

overridevirtual

set the passes ID cuts variable of the muon

Implements CP::IMuonSelectionTool.

Definition at line 647 of file MuonSelectionTool.cxx.

{ mu.setPassesIDCuts(passedIDCuts(mu)); }

setQuality()

void CP::MuonSelectionTool::setQuality ( xAOD::Muon & mu ) const

overridevirtual

set the passes low pT cuts variable of the muon

set the passes quality variable of the muon

Implements CP::IMuonSelectionTool.

Definition at line 422 of file MuonSelectionTool.cxx.

                                                         {
        mu.setQuality(getQuality(mu));
        return;
    }

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_acceptInfo

asg::AcceptInfo CP::MuonSelectionTool::m_acceptInfo

private

Store selection information.

Definition at line 183 of file MuonSelectionTool.h.

m_allowComm

Gaudi::Property<bool> CP::MuonSelectionTool::m_allowComm {this, "AcceptCommChain", true, "Accepts muons from the EMEO chain if set to true"}

private

Definition at line 209 of file MuonSelectionTool.h.

{this, "AcceptCommChain", true, "Accepts muons from the EMEO chain if set to true"};

m_BMVcutFile

Gaudi::Property<std::string> CP::MuonSelectionTool::m_BMVcutFile

private

Initial value:

{this, "BMVcutFile",
                                                  "MuonSelectorTools/180620_BMVmimicCutFunctions/BMVmimicCutFunctions.root"}

file for bad muon veto mimic cut functions

Definition at line 246 of file MuonSelectionTool.h.

                                             {this, "BMVcutFile",
                                                  "MuonSelectorTools/180620_BMVmimicCutFunctions/BMVmimicCutFunctions.root"};

m_BMVcutFunction_barrel

std::unique_ptr<TF1> CP::MuonSelectionTool::m_BMVcutFunction_barrel

private

Definition at line 257 of file MuonSelectionTool.h.

m_BMVcutFunction_endcap

std::unique_ptr<TF1> CP::MuonSelectionTool::m_BMVcutFunction_endcap

private

Definition at line 258 of file MuonSelectionTool.h.

m_calculateTightNNScore

Gaudi::Property<bool> CP::MuonSelectionTool::m_calculateTightNNScore {this, "CalculateTightNNScore", false}

private

Definition at line 300 of file MuonSelectionTool.h.

{this, "CalculateTightNNScore", false};

m_calibration_version

Gaudi::Property<std::string> CP::MuonSelectionTool::m_calibration_version {this, "CalibrationRelease", "PreRec2016_2016-04-13"}

private

Definition at line 240 of file MuonSelectionTool.h.

{this, "CalibrationRelease", "PreRec2016_2016-04-13"};

m_caloScoreWP

Gaudi::Property<int> CP::MuonSelectionTool::m_caloScoreWP {this, "CaloScoreWP", 4,"Currently there are 4 CaloScore WPs for testing; WP4 is the recommended one"}

private

Definition at line 192 of file MuonSelectionTool.h.

{this, "CaloScoreWP", 4,"Currently there are 4 CaloScore WPs for testing; WP4 is the recommended one"};

m_custom_dir

Gaudi::Property<std::string> CP::MuonSelectionTool::m_custom_dir {this, "CustomInputFolder", ""}

private

Definition at line 243 of file MuonSelectionTool.h.

{this, "CustomInputFolder", ""};

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_developMode

Gaudi::Property<bool> CP::MuonSelectionTool::m_developMode {this, "ExpertDevelopMode", false}

private

Definition at line 198 of file MuonSelectionTool.h.

{this, "ExpertDevelopMode", false};

m_disablePtCuts

Gaudi::Property<bool> CP::MuonSelectionTool::m_disablePtCuts {this, "DisablePtCuts", false}

private

Definition at line 197 of file MuonSelectionTool.h.

{this, "DisablePtCuts", false};

m_doBadMuonVetoMimic

Gaudi::Property<bool> CP::MuonSelectionTool::m_doBadMuonVetoMimic {this, "DoBadMuonVetoMimic", false}

private

Definition at line 208 of file MuonSelectionTool.h.

{this, "DoBadMuonVetoMimic", false}; // switch to cut away the tail of very large smearing in MC to mimic the effect of the bad muon veto for 2-station muons in the high-pT selection

m_eventInfo

SG::ReadHandleKey<xAOD::EventInfo> CP::MuonSelectionTool::m_eventInfo {this, "EventInfoContName", "EventInfo", "event info key"}

private

Definition at line 215 of file MuonSelectionTool.h.

{this, "EventInfoContName", "EventInfo", "event info key"};

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_excludeNSWFromPrecisionLayers

Gaudi::Property<bool> CP::MuonSelectionTool::m_excludeNSWFromPrecisionLayers {this, "ExcludeNSWFromPrecisionLayers", false, "Cut on the nprecisionlayers ignoring the NSW"}

private

Definition at line 189 of file MuonSelectionTool.h.

{this, "ExcludeNSWFromPrecisionLayers", false, "Cut on the nprecisionlayers ignoring the NSW"};

m_expertMode_EvtNumber

Gaudi::Property<unsigned long long> CP::MuonSelectionTool::m_expertMode_EvtNumber {this, "expertMode_EvtNumber", 0, "Expert only option. Overwrites EventNumber"}

private

Definition at line 213 of file MuonSelectionTool.h.

{this, "expertMode_EvtNumber", 0, "Expert only option. Overwrites EventNumber"};

m_expertMode_RunNumber

Gaudi::Property<int> CP::MuonSelectionTool::m_expertMode_RunNumber {this, "expertMode_RunNumber", 0, "Expert only option. Overwrites RunNumber"}

private

Definition at line 212 of file MuonSelectionTool.h.

{this, "expertMode_RunNumber", 0, "Expert only option. Overwrites RunNumber"};

m_geoOnTheFly

Gaudi::Property<bool> CP::MuonSelectionTool::m_geoOnTheFly {this, "AllowSettingGeometryOnTheFly", false,"avoids crash if run2/run3 geo is wrongly set"}

private

Definition at line 207 of file MuonSelectionTool.h.

{this, "AllowSettingGeometryOnTheFly", false,"avoids crash if run2/run3 geo is wrongly set"};

m_isRun3

Gaudi::Property<bool> CP::MuonSelectionTool::m_isRun3 {this, "IsRun3Geo", false, "Switch to toggle the run 2 & run 3 geometry cuts. The tool will throw an exception if the run number does not match the expectations later"}

private

Definition at line 188 of file MuonSelectionTool.h.

{this, "IsRun3Geo", false, "Switch to toggle the run 2 & run 3 geometry cuts. The tool will throw an exception if the run number does not match the expectations later"}; 

m_low_pt_mva_mutex

std::mutex CP::MuonSelectionTool::m_low_pt_mva_mutex

mutableprivate

Definition at line 285 of file MuonSelectionTool.h.

m_lowPtMuGirl_means

std::vector<double> CP::MuonSelectionTool::m_lowPtMuGirl_means

private

Definition at line 281 of file MuonSelectionTool.h.

m_lowPtMuGirl_scaler

std::vector<double> CP::MuonSelectionTool::m_lowPtMuGirl_scaler

private

Definition at line 282 of file MuonSelectionTool.h.

m_lowPtMuidCO_means

std::vector<double> CP::MuonSelectionTool::m_lowPtMuidCO_means

private

Definition at line 278 of file MuonSelectionTool.h.

m_lowPtMuidCO_scaler

std::vector<double> CP::MuonSelectionTool::m_lowPtMuidCO_scaler

private

Definition at line 279 of file MuonSelectionTool.h.

m_maxEta

Gaudi::Property<double> CP::MuonSelectionTool::m_maxEta {this, "MaxEta", 2.7, "Maximum eta range to select the muons"}

private

Definition at line 185 of file MuonSelectionTool.h.

{this, "MaxEta", 2.7, "Maximum eta range to select the muons"};

m_MuGirl

std::unique_ptr<MVAUtils::BDT> CP::MuonSelectionTool::m_MuGirl {nullptr}

private

Definition at line 280 of file MuonSelectionTool.h.

{nullptr};

m_MuidCO

std::unique_ptr<MVAUtils::BDT> CP::MuonSelectionTool::m_MuidCO {nullptr}

private

Definition at line 277 of file MuonSelectionTool.h.

{nullptr};

m_MVAreaderFile_EVEN_MuGirl

Gaudi::Property<std::string> CP::MuonSelectionTool::m_MVAreaderFile_EVEN_MuGirl

private

Initial value:

{
            this, "MVAreaderFile_EVEN_MuGirl",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuGirl_EVEN.weights.xml"}

Definition at line 225 of file MuonSelectionTool.h.

                                                            {
            this, "MVAreaderFile_EVEN_MuGirl",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuGirl_EVEN.weights.xml"};

m_MVAreaderFile_EVEN_MuidCB

Gaudi::Property<std::string> CP::MuonSelectionTool::m_MVAreaderFile_EVEN_MuidCB

private

Initial value:

{
            this, "MVAreaderFile_EVEN_MuidCB",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuidCB_EVEN.weights.xml"}

Definition at line 218 of file MuonSelectionTool.h.

                                                            {
            this, "MVAreaderFile_EVEN_MuidCB",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuidCB_EVEN.weights.xml"};

m_MVAreaderFile_MuTagIMO_etaBin1

Gaudi::Property<std::string> CP::MuonSelectionTool::m_MVAreaderFile_MuTagIMO_etaBin1

private

Initial value:

{
            this, "MVAreaderFile_MuTagIMO_etaBin1", "dev/MuonSelectorTools/181121_MuTagIMO_BDT/BDT_NOV2021_MuTagIMO_etaBin1.weights.xml"}

Definition at line 232 of file MuonSelectionTool.h.

                                                                 {
            this, "MVAreaderFile_MuTagIMO_etaBin1", "dev/MuonSelectorTools/181121_MuTagIMO_BDT/BDT_NOV2021_MuTagIMO_etaBin1.weights.xml"};

m_MVAreaderFile_MuTagIMO_etaBin2

Gaudi::Property<std::string> CP::MuonSelectionTool::m_MVAreaderFile_MuTagIMO_etaBin2

private

Initial value:

{
            this, "MVAreaderFile_MuTagIMO_etaBin2", "dev/MuonSelectorTools/181121_MuTagIMO_BDT/BDT_NOV2021_MuTagIMO_etaBin2.weights.xml"}

Definition at line 234 of file MuonSelectionTool.h.

                                                                 {
            this, "MVAreaderFile_MuTagIMO_etaBin2", "dev/MuonSelectorTools/181121_MuTagIMO_BDT/BDT_NOV2021_MuTagIMO_etaBin2.weights.xml"};

m_MVAreaderFile_MuTagIMO_etaBin3

Gaudi::Property<std::string> CP::MuonSelectionTool::m_MVAreaderFile_MuTagIMO_etaBin3

private

Initial value:

{
            this, "MVAreaderFile_MuTagIMO_etaBin3", "dev/MuonSelectorTools/181121_MuTagIMO_BDT/BDT_NOV2021_MuTagIMO_etaBin3.weights.xml"}

Definition at line 236 of file MuonSelectionTool.h.

                                                                 {
            this, "MVAreaderFile_MuTagIMO_etaBin3", "dev/MuonSelectorTools/181121_MuTagIMO_BDT/BDT_NOV2021_MuTagIMO_etaBin3.weights.xml"};

m_MVAreaderFile_ODD_MuGirl

Gaudi::Property<std::string> CP::MuonSelectionTool::m_MVAreaderFile_ODD_MuGirl

private

Initial value:

{
            this, "MVAreaderFile_ODD_MuGirl",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuGirl_ODD.weights.xml"}

Definition at line 228 of file MuonSelectionTool.h.

                                                           {
            this, "MVAreaderFile_ODD_MuGirl",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuGirl_ODD.weights.xml"};

m_MVAreaderFile_ODD_MuidCB

Gaudi::Property<std::string> CP::MuonSelectionTool::m_MVAreaderFile_ODD_MuidCB

private

Initial value:

{
            this, "MVAreaderFile_ODD_MuidCB",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuidCB_ODD.weights.xml"}

Definition at line 221 of file MuonSelectionTool.h.

                                                           {
            this, "MVAreaderFile_ODD_MuidCB",
            "MuonSelectorTools/190118_PrelimLowPtMVA/LowPtMVA_Weights/BDTG_9JAN2019_MuidCB_ODD.weights.xml"};

m_onnxTool

ToolHandle< AthInfer::IAthInferenceTool > CP::MuonSelectionTool::m_onnxTool {this, "ORTInferenceTool", "AthOnnx::OnnxRuntimeInferenceTool"}

private

Definition at line 301 of file MuonSelectionTool.h.

{this, "ORTInferenceTool", "AthOnnx::OnnxRuntimeInferenceTool"};

m_PixCutOff

Gaudi::Property<bool> CP::MuonSelectionTool::m_PixCutOff {this, "PixCutOff", false}

private

Definition at line 201 of file MuonSelectionTool.h.

{this, "PixCutOff", false};

m_quality

Gaudi::Property<int> CP::MuonSelectionTool::m_quality {this, "MuQuality", 1,"Quality to select. Values correspond to 0=Tight, 1=Medium, 2=Loose, 3=VeryLoose (only for debug, not supported), 4=HighPt, 5=LowPtEfficiency"}

private

Definition at line 186 of file MuonSelectionTool.h.

{this, "MuQuality", 1,"Quality to select. Values correspond to 0=Tight, 1=Medium, 2=Loose, 3=VeryLoose (only for debug, not supported), 4=HighPt, 5=LowPtEfficiency"};

m_reader_MUTAGIMO_etaBin1

std::unique_ptr<TMVA::Reader> CP::MuonSelectionTool::m_reader_MUTAGIMO_etaBin1 {nullptr}

private

Definition at line 272 of file MuonSelectionTool.h.

{nullptr};

m_reader_MUTAGIMO_etaBin2

std::unique_ptr<TMVA::Reader> CP::MuonSelectionTool::m_reader_MUTAGIMO_etaBin2 {nullptr}

private

Definition at line 273 of file MuonSelectionTool.h.

{nullptr};

m_reader_MUTAGIMO_etaBin3

std::unique_ptr<TMVA::Reader> CP::MuonSelectionTool::m_reader_MUTAGIMO_etaBin3 {nullptr}

private

Definition at line 274 of file MuonSelectionTool.h.

{nullptr};

m_readerE_MUGIRL

std::unique_ptr<TMVA::Reader> CP::MuonSelectionTool::m_readerE_MUGIRL {nullptr}

private

Definition at line 269 of file MuonSelectionTool.h.

{nullptr};

m_readerE_MUID

std::unique_ptr<TMVA::Reader> CP::MuonSelectionTool::m_readerE_MUID {nullptr}

private

Definition at line 267 of file MuonSelectionTool.h.

{nullptr};

m_readerO_MUGIRL

std::unique_ptr<TMVA::Reader> CP::MuonSelectionTool::m_readerO_MUGIRL {nullptr}

private

Definition at line 270 of file MuonSelectionTool.h.

{nullptr};

m_readerO_MUID

std::unique_ptr<TMVA::Reader> CP::MuonSelectionTool::m_readerO_MUID {nullptr}

private

Definition at line 268 of file MuonSelectionTool.h.

{nullptr};

m_recalcPrecisionLayerswNSW

Gaudi::Property<bool> CP::MuonSelectionTool::m_recalcPrecisionLayerswNSW {this, "RecalcPrecisionLayerswNSW", true, "Recalculate nprecisionlayers with internal criteria for NSW"}

private

Definition at line 190 of file MuonSelectionTool.h.

{this, "RecalcPrecisionLayerswNSW", true, "Recalculate nprecisionlayers with internal criteria for NSW"};

m_SctCutOff

Gaudi::Property<bool> CP::MuonSelectionTool::m_SctCutOff {this, "SctCutOff", false}

private

Definition at line 200 of file MuonSelectionTool.h.

{this, "SctCutOff", false};

m_SiHolesCutOff

Gaudi::Property<bool> CP::MuonSelectionTool::m_SiHolesCutOff {this, "SiHolesCutOff", false}

private

Definition at line 202 of file MuonSelectionTool.h.

{this, "SiHolesCutOff", false};

m_tightWP_highPt_rhoCuts

std::unique_ptr<TH1> CP::MuonSelectionTool::m_tightWP_highPt_rhoCuts

private

Definition at line 255 of file MuonSelectionTool.h.

m_tightWP_lowPt_qOverPCuts

std::unique_ptr<TH1> CP::MuonSelectionTool::m_tightWP_lowPt_qOverPCuts

private

Definition at line 253 of file MuonSelectionTool.h.

m_tightWP_lowPt_rhoCuts

std::unique_ptr<TH1> CP::MuonSelectionTool::m_tightWP_lowPt_rhoCuts

private

Definition at line 252 of file MuonSelectionTool.h.

m_tightWP_mediumPt_rhoCuts

std::unique_ptr<TH1> CP::MuonSelectionTool::m_tightWP_mediumPt_rhoCuts

private

Definition at line 254 of file MuonSelectionTool.h.

m_toroidOff

Gaudi::Property<bool> CP::MuonSelectionTool::m_toroidOff {this, "ToroidOff", false, "Run the tool in Toroid off setup"}

private

Definition at line 187 of file MuonSelectionTool.h.

{this, "ToroidOff", false, "Run the tool in Toroid off setup"};

m_TrtCutOff

Gaudi::Property<bool> CP::MuonSelectionTool::m_TrtCutOff {this, "TrtCutOff", true}

private

Definition at line 199 of file MuonSelectionTool.h.

{this, "TrtCutOff", true};

m_turnOffMomCorr

Gaudi::Property<bool> CP::MuonSelectionTool::m_turnOffMomCorr {this, "TurnOffMomCorr", false}

private

Definition at line 196 of file MuonSelectionTool.h.

{this, "TurnOffMomCorr", false};

m_use2stationMuonsHighPt

Gaudi::Property<bool> CP::MuonSelectionTool::m_use2stationMuonsHighPt {this, "Use2stationMuonsHighPt", true, "for users of high-pT working point to choose whether to include 'safe' 2-station muons"}

private

Definition at line 204 of file MuonSelectionTool.h.

{this, "Use2stationMuonsHighPt", true, "for users of high-pT working point to choose whether to include 'safe' 2-station muons"};

m_useAllAuthors

Gaudi::Property<bool> CP::MuonSelectionTool::m_useAllAuthors {this, "UseAllAuthors", true}

private

Definition at line 203 of file MuonSelectionTool.h.

{this, "UseAllAuthors", true};

m_useBEEBISInHighPtRun3

Gaudi::Property<bool> CP::MuonSelectionTool::m_useBEEBISInHighPtRun3 {this, "UseBEEBISInHighPtRun3", true, "Include BEE and BIS7/8 in high-pT WP in Run3"}

private

Definition at line 210 of file MuonSelectionTool.h.

{this, "UseBEEBISInHighPtRun3", true, "Include BEE and BIS7/8 in high-pT WP in Run3"};        

m_useCaloScore

Gaudi::Property<bool> CP::MuonSelectionTool::m_useCaloScore {this, "UseCaloScore", true, "Use CaloScore for calo-tags in the Loose working point. False will revert back to CaloMuonIDTag (not recommended in Rel.22)"}

private

Definition at line 191 of file MuonSelectionTool.h.

{this, "UseCaloScore", true, "Use CaloScore for calo-tags in the Loose working point. False will revert back to CaloMuonIDTag (not recommended in Rel.22)"};

m_useLRT

Gaudi::Property<bool> CP::MuonSelectionTool::m_useLRT {this, "UseLRT", false, "Enable support for LRT muons"}

private

Definition at line 193 of file MuonSelectionTool.h.

{this, "UseLRT", false, "Enable support for LRT muons"};

m_useMVALowPt

Gaudi::Property<bool> CP::MuonSelectionTool::m_useMVALowPt {this, "UseMVALowPt", false, "for users of low-pT working point to choose whether to use MVA and whether to include MuTagIMO muons. Not yet supported in release 22, crrently only for development studies."}

private

Definition at line 205 of file MuonSelectionTool.h.

{this, "UseMVALowPt", false, "for users of low-pT working point to choose whether to use MVA and whether to include MuTagIMO muons. Not yet supported in release 22, crrently only for development studies."};

m_useSegmentTaggedLowPt

Gaudi::Property<bool> CP::MuonSelectionTool::m_useSegmentTaggedLowPt {this, "UseSegmentTaggedLowPt", false, "Use MVA low-pt WP. In development phase"}

private

Definition at line 206 of file MuonSelectionTool.h.

{this, "UseSegmentTaggedLowPt", false, "Use MVA low-pt WP. In development phase"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

The documentation for this class was generated from the following files:

• MuonSelectionTool.h
• MuonSelectionTool.cxx