ATLAS Offline Software
Classes | Public Types | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
CP::MuonSelectionTool Class Referenceabstract

Implementation of the muon selector tool. More...

#include <MuonSelectionTool.h>

Inheritance diagram for CP::MuonSelectionTool:
Collaboration 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. More...
 
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. More...
 
bool isBIS78 (const float eta, const float phi) const
 Check if muon eta/phi falls in BIS7/8 chambers. More...
 
bool isBEE (const float eta, const float phi) const
 Check if muon eta/phi falls in BEE chambers. More...
 
bool isBMG (const float eta, const float phi) const
 Check if muon eta/phi falls in BMG chambers. More...
 
float qOverPsignificance (const xAOD::Muon &muon) const
 Returns q/p significance of the muon (see definition in https://cds.cern.ch/record/2665711 ) More...
 
float rhoPrime (const xAOD::Muon &muon) const
 Returns rhoPrime of the muon (see definition in https://cds.cern.ch/record/2665711 ) More...
 
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 More...
 
void fillSummary (const xAOD::Muon &muon, hitSummary &summary) const
 functions that fills a hitSummary for a muon More...
 
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. More...
 
virtual void print () const =0
 Print the state of the tool. More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 
Function(s) implementing the asg::IAsgTool interface
virtual StatusCode initialize () override
 Function initialising the tool. More...
 
Function(s) implementing the IAsgSelectionTool interface
virtual const asg::AcceptInfo & getAcceptInfo () const override
 Get an object describing the "selection steps" of the tool. More...
 
virtual asg::AcceptData accept (const xAOD::IParticle *p) const override
 Get the decision using a generic IParticle pointer. More...
 
Function(s) implementing the IMuonSelectorTool interface
virtual asg::AcceptData accept (const xAOD::Muon &mu) const override
 Get the decision for a specific Muon object. More...
 
virtual void setPassesIDCuts (xAOD::Muon &) const override
 set the passes ID cuts variable of the muon More...
 
virtual void setQuality (xAOD::Muon &mu) const override
 set the passes low pT cuts variable of the muon More...
 
virtual bool passedIDCuts (const xAOD::Muon &) const override
 Returns true if the muon passes the standard MCP ID cuts. More...
 
virtual bool passedMuonCuts (const xAOD::Muon &) const override
 Returns true if the muon passes a standardized loose preselection. More...
 
virtual bool passedIDCuts (const xAOD::TrackParticle &) const override
 Returns true if the track particle passes the standard MCP ID cuts. More...
 
virtual bool passedHighPtCuts (const xAOD::Muon &) const override
 Returns true if the muon passes the standard MCP High Pt cuts. More...
 
virtual bool passedLowPtEfficiencyCuts (const xAOD::Muon &) const override
 Returns true if the muon passes the standard MCP low pt cuts. More...
 
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. More...
 
virtual bool isBadMuon (const xAOD::Muon &) const override
 Returns true if a CB muon fails some loose quaility requirements designed to remove pathological tracks. More...
 
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. More...
 
virtual bool passedCaloTagQuality (const xAOD::Muon &mu) const override
 Returns true if the muon passed additional calo-tag quality cuts. More...
 
virtual bool passedCaloScore (const xAOD::Muon &mu) const override
 Returns true if the muon passed the CaloScore calo-tag working point. More...
 
virtual int getResolutionCategory (const xAOD::Muon &) const override
 Returns an integer corresponding to categorization of muons with different resolutions. More...
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

bool passedLowPtEfficiencyMVACut (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. More...
 
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. More...
 
StatusCode getHist (TFile *file, const std::string &histName, std::unique_ptr< TH1 > &hist) const
 Checks for each histogram. More...
 
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> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

asg::AcceptInfo m_acceptInfo
 Store selection information. More...
 
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 More...
 
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::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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
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 35 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.

31  {
32  unclassified = -1,
33  missingInner = 1,
34  missingMiddle = 1 << 1,
35  missingOuter = 1 << 2,
36  highPt2station = 1 << 3,
37  highPt = 1 << 4,
38  spoiledCSC = 1 << 5,
39  BEoverlap = 1 << 6,
40  BIS78 = 1 << 7,
41  missingBEE = 1 << 8,
42  oneStation = 1 << 9,
43  CategoryZero = missingInner | spoiledCSC | BEoverlap | BIS78 | missingBEE,
44  CategoryOne = missingMiddle | oneStation,
45  CategoryTwo = missingOuter,
46  CategoryThree = highPt2station,
47  CategoryFour = highPt
48  };

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.

56  : asg::AsgTool(tool_name), m_acceptInfo("MuonSelection"){
57 
58  if (!m_calculateTightNNScore) m_onnxTool.setTypeAndName("");
59 
60  }

◆ ~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 271 of file MuonSelectionTool.cxx.

271  {
272  // Check if this is a muon:
273  if (p->type() != xAOD::Type::Muon) {
274  ATH_MSG_ERROR("accept(...) Function received a non-muon");
275  return asg::AcceptData(&m_acceptInfo);
276  }
277 
278  // Cast it to a muon:
279  const xAOD::Muon* mu = dynamic_cast<const xAOD::Muon*>(p);
280  if (!mu) {
281  ATH_MSG_FATAL("accept(...) Failed to cast particle to muon");
282  return asg::AcceptData(&m_acceptInfo);
283  }
284 
285  // Let the specific function do the work:
286  return accept(*mu);
287  }

◆ 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 319 of file MuonSelectionTool.cxx.

319  {
320  // Verbose information
321  ATH_MSG_VERBOSE("-----------------------------------");
322  ATH_MSG_VERBOSE("New muon passed to accept function:");
323  if (mu.muonType() == xAOD::Muon::Combined)
324  ATH_MSG_VERBOSE("Muon type: combined");
325  else if (mu.muonType() == xAOD::Muon::MuonStandAlone)
326  ATH_MSG_VERBOSE("Muon type: stand-alone");
327  else if (mu.muonType() == xAOD::Muon::SegmentTagged)
328  ATH_MSG_VERBOSE("Muon type: segment-tagged");
329  else if (mu.muonType() == xAOD::Muon::CaloTagged)
330  ATH_MSG_VERBOSE("Muon type: calorimeter-tagged");
331  else if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon)
332  ATH_MSG_VERBOSE("Muon type: silicon-associated forward");
333  ATH_MSG_VERBOSE("Muon pT [GeV]: " << mu.pt() * MeVtoGeV);
334  ATH_MSG_VERBOSE("Muon eta: " << mu.eta());
335  ATH_MSG_VERBOSE("Muon phi: " << mu.phi());
336 
337  checkSanity();
338 
339  asg::AcceptData acceptData(&m_acceptInfo);
340 
341  // Do the eta cut:
342  if (std::abs(mu.eta()) >= m_maxEta) {
343  ATH_MSG_VERBOSE("Failed eta cut");
344  return acceptData;
345  }
346  acceptData.setCutResult("Eta", true);
347 
348  // Passes ID hit cuts
349  bool passIDCuts = passedIDCuts(mu);
350  ATH_MSG_VERBOSE("Passes ID Hit cuts " << passIDCuts);
351  acceptData.setCutResult("IDHits", passIDCuts);
352 
353  // passes muon preselection
354  bool passMuonCuts = passedMuonCuts(mu);
355  ATH_MSG_VERBOSE("Passes preselection cuts " << passMuonCuts);
356  acceptData.setCutResult("Preselection", passMuonCuts);
357 
358  if (!passIDCuts || !passMuonCuts) { return acceptData; }
359 
360  // Passes quality requirements
361  xAOD::Muon::Quality thisMu_quality = getQuality(mu);
362  bool thisMu_highpt = false;
363  thisMu_highpt = passedHighPtCuts(mu);
364  bool thisMu_lowptE = false;
365  thisMu_lowptE = passedLowPtEfficiencyCuts(mu, thisMu_quality);
366  ATH_MSG_VERBOSE("Summary of quality information for this muon: ");
367  ATH_MSG_VERBOSE("Muon quality: " << thisMu_quality << " passes HighPt: " << thisMu_highpt
368  << " passes LowPtEfficiency: " << thisMu_lowptE);
369  if (m_quality < 4 && thisMu_quality > m_quality) { return acceptData; }
370  if (m_quality == 4 && !thisMu_highpt) { return acceptData; }
371  if (m_quality == 5 && !thisMu_lowptE) { return acceptData; }
372  acceptData.setCutResult("Quality", true);
373  // Return the result:
374  return acceptData;
375  }

◆ checkSanity()

void CP::MuonSelectionTool::checkSanity ( ) const
private

Definition at line 290 of file MuonSelectionTool.cxx.

290  {
291 
292  static std::atomic<bool> checkDone{false};
293 
294  if(!checkDone) {
295  // Check that the user either set the correct geometry or enabled on-the-fly determination
296  // This can happen intentionally in developer mode. In any case don't throw an exception
297  // (we should either trust the user or ignore in the first place and force on-the-fly determination).
298  if (isRun3() != isRun3(true)) {
299  ATH_MSG_WARNING("MuonSelectionTool is configured with isRun3Geo="<<isRun3()
300  <<" while on-the fly check for runNumber "<<getRunNumber(true)<<" indicates isRun3Geo="<<isRun3(true));
301  }
302 
303  // Check that the requested WP is currently supported by the MCP group.
304  if (isRun3()) {
305  if(m_quality!=0 && m_quality!=1 && m_quality!=2 && m_quality!=4 && m_quality!=5) {
306  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");
307  }
308 
309  if(m_quality==0 && !m_developMode && (m_excludeNSWFromPrecisionLayers || !m_recalcPrecisionLayerswNSW)) {
310  ATH_MSG_WARNING("For Run3, Tight WP is supported only when ExcludeNSWFromPrecisionLayers=False and RecalcPrecisionLayerswNSW=True");
311  }
312  }
313 
314  checkDone = true;
315  }
316  }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fillSummary()

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

functions that fills a hitSummary for a muon

Definition at line 1420 of file MuonSelectionTool.cxx.

1420  {
1421 
1422  checkSanity();
1423 
1424  retrieveSummaryValue(muon, summary.nprecisionLayers, xAOD::SummaryType::numberOfPrecisionLayers);
1425  retrieveSummaryValue(muon, summary.nprecisionHoleLayers, xAOD::SummaryType::numberOfPrecisionHoleLayers);
1426  retrieveSummaryValue(muon, summary.nGoodPrecLayers, xAOD::numberOfGoodPrecisionLayers);
1427  retrieveSummaryValue(muon, summary.innerSmallHits, xAOD::MuonSummaryType::innerSmallHits);
1428  retrieveSummaryValue(muon, summary.innerLargeHits, xAOD::MuonSummaryType::innerLargeHits);
1429  retrieveSummaryValue(muon, summary.middleSmallHits, xAOD::MuonSummaryType::middleSmallHits);
1430  retrieveSummaryValue(muon, summary.middleLargeHits, xAOD::MuonSummaryType::middleLargeHits);
1431  retrieveSummaryValue(muon, summary.outerSmallHits, xAOD::MuonSummaryType::outerSmallHits);
1432  retrieveSummaryValue(muon, summary.outerLargeHits, xAOD::MuonSummaryType::outerLargeHits);
1433  retrieveSummaryValue(muon, summary.extendedSmallHits, xAOD::MuonSummaryType::extendedSmallHits);
1434  retrieveSummaryValue(muon, summary.extendedLargeHits, xAOD::MuonSummaryType::extendedLargeHits);
1435  retrieveSummaryValue(muon, summary.extendedSmallHoles, xAOD::MuonSummaryType::extendedSmallHoles);
1436  retrieveSummaryValue(muon, summary.isSmallGoodSectors, xAOD::MuonSummaryType::isSmallGoodSectors);
1437 
1438  if (!isRun3()) {
1439  // ignore missing of cscUnspoiledEtaHits in case we are running in expert developer mode
1440  // e.g. for when we want to apply Run2 WPs in Run3
1441  retrieveSummaryValue(muon, summary.cscUnspoiledEtaHits, xAOD::MuonSummaryType::cscUnspoiledEtaHits, m_developMode);
1442 
1443  if (std::abs(muon.eta()) > 2.0) {
1444  ATH_MSG_VERBOSE("Recalculating number of precision layers for combined muon");
1445  summary.nprecisionLayers = (summary.innerSmallHits > 1 || summary.innerLargeHits > 1)
1446  + (summary.middleSmallHits > 2 || summary.middleLargeHits > 2)
1447  + (summary.outerSmallHits > 2 || summary.outerLargeHits > 2);
1448  }
1449 
1450  } else if (std::abs(muon.eta()) > 1.3 && (m_excludeNSWFromPrecisionLayers || m_recalcPrecisionLayerswNSW)) {
1451  summary.nprecisionLayers = (summary.middleSmallHits > 2 || summary.middleLargeHits > 2)
1452  + (summary.outerSmallHits > 2 || summary.outerLargeHits > 2)
1453  + (summary.extendedSmallHits > 2 || summary.extendedLargeHits > 2);
1454 
1455  if (!m_excludeNSWFromPrecisionLayers && m_recalcPrecisionLayerswNSW) {
1456 
1457  if (!eta1stgchits_acc.isAvailable(muon) || !eta2stgchits_acc.isAvailable(muon) || !mmhits_acc.isAvailable(muon)) {
1458  ATH_MSG_FATAL(__FILE__ << ":" << __LINE__ << " Failed to retrieve NSW hits!"
1459  << " (Please use DxAODs with p-tags >= p5834 OR set ExcludeNSWFromPrecisionLayers to True (tests only)");
1460  throw std::runtime_error("Failed to retrieve NSW hits");
1461  }
1462 
1463  retrieveSummaryValue(muon, summary.etaLayer1STGCHits, xAOD::MuonSummaryType::etaLayer1STGCHits);
1464  retrieveSummaryValue(muon, summary.etaLayer2STGCHits, xAOD::MuonSummaryType::etaLayer2STGCHits);
1465  retrieveSummaryValue(muon, summary.MMHits, xAOD::MuonSummaryType::MMHits);
1466  summary.nprecisionLayers += ((summary.etaLayer1STGCHits + summary.etaLayer2STGCHits) > 3 || summary.MMHits > 3);
1467  }
1468  }
1469  }

◆ getAcceptInfo()

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

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

Implements IAsgSelectionTool.

Definition at line 269 of file MuonSelectionTool.cxx.

269 { 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 248 of file MuonSelectionTool.cxx.

248  {
249  //
250  if (!file) {
251  ATH_MSG_ERROR(" getHist(...) TFile is nullptr! Check that the Tight cut map is loaded correctly");
252  return StatusCode::FAILURE;
253  }
254  TH1* h_ptr = nullptr;
255  file->GetObject(histName.c_str(), h_ptr);
256  //
257  //
258  if (!h_ptr) {
259  ATH_MSG_ERROR("Cannot retrieve histogram " << histName);
260  return StatusCode::FAILURE;
261  }
262  hist = std::unique_ptr<TH1>{h_ptr};
263  hist->SetDirectory(nullptr);
264  ATH_MSG_INFO("Successfully read tight working point histogram: " << hist->GetName());
265  //
266  return StatusCode::SUCCESS;
267  }

◆ getKey()

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

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

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

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

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

Definition at line 119 of file AsgTool.cxx.

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

◆ getName()

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

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

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

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

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

Definition at line 106 of file AsgTool.cxx.

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

◆ getProperty()

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

Get one of the tool's properties.

◆ 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 435 of file MuonSelectionTool.cxx.

435  {
436  ATH_MSG_VERBOSE("Evaluating muon quality...");
437  if (isRun3() && mu.isAuthor(xAOD::Muon::Author::Commissioning) && !m_allowComm) {
438  ATH_MSG_VERBOSE("Reject authors from the commissioning chain");
439  return xAOD::Muon::VeryLoose;
440  }
441 
442  // SegmentTagged muons
443  if (mu.muonType() == xAOD::Muon::SegmentTagged) {
444  ATH_MSG_VERBOSE("Muon is segment-tagged");
445 
446  if (std::abs(mu.eta()) < 0.1) {
447  ATH_MSG_VERBOSE("Muon is loose");
448  return xAOD::Muon::Loose;
449  } else {
450  ATH_MSG_VERBOSE("Do not allow segment-tagged muon at |eta| > 0.1 - return VeryLoose");
451  return xAOD::Muon::VeryLoose;
452  }
453  }
454 
455  // CaloTagged muons
456  if (mu.muonType() == xAOD::Muon::CaloTagged) {
457  ATH_MSG_VERBOSE("Muon is calorimeter-tagged");
458 
459  if (std::abs(mu.eta()) < 0.1 && passedCaloTagQuality(mu)) {
460  ATH_MSG_VERBOSE("Muon is loose");
461  return xAOD::Muon::Loose;
462  }
463  }
464 
465  // Combined muons
466  hitSummary summary{};
467  fillSummary(mu, summary);
468 
469  if (mu.muonType() == xAOD::Muon::Combined) {
470  ATH_MSG_VERBOSE("Muon is combined");
471  if (mu.author() == xAOD::Muon::STACO) {
472  ATH_MSG_VERBOSE("Muon is STACO - return VeryLoose");
473  return xAOD::Muon::VeryLoose;
474  }
475 
476  // rejection muons with out-of-bounds hits
477  uint8_t combinedTrackOutBoundsPrecisionHits{0};
478  retrieveSummaryValue(mu, combinedTrackOutBoundsPrecisionHits, xAOD::MuonSummaryType::combinedTrackOutBoundsPrecisionHits);
479 
480  if (combinedTrackOutBoundsPrecisionHits > 0) {
481  ATH_MSG_VERBOSE("Muon has out-of-bounds precision hits - return VeryLoose");
482  return xAOD::Muon::VeryLoose;
483  }
484 
485  // LOOSE / MEDIUM / TIGHT WP
486  const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
487  const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
488  if (idtrack && metrack && metrack->definingParametersCovMatrix()(4, 4) > 0) {
489  const float qOverPsignif = qOverPsignificance(mu);
490  const float rho = rhoPrime(mu);
491  const float reducedChi2 = mu.primaryTrackParticle()->chiSquared() / mu.primaryTrackParticle()->numberDoF();
492 
493  ATH_MSG_VERBOSE("Relevant cut variables:");
494  ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers);
495  ATH_MSG_VERBOSE("reduced Chi2 = " << reducedChi2);
496  ATH_MSG_VERBOSE("qOverP significance = " << qOverPsignif);
497 
498  // NEW TIGHT WP
499  if (summary.nprecisionLayers > 1 && reducedChi2 < 8 && std::abs(qOverPsignif) < 7) {
500  if (passTight(mu, rho, qOverPsignif)) {
501  ATH_MSG_VERBOSE("Muon is tight");
502  return xAOD::Muon::Tight;
503  }
504  }
505 
506  ATH_MSG_VERBOSE("Muon did not pass requirements for tight combined muon");
507 
508  // MEDIUM WP
509  if ((std::abs(qOverPsignif) < 7 || m_toroidOff) &&
510  (summary.nprecisionLayers > 1 ||(summary.nprecisionLayers == 1 && summary.nprecisionHoleLayers < 2 && std::abs(mu.eta()) < 0.1))
511 
512  ) {
513  ATH_MSG_VERBOSE("Muon is medium");
514  return xAOD::Muon::Medium;
515  }
516 
517  ATH_MSG_VERBOSE("Muon did not pass requirements for medium combined muon");
518 
519  } else {
520  ATH_MSG_VERBOSE("Muon is missing the ID and/or ME tracks...");
521 
522  // CB muons with missing ID or ME track
523  if ((summary.nprecisionLayers > 1 ||
524  (summary.nprecisionLayers == 1 && summary.nprecisionHoleLayers < 2 && std::abs(mu.eta()) < 0.1))) {
525  // In toroid-off data ME/MS tracks often missing - need special treatment => flagging as "Medium"
526  // In toroid-on data ME/MS tracks missing only for <1% of CB muons, mostly MuGirl (to be fixed) => flagging as "Loose"
527  if (m_toroidOff) {
528  ATH_MSG_VERBOSE("...this is toroid-off data - returning medium");
529  return xAOD::Muon::Medium;
530  } else {
531  ATH_MSG_VERBOSE("...this is not toroid-off data - returning loose");
532  return xAOD::Muon::Loose;
533  }
534  }
535  }
536 
537  // Improvement for Loose targeting low-pT muons (pt<7 GeV)
538  if ((m_disablePtCuts || mu.pt() * MeVtoGeV < 7.) && std::abs(mu.eta()) < 1.3 && summary.nprecisionLayers > 0 &&
539  (mu.author() == xAOD::Muon::MuGirl && mu.isAuthor(xAOD::Muon::MuTagIMO))) {
540  ATH_MSG_VERBOSE("Muon passed selection for loose working point at low pT");
541  return xAOD::Muon::Loose;
542  }
543 
544  // didn't pass the set of requirements for a medium or tight combined muon
545  ATH_MSG_VERBOSE("Did not pass selections for combined muon - returning VeryLoose");
546  return xAOD::Muon::VeryLoose;
547  }
548 
549  // SA muons
550  if (mu.author() == xAOD::Muon::MuidSA) {
551  ATH_MSG_VERBOSE("Muon is stand-alone");
552 
553  if(isRun3() && !m_developMode){
554  ATH_MSG_VERBOSE("Standalone muons currently only used when in expert mode for run3");
555  return xAOD::Muon::VeryLoose; //SA muons currently disabled for run3
556  }
557 
558  if (std::abs(mu.eta()) > 2.5) {
559  ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers);
560 
561  // 3 station requirement for medium
562  if (summary.nprecisionLayers > 2 && !m_toroidOff) {
563  ATH_MSG_VERBOSE("Muon is medium");
564  return xAOD::Muon::Medium;
565  }
566  }
567 
568  // didn't pass the set of requirements for a medium SA muon
569  ATH_MSG_VERBOSE("Muon did not pass selection for medium stand-alone muon - return VeryLoose");
570  return xAOD::Muon::VeryLoose;
571  }
572 
573  // SiliconAssociatedForward (SAF) muons
574  if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
575  ATH_MSG_VERBOSE("Muon is silicon-associated forward muon");
576 
577  if(isRun3() && !m_developMode){
578  ATH_MSG_VERBOSE("Silicon-associated forward muon muons currently only used when in expert mode for run3");
579  return xAOD::Muon::VeryLoose; //SAF muons currently disabled for run3
580  }
581 
582  const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
583  const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
584 
585  if (cbtrack && metrack) {
586  if (std::abs(cbtrack->eta()) > 2.5) {
587  ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers);
588 
589  if (summary.nprecisionLayers > 2 && !m_toroidOff) {
590  if (mu.trackParticle(xAOD::Muon::Primary) == mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle) &&
591  !m_developMode) {
592  ATH_MSG_FATAL(
593  "SiliconForwardAssociated muon has ID track as primary track particle. "
594  << "This is a bug fixed starting with xAODMuon-00-17-07, which should be present in this release. "
595  << "Please report this to the Muon CP group!");
596  }
597  ATH_MSG_VERBOSE("Muon is medium");
598  return xAOD::Muon::Medium;
599  }
600  }
601  }
602 
603  // didn't pass the set of requirements for a medium SAF muon
604  ATH_MSG_VERBOSE("Muon did not pass selection for medium silicon-associated forward muon - return VeryLoose");
605  return xAOD::Muon::VeryLoose;
606  }
607 
608  ATH_MSG_VERBOSE("Muon did not pass selection for loose/medium/tight for any muon type - return VeryLoose");
609  return xAOD::Muon::VeryLoose;
610  }

◆ 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 1482 of file MuonSelectionTool.cxx.

1482  {
1483  // Resolutions have only been evaluated for medium combined muons
1484  if (mu.muonType() != xAOD::Muon::Combined || getQuality(mu) > xAOD::Muon::Medium) return ResolutionCategory::unclassified;
1485 
1486  // :: Access MS hits information
1487  hitSummary summary{};
1488  fillSummary(mu, summary);
1489 
1490  // For muons passing the high-pT working point, distinguish between 2-station tracks and the rest
1491  if (passedHighPtCuts(mu)) {
1492  if (summary.nprecisionLayers == 2)
1493  return ResolutionCategory::highPt2station;
1494  else
1495  return ResolutionCategory::highPt;
1496  }
1497 
1498  const xAOD::TrackParticle* CB_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
1499  const xAOD::TrackParticle* MS_track = mu.trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
1500  if (!MS_track) {
1501  ATH_MSG_VERBOSE("getResolutionCategory - No MS track available for muon. Using combined track.");
1502  MS_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
1503  }
1504 
1505  if (!MS_track || !CB_track) return ResolutionCategory::unclassified;
1506  const float etaMS = MS_track->eta();
1507  const float etaCB = CB_track->eta();
1508  const float phiMS = MS_track->phi();
1509 
1510  int category = ResolutionCategory::unclassified;
1511 
1512  if ((summary.isSmallGoodSectors && summary.innerSmallHits < 3) || (!summary.isSmallGoodSectors && summary.innerLargeHits < 3))
1513  category = ResolutionCategory::missingInner; // missing-inner
1514 
1515  if ((summary.isSmallGoodSectors && summary.middleSmallHits < 3) || (!summary.isSmallGoodSectors && summary.middleLargeHits < 3))
1516  category = ResolutionCategory::missingMiddle; // missing-middle
1517 
1518  if ((summary.isSmallGoodSectors && summary.outerSmallHits < 3 && summary.extendedSmallHits < 3) ||
1519  (!summary.isSmallGoodSectors && summary.outerLargeHits < 3 && summary.extendedLargeHits < 3))
1520  category = ResolutionCategory::missingOuter; // missing-outer
1521 
1522  if (!isRun3() && (std::abs(etaMS) > 2.0 || std::abs(etaCB) > 2.0) && summary.cscUnspoiledEtaHits == 0)
1523  category = ResolutionCategory::spoiledCSC; // spoiled CSC
1524 
1525  if ((1.01 < std::abs(etaMS) && std::abs(etaMS) < 1.1) || (1.01 < std::abs(etaCB) && std::abs(etaCB) < 1.1))
1526  category = ResolutionCategory::BEoverlap; // barrel-end-cap overlap
1527 
1528  if (isBIS78(etaMS, phiMS)) category = ResolutionCategory::BIS78; // BIS7/8
1529 
1530  //::: BEE
1531  if (isBEE(etaMS, phiMS) || (std::abs(etaCB) > 1.4 && (summary.extendedSmallHits > 0 || summary.extendedSmallHoles > 0))) {
1532  if (summary.extendedSmallHits < 3 && summary.middleSmallHits >= 3 && summary.outerSmallHits >= 3)
1533  category = ResolutionCategory::missingBEE; // missing-BEE
1534 
1535  if (summary.extendedSmallHits >= 3 && summary.outerSmallHits < 3) category = ResolutionCategory::missingOuter; // missing-outer
1536 
1537  if (!summary.isSmallGoodSectors)
1538  category = ResolutionCategory::unclassified; // ambiguity due to eta/phi differences between MS and CB track
1539  }
1540 
1541  if (summary.nprecisionLayers == 1) category = ResolutionCategory::oneStation; // one-station track
1542 
1543  return category;
1544  }

◆ getRunNumber()

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

Definition at line 1548 of file MuonSelectionTool.cxx.

1548  {
1549 
1550  static const SG::AuxElement::ConstAccessor<unsigned int> acc_rnd("RandomRunNumber");
1551 
1552  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
1553  //overwrite run number
1554  unsigned int runNumber = 0;
1555  if(m_expertMode_RunNumber.value()!=0) runNumber=m_expertMode_RunNumber.value();
1556  else runNumber = eventInfo->runNumber();
1557 
1558  // Case of data
1559  if (!eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
1560  ATH_MSG_DEBUG("The current event is a data event. Return runNumber.");
1561  return runNumber;
1562  }
1563 
1564  // Case of MC
1565  // attempt to get the run number assigned by the PRW tool
1566  static std::atomic<bool> issuedWarningPRW{false};
1567  if (acc_rnd.isAvailable(*eventInfo)) {
1568  unsigned int rn = acc_rnd(*eventInfo);
1569  if (rn != 0) return acc_rnd(*eventInfo);
1570 
1571  if (!issuedWarningPRW) {
1572  ATH_MSG_WARNING("Pile up tool has assigned runNumber = 0");
1573  issuedWarningPRW = true;
1574  }
1575  }
1576 
1577  // otherwise return a dummy run number
1578  if (needOnlyCorrectYear) {
1579  if (runNumber < 300000) { // mc16a (2016): 284500
1580  ATH_MSG_DEBUG("Random run number not available and this is mc16a or mc20a, returning dummy 2016 run number.");
1581  return 311071;
1582 
1583  } else if (runNumber < 310000) { // mc16d (2017): 300000
1584  ATH_MSG_DEBUG("Random run number not available and this is mc16d or mc20d, returning dummy 2017 run number.");
1585  return 340072;
1586 
1587  } else if (runNumber < 320000) { // mc16e (2018): 310000
1588  ATH_MSG_DEBUG("Random run number not available and this is mc16e or mc20e, returning dummy 2018 run number.");
1589  return 351359;
1590 
1591  } else if (runNumber < 600000) { //mc21: 330000, mc23a: 410000, mc23c: 450000
1592  ATH_MSG_DEBUG("Random run number not available and this is mc21/mc23, for the time being we're returing a dummy run number.");
1593  return 399999;
1594  } else {
1595  ATH_MSG_DEBUG("Detected some run 4 / phase II runnumber "<<runNumber<<". ");
1596  return 666666;
1597  }
1598 
1599  ATH_MSG_FATAL("Random run number not available, fallback option of using runNumber failed since "<<runNumber<<" cannot be recognised");
1600  throw std::runtime_error("MuonSelectionTool() - need RandomRunNumber decoration by the PileupReweightingTool");
1601  }
1602 
1603  ATH_MSG_FATAL("Failed to find the RandomRunNumber decoration by the PileupReweightingTool");
1604  throw std::runtime_error("MuonSelectionTool() - need RandomRunNumber decoration from PileupReweightingTool");
1605  }

◆ 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 810 of file MuonSelectionTool.cxx.

810  {
811  std::vector<const xAOD::MuonSegment*> segments_sorted;
812  segments_sorted.reserve(mu.nMuonSegments());
813 
814  for (unsigned int i = 0; i < mu.nMuonSegments(); i++) {
815  if (!mu.muonSegment(i))
816  ATH_MSG_WARNING("The muon reports more segments than are available. Please report this to the muon software community!");
817  else
818  segments_sorted.push_back(mu.muonSegment(i));
819  }
820 
821  std::sort(segments_sorted.begin(), segments_sorted.end(), chamberIndexCompare);
822 
823  return segments_sorted;
824  }

◆ 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 1659 of file MuonSelectionTool.cxx.

1659  {
1660  if (!m_calculateTightNNScore)
1661  {
1662  ATH_MSG_ERROR("TightNNScore calculation is disabled. Please set the property CalculateTightNNScore to true.");
1663  throw std::runtime_error("cannot calculate TightNNScore");
1664  }
1665  //this score currently only can be calculated for combined muons
1666  if (mu.muonType() != xAOD::Muon::Combined) return -999;
1667  const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1668  const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
1669  if(!idtrack || !metrack) return -999;
1670  //the score is only calculated for muons which pass the Medium WP
1671  if (getQuality(mu) > xAOD::Muon::Medium) return -999;
1672  //only muons with pt > 4 GeV and |eta|<2.5 are considered
1673  if (std::abs(mu.eta())>2.5) return -999;
1674  if(mu.pt()<4000.) return -999;
1675 
1676  std::vector<float> input_features;
1677  // 1. Fill input features
1678  int mu_author=mu.author();
1679  float mu_rhoPrime=rhoPrime(mu);
1680  float mu_scatteringCurvatureSignificance=0.;
1681  retrieveParam(mu, mu_scatteringCurvatureSignificance, xAOD::Muon::scatteringCurvatureSignificance);
1682  float mu_scatteringNeighbourSignificance=0.;
1683  retrieveParam(mu, mu_scatteringNeighbourSignificance, xAOD::Muon::scatteringNeighbourSignificance);
1684  float mu_momentumBalanceSignificance=0.;
1685  retrieveParam(mu, mu_momentumBalanceSignificance, xAOD::Muon::momentumBalanceSignificance);
1686  float mu_qOverPSignificance=qOverPsignificance(mu);
1687  float mu_reducedChi2=mu.primaryTrackParticle()->chiSquared() / mu.primaryTrackParticle()->numberDoF();
1688  float mu_reducedChi2_ID=idtrack->chiSquared() / idtrack->numberDoF();
1689  float mu_reducedChi2_ME=metrack->chiSquared() / metrack->numberDoF();
1690  float mu_spectrometerFieldIntegral=0.;
1691  retrieveParam(mu, mu_spectrometerFieldIntegral, xAOD::Muon::spectrometerFieldIntegral);
1692  float mu_segmentDeltaEta=0;
1693  retrieveParam(mu, mu_segmentDeltaEta, xAOD::Muon::segmentDeltaEta);
1694  uint8_t mu_numberOfPixelHits=0;
1695  retrieveSummaryValue(mu, mu_numberOfPixelHits, xAOD::SummaryType::numberOfPixelHits);
1696  uint8_t mu_numberOfPixelDeadSensors=0;
1697  retrieveSummaryValue(mu, mu_numberOfPixelDeadSensors, xAOD::SummaryType::numberOfPixelDeadSensors);
1698  uint8_t mu_innerLargeHits=0;
1699  retrieveSummaryValue(mu, mu_innerLargeHits, xAOD::MuonSummaryType::innerLargeHits);
1700  uint8_t mu_innerSmallHits=0;
1701  retrieveSummaryValue(mu, mu_innerSmallHits, xAOD::MuonSummaryType::innerSmallHits);
1702  uint8_t mu_middleLargeHits=0;
1703  retrieveSummaryValue(mu, mu_middleLargeHits, xAOD::MuonSummaryType::middleLargeHits);
1704  uint8_t mu_middleSmallHits=0;
1705  retrieveSummaryValue(mu, mu_middleSmallHits, xAOD::MuonSummaryType::middleSmallHits);
1706  uint8_t mu_outerLargeHits=0;
1707  retrieveSummaryValue(mu, mu_outerLargeHits, xAOD::MuonSummaryType::outerLargeHits);
1708  uint8_t mu_outerSmallHits=0;
1709  retrieveSummaryValue(mu, mu_outerSmallHits, xAOD::MuonSummaryType::outerSmallHits);
1710 
1711  if(!isRun3())
1712  {
1713  input_features = {(float)mu_author,
1714  mu_rhoPrime,
1715  mu_scatteringCurvatureSignificance,
1716  mu_scatteringNeighbourSignificance,
1717  mu_momentumBalanceSignificance,
1718  mu_qOverPSignificance,
1719  mu_reducedChi2,
1720  mu_reducedChi2_ID,
1721  mu_reducedChi2_ME,
1722  mu_spectrometerFieldIntegral,
1723  mu_segmentDeltaEta,
1724  (float)mu_numberOfPixelHits,
1725  (float)mu_numberOfPixelDeadSensors,
1726  (float)mu_innerLargeHits,
1727  (float)mu_innerSmallHits,
1728  (float)mu_middleLargeHits,
1729  (float)mu_middleSmallHits,
1730  (float)mu_outerLargeHits,
1731  (float)mu_outerSmallHits};
1732  }
1733  else
1734  {
1735  uint8_t mu_phiLayer1STGCHits=0;
1736  retrieveSummaryValue(mu, mu_phiLayer1STGCHits, xAOD::MuonSummaryType::phiLayer1STGCHits);
1737  uint8_t mu_phiLayer2STGCHits=0;
1738  retrieveSummaryValue(mu, mu_phiLayer2STGCHits, xAOD::MuonSummaryType::phiLayer2STGCHits);
1739  uint8_t mu_etaLayer1STGCHits=0;
1740  retrieveSummaryValue(mu, mu_etaLayer1STGCHits, xAOD::MuonSummaryType::etaLayer1STGCHits);
1741  uint8_t mu_etaLayer2STGCHits=0;
1742  retrieveSummaryValue(mu, mu_etaLayer2STGCHits, xAOD::MuonSummaryType::etaLayer2STGCHits);
1743  uint8_t mu_MMHits=0;
1744  retrieveSummaryValue(mu, mu_MMHits, xAOD::MuonSummaryType::MMHits);
1745  input_features = {(float)mu_author,
1746  mu_rhoPrime,
1747  mu_scatteringCurvatureSignificance,
1748  mu_scatteringNeighbourSignificance,
1749  mu_momentumBalanceSignificance,
1750  mu_qOverPSignificance,
1751  mu_reducedChi2,
1752  mu_reducedChi2_ID,
1753  mu_reducedChi2_ME,
1754  mu_spectrometerFieldIntegral,
1755  mu_segmentDeltaEta,
1756  (float)mu_numberOfPixelHits,
1757  (float)mu_numberOfPixelDeadSensors,
1758  (float)mu_innerLargeHits,
1759  (float)mu_innerSmallHits,
1760  (float)mu_middleLargeHits,
1761  (float)mu_middleSmallHits,
1762  (float)mu_outerLargeHits,
1763  (float)mu_outerSmallHits,
1764  (float)mu_phiLayer1STGCHits,
1765  (float)mu_phiLayer2STGCHits,
1766  (float)mu_etaLayer1STGCHits,
1767  (float)mu_etaLayer2STGCHits,
1768  (float)mu_MMHits};
1769  }
1770 
1771  float score=-999.;
1772  std::vector<int64_t> inputShape = {1, static_cast<int64_t>(input_features.size())};
1773 
1774  AthInfer::InputDataMap inputData;
1775  inputData["flatten_input"] = std::make_pair(
1776  inputShape, std::move(input_features)
1777  );
1778 
1779  AthInfer::OutputDataMap outputData;
1780  outputData["TightNNScore"] = std::make_pair(
1781  std::vector<int64_t>{1, 1}, std::vector<float>{}
1782  );
1783 
1784  if (!m_onnxTool->inference(inputData, outputData).isSuccess()) {
1785  ATH_MSG_WARNING("ONNX inference failed!");
1786  return -999.;
1787  }
1788  const auto& variant = outputData["TightNNScore"].second;
1789  if (std::holds_alternative<std::vector<float>>(variant)) {
1790  const auto& vec = std::get<std::vector<float>>(variant);
1791  if (!vec.empty()) score = vec[0];
1792  else {
1793  ATH_MSG_WARNING("ONNX output vector is empty!");
1794  return -999.;
1795  }
1796  } else {
1797  ATH_MSG_WARNING("ONNX output is not a float vector!");
1798  return -999.;
1799  }
1800 
1801  ATH_MSG_DEBUG("TightNNScore for muon with pT " << mu.pt() << " GeV, eta " << mu.eta() << " is " << score);
1802 
1803  return score;
1804  }

◆ IdMsPt()

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

Definition at line 381 of file MuonSelectionTool.cxx.

381  {
382  const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
383  const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
384  if (!idtrack || !metrack) idPt = mePt = -1.;
385  else if (m_turnOffMomCorr) {
386  mePt = metrack->pt();
387  idPt = idtrack->pt();
388  } else {
389  if (!mePt_acc.isAvailable(mu) || !idPt_acc.isAvailable(mu)) {
390  ATH_MSG_FATAL("The muon with pT " << mu.pt() * MeVtoGeV << " eta: " << mu.eta() << ", phi:" << mu.phi()
391  << " q:" << mu.charge() << ", author:" << mu.author()
392  << " is not decorated with calibrated momenta. Please fix");
393  throw std::runtime_error("MuonSelectionTool() - qOverP significance calculation failed");
394  }
395  mePt = mePt_acc(mu);
396  idPt = idPt_acc(mu);
397  }
398  }

◆ initialize()

StatusCode CP::MuonSelectionTool::initialize ( )
overridevirtual

Function initialising the tool.

Reimplemented from asg::AsgTool.

Definition at line 64 of file MuonSelectionTool.cxx.

64  {
65 
66  // Greet the user:
67  ATH_MSG_INFO("Initialising...");
68 
69  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.")
70  : ATH_MSG_INFO("Is Run-3 geometry: " << m_isRun3.value());
71  ATH_MSG_INFO("Maximum muon |eta|: " << m_maxEta.value());
72  ATH_MSG_INFO("Muon quality: "<< m_quality.value());
73  if (m_toroidOff) ATH_MSG_INFO("!! CONFIGURED FOR TOROID-OFF COLLISIONS !!");
74  if (m_SctCutOff) ATH_MSG_WARNING("!! SWITCHING SCT REQUIREMENTS OFF !! FOR DEVELOPMENT USE ONLY !!");
75  if (m_PixCutOff) ATH_MSG_WARNING("!! SWITCHING PIXEL REQUIREMENTS OFF !! FOR DEVELOPMENT USE ONLY !!");
76  if (m_SiHolesCutOff) ATH_MSG_WARNING("!! SWITCHING SILICON HOLES REQUIREMENTS OFF !! FOR DEVELOPMENT USE ONLY !!");
77  if (m_custom_dir != "")
78  ATH_MSG_WARNING("!! SETTING UP WITH USER SPECIFIED INPUT LOCATION \"" << m_custom_dir << "\"!! FOR DEVELOPMENT USE ONLY !! ");
79  if (!m_useAllAuthors)
80  ATH_MSG_WARNING(
81  "Not using allAuthors variable as currently missing in many derivations; LowPtEfficiency working point will always return "
82  "false, but this is expected at the moment. Have a look here: "
83  "https://twiki.cern.ch/twiki/bin/view/Atlas/MuonSelectionToolR21#New_LowPtEfficiency_working_poin");
84 
85  // Print message to ensure that users excluding 2-station muons in the high-pT selection are aware of this
86  if (!m_use2stationMuonsHighPt)
87  ATH_MSG_INFO("You have opted to select only 3-station muons in the high-pT selection! "
88  << "Please feed 'HighPt3Layers' to the 'WorkingPoint' property to retrieve the appropriate scale-factors");
89 
90  // Only an MVA-based selection is defined for segment-tagged muons for the Low-pT working point
91  if (m_useSegmentTaggedLowPt && !m_useMVALowPt) {
92  ATH_MSG_WARNING("No cut-based selection is defined for segment-tagged muons in the Low-pT working point. "
93  << "Please set UseMVALowPt=true if you want to try the UseSegmentTaggedLowPt=true option.");
94  m_useSegmentTaggedLowPt = false;
95  }
96  if (m_useLRT) {
97  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).");
98  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.");
99  }
100 
101  // Set up the TAccept object:
102  m_acceptInfo.addCut("Eta", "Selection of muons according to their pseudorapidity");
103  m_acceptInfo.addCut("IDHits", "Selection of muons according to whether they passed the MCP ID Hit cuts");
104  m_acceptInfo.addCut("Preselection", "Selection of muons according to their type/author");
105  m_acceptInfo.addCut("Quality", "Selection of muons according to their tightness");
106  // Sanity check
107  if (m_quality > 5) {
108  ATH_MSG_ERROR(
109  "Invalid quality (i.e. selection WP) set: "
110  << m_quality
111  << " - it must be an integer between 0 and 5! (0=Tight, 1=Medium, 2=Loose, 3=Veryloose, 4=HighPt, 5=LowPtEfficiency)");
112  return StatusCode::FAILURE;
113  }
114  if (m_quality == 5 && !m_useAllAuthors) {
115  ATH_MSG_ERROR("Cannot use lowPt working point if allAuthors is not available!");
116  return StatusCode::FAILURE;
117  }
118 
119  if(m_caloScoreWP<1 || m_caloScoreWP>4){
120  ATH_MSG_FATAL("CaloScoreWP property must be set to 1, 2, 3 or 4");
121  return StatusCode::FAILURE;
122  }
123 
124  // Load Tight WP cut-map
125  ATH_MSG_INFO("Initialising tight working point histograms...");
126  std::string tightWP_rootFile_fullPath;
127  if (!m_custom_dir.empty()) {
128  tightWP_rootFile_fullPath = PathResolverFindCalibFile(m_custom_dir + "/muonSelection_tightWPHisto.root");
129  } else {
130  tightWP_rootFile_fullPath = PathResolverFindCalibFile(
131  Form("MuonSelectorTools/%s/muonSelection_tightWPHisto.root", m_calibration_version.value().c_str()));
132  }
133 
134  ATH_MSG_INFO("Reading muon tight working point histograms from " << tightWP_rootFile_fullPath);
135  //
136  std::unique_ptr<TFile> file(TFile::Open(tightWP_rootFile_fullPath.c_str(), "READ"));
137 
138  if (!file->IsOpen()) {
139  ATH_MSG_ERROR("Cannot read tight working point file from " << tightWP_rootFile_fullPath);
140  return StatusCode::FAILURE;
141  }
142 
143  // Retrieve all the relevant histograms
144  ATH_CHECK(getHist(file.get(), "tightWP_lowPt_rhoCuts", m_tightWP_lowPt_rhoCuts));
145  ATH_CHECK(getHist(file.get(), "tightWP_lowPt_qOverPCuts", m_tightWP_lowPt_qOverPCuts));
146  ATH_CHECK(getHist(file.get(), "tightWP_mediumPt_rhoCuts", m_tightWP_mediumPt_rhoCuts));
147  ATH_CHECK(getHist(file.get(), "tightWP_highPt_rhoCuts", m_tightWP_highPt_rhoCuts));
148  //
149  file->Close();
150 
151  // Read bad muon veto efficiency histograms
152  std::string BMVcutFile_fullPath = PathResolverFindCalibFile(m_BMVcutFile);
153 
154  ATH_MSG_INFO("Reading bad muon veto cut functions from " << BMVcutFile_fullPath);
155  //
156  std::unique_ptr<TFile> BMVfile(TFile::Open(BMVcutFile_fullPath.c_str(), "READ"));
157 
158  if (!BMVfile->IsOpen()) {
159  ATH_MSG_ERROR("Cannot read bad muon veto cut function file from " << BMVcutFile_fullPath);
160  return StatusCode::FAILURE;
161  }
162 
163  m_BMVcutFunction_barrel = std::unique_ptr<TF1>((TF1*)BMVfile->Get("BMVcutFunction_barrel"));
164  m_BMVcutFunction_endcap = std::unique_ptr<TF1>((TF1*)BMVfile->Get("BMVcutFunction_endcap"));
165 
166  BMVfile->Close();
167 
168  if (!m_BMVcutFunction_barrel || !m_BMVcutFunction_endcap) {
169  ATH_MSG_ERROR("Cannot read bad muon veto cut functions");
170  return StatusCode::FAILURE;
171  }
172 
173  if (m_useMVALowPt) {
174  // Set up TMVA readers for MVA-based low-pT working point
175  // E and O refer to even and odd event numbers to avoid applying the MVA on events used for training
176  TString weightPath_EVEN_MuidCB = PathResolverFindCalibFile(m_MVAreaderFile_EVEN_MuidCB);
177  TString weightPath_ODD_MuidCB = PathResolverFindCalibFile(m_MVAreaderFile_ODD_MuidCB);
178  TString weightPath_EVEN_MuGirl = PathResolverFindCalibFile(m_MVAreaderFile_EVEN_MuGirl);
179  TString weightPath_ODD_MuGirl = PathResolverFindCalibFile(m_MVAreaderFile_ODD_MuGirl);
180 
181  auto make_mva_reader = [](TString file_path) {
182  std::vector<std::string> mva_var_names{"momentumBalanceSignificance",
183  "scatteringCurvatureSignificance",
184  "scatteringNeighbourSignificance",
185  "EnergyLoss",
186  "middleLargeHoles+middleSmallHoles",
187  "muonSegmentDeltaEta",
188  "muonSeg1ChamberIdx",
189  "muonSeg2ChamberIdx"};
190  std::unique_ptr<TMVA::Reader> reader = std::make_unique<TMVA::Reader>(mva_var_names);
191  reader->BookMVA("BDTG", file_path);
192  return reader;
193  };
194  m_readerE_MUID = make_mva_reader(weightPath_EVEN_MuidCB);
195 
196  m_readerO_MUID = make_mva_reader(weightPath_ODD_MuidCB);
197 
198  m_readerE_MUGIRL = make_mva_reader(weightPath_EVEN_MuGirl);
199 
200  m_readerO_MUGIRL = make_mva_reader(weightPath_ODD_MuGirl);
201 
202  if (m_useSegmentTaggedLowPt) {
203  TString weightPath_MuTagIMO_etaBin1 = PathResolverFindCalibFile(m_MVAreaderFile_MuTagIMO_etaBin1);
204  TString weightPath_MuTagIMO_etaBin2 = PathResolverFindCalibFile(m_MVAreaderFile_MuTagIMO_etaBin2);
205  TString weightPath_MuTagIMO_etaBin3 = PathResolverFindCalibFile(m_MVAreaderFile_MuTagIMO_etaBin3);
206 
207  auto make_mva_reader_MuTagIMO = [](TString file_path, bool useSeg2ChamberIndex) {
208  std::vector<std::string> mva_var_names;
209  if (useSeg2ChamberIndex) mva_var_names.push_back("muonSeg2ChamberIndex");
210  mva_var_names.push_back("muonSeg1ChamberIndex");
211  mva_var_names.push_back("muonSeg1NPrecisionHits");
212  mva_var_names.push_back("muonSegmentDeltaEta");
213  mva_var_names.push_back("muonSeg1GlobalR");
214  mva_var_names.push_back("muonSeg1Chi2OverDoF");
215  mva_var_names.push_back("muonSCS");
216 
217  std::unique_ptr<TMVA::Reader> reader = std::make_unique<TMVA::Reader>(mva_var_names);
218  reader->BookMVA("BDT", file_path);
219  return reader;
220  };
221 
222  m_reader_MUTAGIMO_etaBin1 = make_mva_reader_MuTagIMO(weightPath_MuTagIMO_etaBin1, false);
223  m_reader_MUTAGIMO_etaBin2 = make_mva_reader_MuTagIMO(weightPath_MuTagIMO_etaBin2, false);
224  m_reader_MUTAGIMO_etaBin3 = make_mva_reader_MuTagIMO(weightPath_MuTagIMO_etaBin3, true);
225  }
226  }
227 
228  ATH_MSG_INFO("TightNNScore calculation is " << (m_calculateTightNNScore ? "enabled." : "disabled."));
229 
230  if (m_calculateTightNNScore) {
231  if (m_onnxTool.empty()) {
232  ATH_MSG_ERROR("Cannot calculate TightNNScore: ONNX tool not configured! "
233  "Please set the ORTInferenceTool property to a valid AthOnnx::OnnxRuntimeInferenceTool instance.");
234  return StatusCode::FAILURE;
235  }
236 
237  ATH_MSG_INFO("Retrieving ONNX tool: " << m_onnxTool.name());
238  ATH_CHECK(m_onnxTool.retrieve());
239  } else ATH_MSG_INFO("ONNX tool not configured — skipping retrieval.");
240 
241  ATH_MSG_INFO("Finished ONNX tool setup");
242 
243  ATH_CHECK(m_eventInfo.initialize());
244  // Return gracefully:
245  return StatusCode::SUCCESS;
246  }

◆ 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 649 of file MuonSelectionTool.cxx.

649  {
650  if (mu.muonType() != xAOD::Muon::Combined) return false;
651  // ::
652  const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
653  const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
654  const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
655  // ::
656  // Some spurious muons are found to have negative ME track fit covariance, and are typically poorly reconstructed
657  if (metrack && metrack->definingParametersCovMatrix()(4, 4) < 0.0) return true;
658  // ::
659  bool IsBadMuon = false;
660  if (idtrack && metrack && cbtrack) {
661  // ::
662  double qOverP_ID = idtrack->qOverP();
663  double qOverPerr_ID = std::sqrt(idtrack->definingParametersCovMatrix()(4, 4));
664  double qOverP_ME = metrack->qOverP();
665  double qOverPerr_ME = std::sqrt(metrack->definingParametersCovMatrix()(4, 4));
666  double qOverP_CB = cbtrack->qOverP();
667  double qOverPerr_CB = std::sqrt(cbtrack->definingParametersCovMatrix()(4, 4));
668  // ::
669  if (m_quality == 4) {
670  // recipe for high-pt selection
671  IsBadMuon = !passedErrorCutCB(mu);
672 
673  hitSummary summary{};
674  fillSummary(mu, summary);
675 
676  // temporarily apply same recipe as for other working points in addition to CB error
677  // cut for 2-station muons, pending better treatment of ID/MS misalignments
678  if (m_use2stationMuonsHighPt && summary.nprecisionLayers == 2) {
679  double IdCbRatio = std::abs((qOverPerr_ID / qOverP_ID) / (qOverPerr_CB / qOverP_CB));
680  double MeCbRatio = std::abs((qOverPerr_ME / qOverP_ME) / (qOverPerr_CB / qOverP_CB));
681  IsBadMuon = (IdCbRatio < 0.8 || MeCbRatio < 0.8 || IsBadMuon);
682  }
683  } else {
684  // recipe for other WP
685  double IdCbRatio = std::abs((qOverPerr_ID / qOverP_ID) / (qOverPerr_CB / qOverP_CB));
686  double MeCbRatio = std::abs((qOverPerr_ME / qOverP_ME) / (qOverPerr_CB / qOverP_CB));
687  IsBadMuon = (IdCbRatio < 0.8 || MeCbRatio < 0.8);
688  }
689  } else {
690  return true;
691  }
692  return IsBadMuon;
693  }

◆ isBEE()

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

Check if muon eta/phi falls in BEE chambers.

Definition at line 1627 of file MuonSelectionTool.cxx.

1627  {
1628  static constexpr std::array<float, 2> BEE_eta{1.440, 1.692};
1629  static constexpr std::array<float, 8> BEE_phi{0.301, 0.478, 1.086, 1.263, 1.872, 2.049, 2.657, 2.834};
1630 
1631  float abs_eta = std::abs(eta);
1632  float abs_phi = std::abs(phi);
1633 
1634  if (abs_eta >= BEE_eta[0] && abs_eta <= BEE_eta[1]) {
1635  if ((abs_phi >= BEE_phi[0] && abs_phi <= BEE_phi[1]) || (abs_phi >= BEE_phi[2] && abs_phi <= BEE_phi[3]) ||
1636  (abs_phi >= BEE_phi[4] && abs_phi <= BEE_phi[5]) || (abs_phi >= BEE_phi[6] && abs_phi <= BEE_phi[7])) {
1637  return true;
1638  }
1639  }
1640 
1641  return false;
1642  }

◆ 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 1609 of file MuonSelectionTool.cxx.

1609  {
1610  static constexpr std::array<float, 2> BIS78_eta{1.05, 1.3};
1611  static constexpr std::array<float, 8> BIS78_phi{0.21, 0.57, 1.00, 1.33, 1.78, 2.14, 2.57, 2.93};
1612 
1613  float abs_eta = std::abs(eta);
1614  float abs_phi = std::abs(phi);
1615 
1616  if (abs_eta >= BIS78_eta[0] && abs_eta <= BIS78_eta[1]) {
1617  if ((abs_phi >= BIS78_phi[0] && abs_phi <= BIS78_phi[1]) || (abs_phi >= BIS78_phi[2] && abs_phi <= BIS78_phi[3]) ||
1618  (abs_phi >= BIS78_phi[4] && abs_phi <= BIS78_phi[5]) || (abs_phi >= BIS78_phi[6] && abs_phi <= BIS78_phi[7])) {
1619  return true;
1620  }
1621  }
1622 
1623  return false;
1624  }

◆ isBMG()

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

Check if muon eta/phi falls in BMG chambers.

Definition at line 1645 of file MuonSelectionTool.cxx.

1645  {
1646  static constexpr std::array<float, 6> BMG_eta{0.35, 0.47, 0.68, 0.80, 0.925, 1.04};
1647  static constexpr std::array<float, 4> BMG_phi{-1.93, -1.765, -1.38, -1.21};
1648 
1649  float abs_eta = std::abs(eta);
1650 
1651  if ((abs_eta >= BMG_eta[0] && abs_eta <= BMG_eta[1]) || (abs_eta >= BMG_eta[2] && abs_eta <= BMG_eta[3]) ||
1652  (abs_eta >= BMG_eta[4] && abs_eta <= BMG_eta[5])) {
1653  if ((phi >= BMG_phi[0] && phi <= BMG_phi[1]) || (phi >= BMG_phi[2] && phi <= BMG_phi[3])) { return true; }
1654  }
1655 
1656  return false;
1657  }

◆ isRun3()

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

Definition at line 276 of file MuonSelectionTool.h.

276  {
277  if (!m_geoOnTheFly && !forceOnTheFly) return m_isRun3;
278  int rn = getRunNumber(true);
279  return rn>=399999;
280  }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msg_level_name()

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

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

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

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

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

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

Definition at line 101 of file AsgTool.cxx.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ 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 1220 of file MuonSelectionTool.cxx.

1220  {
1221  TF1* cutFunction;
1222  double p1, p2;
1223  if (std::abs(mu.eta()) < 1.05) {
1224  cutFunction = m_BMVcutFunction_barrel.get();
1225  p1 = 0.066265;
1226  p2 = 0.000210047;
1227  } else {
1228  cutFunction = m_BMVcutFunction_endcap.get();
1229  p1 = 0.0629747;
1230  p2 = 0.000196466;
1231  }
1232 
1233  double qOpRelResolution = std::hypot(p1, p2 * mu.primaryTrackParticle()->pt() * MeVtoGeV);
1234 
1235  double qOverPabs_unsmeared = std::abs(mu.primaryTrackParticle()->definingParameters()[4]);
1236  double qOverPabs_smeared = 1.0 / (mu.pt() * std::cosh(mu.eta()));
1237 
1238  if ((qOverPabs_smeared - qOverPabs_unsmeared) / (qOpRelResolution * qOverPabs_unsmeared) <
1239  cutFunction->Eval(mu.primaryTrackParticle()->pt() * MeVtoGeV))
1240  return false;
1241  else
1242  return true;
1243  }

◆ 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 1317 of file MuonSelectionTool.cxx.

1317  {
1318  // We use a working point with a pT-dependent cut on the NN discriminant, designed to achieve a constant
1319  // fakes rejection as function of pT in Z->mumu MC
1320 
1321  // Extract the relevant score variable (NN discriminant)
1322 
1323  float CaloMuonScore{-999.0};
1324  retrieveParam(mu, CaloMuonScore, xAOD::Muon::CaloMuonScore);
1325 
1326  if(m_caloScoreWP==1) return (CaloMuonScore >= 0.92);
1327  if(m_caloScoreWP==2) return (CaloMuonScore >= 0.56);
1328  else if(m_caloScoreWP==3 || m_caloScoreWP==4)
1329  {
1330  // Cut on the score variable
1331  float pT = mu.pt() * MeVtoGeV; // GeV
1332 
1333  if (pT > 20.0) // constant cut above 20 GeV
1334  return (CaloMuonScore >= 0.77);
1335  else {
1336  // pT-dependent cut below 20 GeV
1337  // The pT-dependent cut is based on a fit of a third-degree polynomial, with coefficients as given below
1338 
1339  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));
1340  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));
1341  }
1342  }
1343 
1344  return false;
1345  }

◆ 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 1296 of file MuonSelectionTool.cxx.

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

◆ 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 1115 of file MuonSelectionTool.cxx.

1115  {
1116  // ::
1117  if (mu.muonType() != xAOD::Muon::Combined) return false;
1118  // ::
1119  double start_cut = 3.0;
1120  double end_cut = 1.6;
1121  double abs_eta = std::abs(mu.eta());
1122 
1123  // parametrization of expected q/p error as function of pT
1124  double p0(8.0), p1(0.), p2(0.);
1125  if(isRun3()) //MC21 optimization
1126  {
1127  if(abs_eta<=1.05){
1128  p1=0.046;
1129  p2=0.00005;
1130  }
1131  else if (abs_eta > 1.05 && abs_eta <= 1.3) {
1132  p1 = 0.052;
1133  p2 = 0.00008;
1134  } else if (abs_eta > 1.3 && abs_eta <= 1.7) {
1135  p1 = 0.068;
1136  p2 = 0.00006;
1137  } else if (abs_eta > 1.7 && abs_eta <= 2.0) {
1138  p1 = 0.048;
1139  p2 = 0.00006;
1140  } else if (abs_eta > 2.0) {
1141  p1 = 0.037;
1142  p2 = 0.00006;
1143  }
1144  }
1145  else
1146  {
1147  if(abs_eta<=1.05){
1148  p1=0.039;
1149  p2=0.00006;
1150  }
1151  else if (abs_eta > 1.05 && abs_eta <= 1.3) {
1152  p1 = 0.040;
1153  p2 = 0.00009;
1154  } else if (abs_eta > 1.3 && abs_eta <= 1.7) {
1155  p1 = 0.056;
1156  p2 = 0.00008;
1157  } else if (abs_eta > 1.7 && abs_eta <= 2.0) {
1158  p1 = 0.041;
1159  p2 = 0.00006;
1160  } else if (abs_eta > 2.0) {
1161  p1 = 0.031;
1162  p2 = 0.00006;
1163  }
1164  }
1165  // ::
1166  hitSummary summary{};
1167  fillSummary(mu, summary);
1168 
1169  // independent parametrization for 2-station muons
1170  if (m_use2stationMuonsHighPt && summary.nprecisionLayers == 2) {
1171  start_cut = 1.1;
1172  end_cut=0.7;
1173  p1 = 0.0739568;
1174  p2 = 0.00012443;
1175  if (abs_eta > 1.05 && abs_eta < 1.3) {
1176  p1 = 0.0674484;
1177  p2 = 0.000119879;
1178  } else if (abs_eta >= 1.3 && abs_eta < 1.7) {
1179  p1 = 0.041669;
1180  p2 = 0.000178349;
1181  } else if (abs_eta >= 1.7 && abs_eta < 2.0) {
1182  p1 = 0.0488664;
1183  p2 = 0.000137648;
1184  } else if (abs_eta >= 2.0) {
1185  p1 = 0.028077;
1186  p2 = 0.000152707;
1187  }
1188  }
1189  // ::
1190  bool passErrorCutCB = false;
1191  const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
1192  if (cbtrack) {
1193  // ::
1194  double pt_CB = (cbtrack->pt() * MeVtoGeV < 5000.) ? cbtrack->pt() * MeVtoGeV : 5000.; // GeV
1195  double qOverP_CB = cbtrack->qOverP();
1196  double qOverPerr_CB = std::sqrt(cbtrack->definingParametersCovMatrix()(4, 4));
1197  // sigma represents the average expected error at the muon's pt/eta
1198  double sigma = std::sqrt(std::pow(p0 / pt_CB, 2) + std::pow(p1, 2) + std::pow(p2 * pt_CB, 2));
1199  // cutting at start_cut*sigma for pt <=1 TeV depending on eta region,
1200  // then linearly tightening until end_cut*sigma is reached at pt >= 5TeV.
1201  double a = (end_cut - start_cut) / 4000.0;
1202  double b = end_cut - a * 5000.0;
1203  double coefficient = (pt_CB > 1000.) ? (a * pt_CB + b) : start_cut;
1204  if (std::abs(qOverPerr_CB / qOverP_CB) < coefficient * sigma) { passErrorCutCB = true; }
1205  }
1206  // ::
1207  if (m_use2stationMuonsHighPt && m_doBadMuonVetoMimic && summary.nprecisionLayers == 2) {
1208  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
1209 
1210  if (eventInfo->eventType(xAOD::EventInfo::IS_SIMULATION)) {
1211  ATH_MSG_DEBUG("The current event is a MC event. Use bad muon veto mimic.");
1212  return passErrorCutCB && passedBMVmimicCut(mu);
1213  }
1214  }
1215 
1216  // ::
1217  return passErrorCutCB;
1218  }

◆ 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 937 of file MuonSelectionTool.cxx.

937  {
938  ATH_MSG_VERBOSE("Checking whether muon passes high-pT selection...");
939 
940  // :: Request combined muons
941  if (mu.muonType() != xAOD::Muon::Combined) {
942  ATH_MSG_VERBOSE("Muon is not combined - fail high-pT");
943  return false;
944  }
945  if (mu.author() == xAOD::Muon::STACO) {
946  ATH_MSG_VERBOSE("Muon is STACO - fail high-pT");
947  return false;
948  }
949 
950  // :: Reject muons with out-of-bounds hits
951  uint8_t combinedTrackOutBoundsPrecisionHits{0};
952  retrieveSummaryValue(mu, combinedTrackOutBoundsPrecisionHits, xAOD::MuonSummaryType::combinedTrackOutBoundsPrecisionHits);
953  if (combinedTrackOutBoundsPrecisionHits > 0) {
954  ATH_MSG_VERBOSE("Muon has out-of-bounds precision hits - fail high-pT");
955  return false;
956  }
957 
958  // :: Access MS hits information
959  hitSummary summary{};
960  fillSummary(mu, summary);
961 
962 
963  ATH_MSG_VERBOSE("number of precision layers: " << (int)summary.nprecisionLayers);
964 
965  //::: Apply MS Chamber Vetoes
966  // Given according to their eta-phi locations in the muon spectrometer
967  // FORM: CHAMBERNAME[ array of four values ] = { eta 1, eta 2, phi 1, phi 2}
968  // The vetoes are applied based on the MS track if available. If the MS track is not available,
969  // the vetoes are applied according to the combined track, and runtime warning is printed to
970  // the command line.
971  const xAOD::TrackParticle* CB_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
972  const xAOD::TrackParticle* MS_track = mu.trackParticle(xAOD::Muon::MuonSpectrometerTrackParticle);
973  if (!MS_track) {
974  ATH_MSG_VERBOSE("passedHighPtCuts - No MS track available for muon. Using combined track.");
975  MS_track = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
976  }
977 
978  if (MS_track && CB_track) {
979  float etaMS = MS_track->eta();
980  float phiMS = MS_track->phi();
981  float etaCB = CB_track->eta();
982 
983  //::: no unspoiled clusters in CSC
984  if (!isRun3() && (std::abs(etaMS) > 2.0 || std::abs(etaCB) > 2.0)) {
985  if (summary.cscUnspoiledEtaHits == 0) {
986  ATH_MSG_VERBOSE("Muon has only spoiled CSC clusters - fail high-pT");
987  return false;
988  }
989  }
990 
991  // veto bad CSC giving troubles with scale factors
992  if (!isRun3() && mu.eta() < -1.899 && std::abs(mu.phi()) < 0.211) {
993  ATH_MSG_VERBOSE("Muon is in eta/phi region vetoed due to disabled chambers in MC - fail high-pT");
994  return false;
995  }
996 
997  //::: Barrel/Endcap overlap region
998  if ((1.01 < std::abs(etaMS) && std::abs(etaMS) < 1.1) || (1.01 < std::abs(etaCB) && std::abs(etaCB) < 1.1)) {
999  ATH_MSG_VERBOSE("Muon is in barrel/endcap overlap region - fail high-pT");
1000  return false;
1001  }
1002 
1003  //::: BIS78
1004  if (isBIS78(etaMS, phiMS)) {
1005  if (!isRun3() || !m_useBEEBISInHighPtRun3) {
1006  ATH_MSG_VERBOSE("Muon is in BIS7/8 eta/phi region - fail high-pT");
1007  return false;
1008  }
1009  }
1010 
1013  //if (getRunNumber(true) >= 324320) {
1014  //if (isBMG(etaMS, phiMS)) {
1015  //ATH_MSG_VERBOSE("Muon is in BMG eta/phi region - fail high-pT");
1016  //return false;
1017  //}
1018  //}
1019 
1020  //::: BEE
1021  if (isBEE(etaMS, phiMS)) {
1022  // in Run3, large mis-alignment on the BEE chamber was found. temporarily mask the BEE region
1023  if (isRun3() && !m_useBEEBISInHighPtRun3) {
1024  ATH_MSG_VERBOSE("Muon is in BEE eta/phi region - fail high-pT");
1025  return false;
1026  }
1027  // Muon falls in the BEE eta-phi region: asking for 4 good precision layers
1028  // if( nGoodPrecLayers < 4 ) return false; // postponed (further studies needed)
1029  if (summary.nprecisionLayers < 4) {
1030  ATH_MSG_VERBOSE("Muon is in BEE eta/phi region and does not have 4 precision layers - fail high-pT");
1031  return false;
1032  }
1033  }
1034  if (std::abs(etaCB) > 1.4) {
1035  // Veto residual 3-station muons in BEE region due to MS eta/phi resolution effects
1036  // if( nGoodPrecLayers<4 && (extendedSmallHits>0||extendedSmallHoles>0) ) return false; // postponed (further studies
1037  // needed)
1038  if (summary.nprecisionLayers < 4 && (summary.extendedSmallHits > 0 || summary.extendedSmallHoles > 0)) {
1039  ATH_MSG_VERBOSE("Muon is in BEE eta/phi region and does not have 4 precision layers - fail high-pT");
1040  return false;
1041  }
1042  }
1043  } else {
1044  ATH_MSG_WARNING("passedHighPtCuts - MS or CB track missing in muon! Failing High-pT selection...");
1045  return false;
1046  }
1047 
1048  //::: Apply 1/p significance cut
1049  const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
1050  const xAOD::TrackParticle* metrack = mu.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
1051  if (idtrack && metrack && metrack->definingParametersCovMatrix()(4, 4) > 0) { const float qOverPsignif = qOverPsignificance(mu);
1052 
1053  ATH_MSG_VERBOSE("qOverP significance: " << qOverPsignif);
1054 
1055  if (std::abs(qOverPsignif) > 7) {
1056  ATH_MSG_VERBOSE("Muon failed qOverP significance cut");
1057  return false;
1058  }
1059  } else {
1060  ATH_MSG_VERBOSE("Muon missing ID or ME tracks - fail high-pT");
1061  return false;
1062  }
1063 
1064  // Accept good 2-station muons if the user has opted to include these
1065  if (m_use2stationMuonsHighPt && summary.nprecisionLayers == 2) {
1066  // should not accept EM+EO muons due to ID/MS alignment issues
1067  if (std::abs(mu.eta()) > 1.2 && summary.extendedSmallHits < 3 && summary.extendedLargeHits < 3) {
1068  ATH_MSG_VERBOSE("2-station muon with EM+EO - fail high-pT");
1069  return false;
1070  }
1071 
1072  // only select muons missing the inner precision layer
1073  // apply strict veto on overlap between small and large sectors
1074 
1075  if (summary.innerLargeHits == 0 && summary.middleLargeHits == 0 && summary.outerLargeHits == 0 &&
1076  summary.extendedLargeHits == 0 && summary.middleSmallHits > 2 &&
1077  (summary.outerSmallHits > 2 || summary.extendedSmallHits > 2)) {
1078  ATH_MSG_VERBOSE("Accepted 2-station muon in small sector");
1079  return true;
1080  }
1081 
1082  if (summary.innerSmallHits == 0 && summary.middleSmallHits == 0 && summary.outerSmallHits == 0 &&
1083  summary.extendedSmallHits == 0 && summary.middleLargeHits > 2 &&
1084  (summary.outerLargeHits > 2 || summary.extendedLargeHits > 2)) {
1085  ATH_MSG_VERBOSE("Accepted 2-station muon in large sector");
1086  return true;
1087  }
1088  }
1089 
1090  //::: Require 3 (good) station muons
1091  if (summary.nprecisionLayers < 3) {
1092  ATH_MSG_VERBOSE("Muon has less than 3 precision layers - fail high-pT");
1093  return false;
1094  }
1095 
1096  // Remove 3-station muons with small-large sectors overlap
1097  if (summary.isSmallGoodSectors) {
1098  if (!(summary.innerSmallHits > 2 && summary.middleSmallHits > 2 &&
1099  (summary.outerSmallHits > 2 || summary.extendedSmallHits > 2))) {
1100  ATH_MSG_VERBOSE("Muon has small/large sectors overlap - fail high-pT");
1101  return false;
1102  }
1103  } else {
1104  if (!(summary.innerLargeHits > 2 && summary.middleLargeHits > 2 &&
1105  (summary.outerLargeHits > 2 || summary.extendedLargeHits > 2))) {
1106  ATH_MSG_VERBOSE("Muon has small/large sectors overlap - fail high-pT");
1107  return false;
1108  }
1109  }
1110 
1111  ATH_MSG_VERBOSE("Muon passed high-pT selection");
1112  return true;
1113  }

◆ 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 614 of file MuonSelectionTool.cxx.

614  {
615  if (m_useLRT) {
616  static const SG::AuxElement::Accessor<char> isLRTmuon("isLRT");
617  if (isLRTmuon.isAvailable(mu)) {
618  if (isLRTmuon(mu)) return true;
619  }
620  else {
621  static const SG::AuxElement::Accessor<uint64_t> patternAcc("patternRecoInfo");
622  const xAOD::TrackParticle* idtrack = mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
623  if(idtrack) {
624  if(!patternAcc.isAvailable(*idtrack)) {
625  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.");
626  throw std::runtime_error("MuonSelectionTool() - isLRT decor and patternRecoInfo both unavailable for a muon.");
627  }
628  std::bitset<xAOD::NumberOfTrackRecoInfo> patternBitSet(patternAcc(*idtrack));
629  if (patternBitSet.test(xAOD::SiSpacePointsSeedMaker_LargeD0)) return true;
630  }
631  }
632  }
633  // do not apply the ID hit requirements for SA muons for |eta| > 2.5
634  if (mu.author() == xAOD::Muon::MuidSA && std::abs(mu.eta()) > 2.5) {
635  return true;
636  } else if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
637  const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
638  if (cbtrack && std::abs(cbtrack->eta()) > 2.5) { return true; }
639  return false;
640  } else {
641  if (mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle))
642  return passedIDCuts(*mu.trackParticle(xAOD::Muon::InnerDetectorTrackParticle));
643  else if (mu.primaryTrackParticle())
644  return passedIDCuts(*mu.primaryTrackParticle());
645  }
646  return false;
647  }

◆ passedIDCuts() [2/2]

bool CP::MuonSelectionTool::passedIDCuts ( const xAOD::TrackParticle &  track) const
overridevirtual

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

Implements CP::IMuonSelectionTool.

Definition at line 1264 of file MuonSelectionTool.cxx.

1264  {
1265  uint8_t value1{0}, value2{0};
1266 
1267  if ((m_PixCutOff || m_SctCutOff || m_SiHolesCutOff) && !m_developMode)
1268  ATH_MSG_WARNING(
1269  " !! Tool configured with some of the ID hits requirements changed... FOR DEVELOPMENT ONLY: muon efficiency SF won't be "
1270  "valid !! ");
1271 
1272  retrieveSummaryValue(track, value1, xAOD::SummaryType::numberOfPixelHits);
1273  retrieveSummaryValue(track, value2, xAOD::SummaryType::numberOfPixelDeadSensors);
1274  if ((value1 + value2 == 0) && !m_PixCutOff) return false;
1275 
1276  retrieveSummaryValue(track, value1, xAOD::SummaryType::numberOfSCTHits);
1277  retrieveSummaryValue(track, value2, xAOD::SummaryType::numberOfSCTDeadSensors);
1278  if ((value1 + value2 <= 4) && !m_SctCutOff) return false;
1279 
1280  retrieveSummaryValue(track, value1, xAOD::SummaryType::numberOfPixelHoles);
1281  retrieveSummaryValue(track, value2, xAOD::SummaryType::numberOfSCTHoles);
1282  if ((value1 + value2 >= 3) && !m_SiHolesCutOff) return false;
1283 
1284  if (!m_TrtCutOff) {
1285  const float abseta = std::abs(track.eta());
1286  retrieveSummaryValue(track, value1, xAOD::SummaryType::numberOfTRTHits);
1287  retrieveSummaryValue(track, value2, xAOD::SummaryType::numberOfTRTOutliers);
1288  const uint8_t totTRThits = value1 + value2;
1289  if (!((0.1 < abseta && abseta <= 1.9 && totTRThits > 5 && value2 < (0.9 * totTRThits)) || (abseta <= 0.1 || abseta > 1.9)))
1290  return false;
1291  }
1292  // Reached end - all ID hit cuts are passed.
1293  return true;
1294  } // passedIDCuts

◆ 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 695 of file MuonSelectionTool.cxx.

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

◆ passedLowPtEfficiencyCuts() [2/2]

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

Implements CP::IMuonSelectionTool.

Definition at line 700 of file MuonSelectionTool.cxx.

700  {
701  ATH_MSG_VERBOSE("Checking whether muon passes low-pT selection...");
702 
703  if (!m_useAllAuthors) { // no allAuthors, always fail the WP
704  ATH_MSG_VERBOSE("Do not have allAuthors variable - fail low-pT");
705  return false;
706  }
707 
708  // requiring combined muons, unless segment-tags are included
709  if (!m_useSegmentTaggedLowPt) {
710  if (mu.muonType() != xAOD::Muon::Combined) {
711  ATH_MSG_VERBOSE("Muon is not combined - fail low-pT");
712  return false;
713  }
714  } else {
715  if (mu.muonType() != xAOD::Muon::Combined && mu.muonType() != xAOD::Muon::SegmentTagged) {
716  ATH_MSG_VERBOSE("Muon is not combined or segment-tagged - fail low-pT");
717  return false;
718  }
719  }
720 
721  // author check
722  if (!m_useSegmentTaggedLowPt) {
723  if (mu.author() != xAOD::Muon::MuGirl && mu.author() != xAOD::Muon::MuidCo) {
724  ATH_MSG_VERBOSE("Muon is neither MuGirl nor MuidCo - fail low-pT");
725  return false;
726  }
727  } else {
728  if (mu.author() != xAOD::Muon::MuGirl && mu.author() != xAOD::Muon::MuidCo && mu.author() != xAOD::Muon::MuTagIMO) {
729  ATH_MSG_VERBOSE("Muon is neither MuGirl / MuidCo / MuTagIMO - fail low-pT");
730  return false;
731  }
732  }
733 
734  // applying Medium selection above pT = 18 GeV
735  if (mu.pt() * MeVtoGeV > 18.) {
736  ATH_MSG_VERBOSE("pT > 18 GeV - apply medium selection");
737  if (thisMu_quality <= xAOD::Muon::Medium) {
738  ATH_MSG_VERBOSE("Muon passed low-pT selection");
739  return true;
740  } else {
741  ATH_MSG_VERBOSE("Muon failed low-pT selection");
742  return false;
743  }
744  }
745 
746  // requiring Medium in forward regions
747  if (!m_useMVALowPt && std::abs(mu.eta()) > 1.55 && thisMu_quality > xAOD::Muon::Medium) {
748  ATH_MSG_VERBOSE("Not using MVA selection, failing low-pT selection due to medium requirement in forward region");
749  return false;
750  }
751 
752  // rejection of muons with out-of-bounds hits
753  uint8_t combinedTrackOutBoundsPrecisionHits{0};
754  retrieveSummaryValue(mu, combinedTrackOutBoundsPrecisionHits, xAOD::MuonSummaryType::combinedTrackOutBoundsPrecisionHits);
755  if (combinedTrackOutBoundsPrecisionHits > 0) {
756  ATH_MSG_VERBOSE("Muon has out-of-bounds precision hits - fail low-pT");
757  return false;
758  }
759 
760  // requiring explicitely >=1 station (2 in the |eta|>1.3 region when Medium selection is not explicitely required)
761  if (mu.muonType() == xAOD::Muon::Combined) {
762  hitSummary summary{};
763  fillSummary(mu, summary);
764  uint nStationsCut = (std::abs(mu.eta()) > 1.3 && std::abs(mu.eta()) < 1.55) ? 2 : 1;
765  if (summary.nprecisionLayers < nStationsCut) {
766  ATH_MSG_VERBOSE("number of precision layers = " << (int)summary.nprecisionLayers << " is lower than cut value " << nStationsCut
767  << " - fail low-pT");
768  return false;
769  }
770  }
771 
772  // reject MuGirl muon if not found also by MuTagIMO
773  if (m_useAllAuthors) {
774  if (mu.author() == xAOD::Muon::MuGirl && !mu.isAuthor(xAOD::Muon::MuTagIMO)) {
775  ATH_MSG_VERBOSE("MuGirl muon is not confirmed by MuTagIMO - fail low-pT");
776  return false;
777  }
778  } else
779  return false;
780 
781  if (m_useMVALowPt) {
782  ATH_MSG_VERBOSE("Applying MVA-based selection");
783  return passedLowPtEfficiencyMVACut(mu);
784  }
785 
786  ATH_MSG_VERBOSE("Applying cut-based selection");
787 
788  // apply some loose quality requirements
789  float momentumBalanceSignificance{0.}, scatteringCurvatureSignificance{0.}, scatteringNeighbourSignificance{0.};
790 
791  retrieveParam(mu, momentumBalanceSignificance, xAOD::Muon::momentumBalanceSignificance);
792  retrieveParam(mu, scatteringCurvatureSignificance, xAOD::Muon::scatteringCurvatureSignificance);
793  retrieveParam(mu, scatteringNeighbourSignificance, xAOD::Muon::scatteringNeighbourSignificance);
794 
795  ATH_MSG_VERBOSE("momentum balance significance: " << momentumBalanceSignificance);
796  ATH_MSG_VERBOSE("scattering curvature significance: " << scatteringCurvatureSignificance);
797  ATH_MSG_VERBOSE("scattering neighbour significance: " << scatteringNeighbourSignificance);
798 
799  if (std::abs(momentumBalanceSignificance) > 3. || std::abs(scatteringCurvatureSignificance) > 3. ||
800  std::abs(scatteringNeighbourSignificance) > 3.) {
801  ATH_MSG_VERBOSE("Muon failed cut-based low-pT selection");
802  return false;
803  }
804 
805  // passed low pt selection
806  ATH_MSG_VERBOSE("Muon passed cut-based low-pT selection");
807  return true;
808  }

◆ passedLowPtEfficiencyMVACut()

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

Definition at line 826 of file MuonSelectionTool.cxx.

826  {
827  //LowPt Not supported in run3 for the time being
828  if(isRun3() && !m_developMode){
829  ATH_MSG_VERBOSE("LowPt WP currently not supported for run3 if not in expert mode");
830  return false;
831  }
832  if (!m_useMVALowPt) {
833  ATH_MSG_DEBUG("Low pt MVA disabled. Return... ");
834  return false;
835  }
836  std::lock_guard<std::mutex> guard(m_low_pt_mva_mutex);
837  // set values for all BDT input variables from the muon in question
838  float momentumBalanceSig{-1}, CurvatureSig{-1}, energyLoss{-1}, muonSegmentDeltaEta{-1}, scatteringNeigbour{-1};
839  retrieveParam(mu, momentumBalanceSig, xAOD::Muon::momentumBalanceSignificance);
840  retrieveParam(mu, CurvatureSig, xAOD::Muon::scatteringCurvatureSignificance);
841  retrieveParam(mu, scatteringNeigbour, xAOD::Muon::scatteringNeighbourSignificance);
842  retrieveParam(mu, energyLoss, xAOD::Muon::EnergyLoss);
843  retrieveParam(mu, muonSegmentDeltaEta, xAOD::Muon::segmentDeltaEta);
844 
845  uint8_t middleSmallHoles{0}, middleLargeHoles{0};
846  retrieveSummaryValue(mu, middleSmallHoles, xAOD::MuonSummaryType::middleSmallHoles);
847  retrieveSummaryValue(mu, middleLargeHoles, xAOD::MuonSummaryType::middleLargeHoles);
848 
849  float seg1ChamberIdx{-1.}, seg2ChamberIdx{-1.}, middleHoles{-1.}, seg1NPrecisionHits{-1.}, seg1GlobalR{-1.}, seg1Chi2OverDoF{-1.};
850 
851  std::vector<const xAOD::MuonSegment*> muonSegments = getSegmentsSorted(mu);
852 
853  if (mu.author() == xAOD::Muon::MuTagIMO && muonSegments.size() == 0)
854  ATH_MSG_WARNING("passedLowPtEfficiencyMVACut - found segment-tagged muon with no segments!");
855 
856  using namespace Muon::MuonStationIndex;
857  seg1ChamberIdx = (!muonSegments.empty()) ? toInt(muonSegments[0]->chamberIndex()) : -9;
858  seg2ChamberIdx = (muonSegments.size() > 1) ? toInt(muonSegments[1]->chamberIndex()) : -9;
859 
860  // these variables are only used for MuTagIMO
861  if (mu.author() == xAOD::Muon::MuTagIMO) {
862  seg1NPrecisionHits = (!muonSegments.empty()) ? muonSegments[0]->nPrecisionHits() : -1;
863  seg1GlobalR = (!muonSegments.empty())
864  ? std::hypot(muonSegments[0]->x(), muonSegments[0]->y(), muonSegments[0]->z())
865  : 0;
866  seg1Chi2OverDoF = (!muonSegments.empty()) ? muonSegments[0]->chiSquared() / muonSegments[0]->numberDoF() : -1;
867  }
868 
869  middleHoles = middleSmallHoles + middleLargeHoles;
870 
871  // get event number from event info
872  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfo);
873  //overwrite event number
874  unsigned long long eventNumber = 0;
875  if(m_expertMode_EvtNumber.value()!=0) eventNumber=m_expertMode_EvtNumber.value();
876  else eventNumber = eventInfo->eventNumber();
877 
878  // variables for the BDT
879  std::vector<float> var_vector;
880  if (mu.author() == xAOD::Muon::MuidCo || mu.author() == xAOD::Muon::MuGirl) {
881  var_vector = {momentumBalanceSig, CurvatureSig, scatteringNeigbour, energyLoss,
882  middleHoles, muonSegmentDeltaEta, seg1ChamberIdx, seg2ChamberIdx};
883  } else {
884  if (std::abs(mu.eta()) >= 1.3)
885  var_vector = {seg2ChamberIdx, seg1ChamberIdx, seg1NPrecisionHits, muonSegmentDeltaEta,
886  seg1GlobalR, seg1Chi2OverDoF, std::abs(CurvatureSig)};
887  else
888  var_vector = {seg1ChamberIdx, seg1NPrecisionHits, muonSegmentDeltaEta,
889  seg1GlobalR, seg1Chi2OverDoF, std::abs(CurvatureSig)};
890  }
891 
892  // use different trainings for even/odd numbered events
893  TMVA::Reader *reader_MUID, *reader_MUGIRL;
894  if (eventNumber % 2 == 1) {
895  reader_MUID = m_readerE_MUID.get();
896  reader_MUGIRL = m_readerE_MUGIRL.get();
897  } else {
898  reader_MUID = m_readerO_MUID.get();
899  reader_MUGIRL = m_readerO_MUGIRL.get();
900  }
901 
902  // BDT for MuTagIMO is binned in |eta|
903  TMVA::Reader* reader_MUTAGIMO;
904  if (std::abs(mu.eta()) < 0.7)
905  reader_MUTAGIMO = m_reader_MUTAGIMO_etaBin1.get();
906  else if (std::abs(mu.eta()) < 1.3)
907  reader_MUTAGIMO = m_reader_MUTAGIMO_etaBin2.get();
908  else
909  reader_MUTAGIMO = m_reader_MUTAGIMO_etaBin3.get();
910 
911  // get the BDT discriminant response
912  float BDTdiscriminant;
913 
914  if (mu.author() == xAOD::Muon::MuidCo)
915  BDTdiscriminant = reader_MUID->EvaluateMVA(var_vector, "BDTG");
916  else if (mu.author() == xAOD::Muon::MuGirl)
917  BDTdiscriminant = reader_MUGIRL->EvaluateMVA(var_vector, "BDTG");
918  else if (mu.author() == xAOD::Muon::MuTagIMO && m_useSegmentTaggedLowPt)
919  BDTdiscriminant = reader_MUTAGIMO->EvaluateMVA(var_vector, "BDT");
920  else {
921  ATH_MSG_WARNING("Invalid author for low-pT MVA, failing selection...");
922  return false;
923  }
924 
925  // cut on dicriminant
926  float BDTcut = (mu.author() == xAOD::Muon::MuTagIMO) ? 0.12 : -0.6;
927 
928  if (BDTdiscriminant > BDTcut) {
929  ATH_MSG_VERBOSE("Passed low-pT MVA cut");
930  return true;
931  } else {
932  ATH_MSG_VERBOSE("Failed low-pT MVA cut");
933  return false;
934  }
935  }

◆ 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 1245 of file MuonSelectionTool.cxx.

1245  {
1246  // ::
1247  if (mu.muonType() == xAOD::Muon::Combined) { return mu.author() != xAOD::Muon::STACO; }
1248  // ::
1249  if (mu.muonType() == xAOD::Muon::CaloTagged && std::abs(mu.eta()) < 0.105)
1250  return passedCaloTagQuality(mu);
1251  // ::
1252  if (mu.muonType() == xAOD::Muon::SegmentTagged && (std::abs(mu.eta()) < 0.105 || m_useSegmentTaggedLowPt)) return true;
1253  // ::
1254  if (mu.author() == xAOD::Muon::MuidSA && std::abs(mu.eta()) > 2.4) return true;
1255  // ::
1256  if (mu.muonType() == xAOD::Muon::SiliconAssociatedForwardMuon) {
1257  const xAOD::TrackParticle* cbtrack = mu.trackParticle(xAOD::Muon::CombinedTrackParticle);
1258  return (cbtrack && std::abs(cbtrack->eta()) > 2.4);
1259  }
1260  // ::
1261  return false;
1262  }

◆ 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 1347 of file MuonSelectionTool.cxx.

1347  {
1348 
1349  if(isRun3() && !m_developMode && (m_excludeNSWFromPrecisionLayers || !m_recalcPrecisionLayerswNSW)){
1350  ATH_MSG_VERBOSE("for run3, Tight WP is only supported when ExcludeNSWFromPrecisionLayers=False and RecalcPrecisionLayerswNSW=True");
1351  return false;
1352  }
1353  float symmetric_eta = std::abs(mu.eta());
1354  float pt = mu.pt() * MeVtoGeV; // GeV
1355 
1356  // Impose pT and eta cuts; the bounds of the cut maps
1357  if (pt < 4.0 || symmetric_eta >= 2.5) return false;
1358  ATH_MSG_VERBOSE("Muon is passing tight WP kinematic cuts with pT,eta " << mu.pt() << " , " << mu.eta());
1359 
1360  // ** Low pT specific cuts ** //
1361  if (pt < 20.0) {
1362  double rhoCut = m_tightWP_lowPt_rhoCuts->Interpolate(pt, symmetric_eta);
1363  double qOverPCut = m_tightWP_lowPt_qOverPCuts->Interpolate(pt, symmetric_eta);
1364 
1365  ATH_MSG_VERBOSE("Applying tight WP cuts to a low pt muon with (pt,eta) ( " << pt << " , " << mu.eta() << " ) ");
1366  ATH_MSG_VERBOSE("Rho value " << rho << ", required to be less than " << rhoCut);
1367  ATH_MSG_VERBOSE("Momentum significance value " << oneOverPSig << ", required to be less than " << qOverPCut);
1368 
1369  if (rho > rhoCut) return false;
1370  ATH_MSG_VERBOSE("Muon passed tight WP, low pT rho cut!");
1371 
1372  if (oneOverPSig > qOverPCut) return false;
1373  ATH_MSG_VERBOSE("Muon passed tight WP, low pT momentum significance cut");
1374 
1375  // Tight muon!
1376  return true;
1377 
1378  }
1379 
1380  // ** Medium pT specific cuts ** //
1381  else if (pt < 100.0) {
1382  double rhoCut = m_tightWP_mediumPt_rhoCuts->Interpolate(pt, symmetric_eta);
1383  //
1384  ATH_MSG_VERBOSE("Applying tight WP cuts to a medium pt muon with (pt,eta) (" << pt << "," << mu.eta() << ")");
1385  ATH_MSG_VERBOSE("Rho value " << rho << " required to be less than " << rhoCut);
1386 
1387  // Apply cut
1388  if (rho > rhoCut) return false;
1389  ATH_MSG_VERBOSE("Muon passed tight WP, medium pT rho cut!");
1390 
1391  // Tight muon!
1392  return true;
1393  }
1394 
1395  // ** High pT specific cuts
1396  else if (pt < 500.0) {
1397  //
1398  ATH_MSG_VERBOSE("Applying tight WP cuts to a high pt muon with (pt,eta) (" << pt << "," << mu.eta() << ")");
1399  // No interpolation, since bins with -1 mean we should cut really loose
1400  double rhoCut = m_tightWP_highPt_rhoCuts->GetBinContent(m_tightWP_highPt_rhoCuts->FindFixBin(pt, symmetric_eta));
1401  ATH_MSG_VERBOSE("Rho value " << rho << ", required to be less than " << rhoCut << " unless -1, in which no cut is applied");
1402  //
1403  if (rhoCut < 0.0) return true;
1404  if (rho > rhoCut) return false;
1405  ATH_MSG_VERBOSE("Muon passed tight WP, high pT rho cut!");
1406 
1407  return true;
1408  }
1409  // For muons with pT > 500 GeV, no extra cuts
1410  else {
1411  ATH_MSG_VERBOSE("Not applying any tight WP cuts to a very high pt muon with (pt,eta) (" << pt << "," << mu.eta() << ")");
1412  return true;
1413  }
1414 
1415  // you should never reach this point
1416  return false;
1417  }

◆ print() [1/2]

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

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

131  {
132 
133  ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
134  return;
135  }

◆ print() [2/2]

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

Print the state of the tool.

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

◆ 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 400 of file MuonSelectionTool.cxx.

400  {
401  // Avoid spurious FPEs in the clang build.
402  CXXUTILS_TRAPPING_FP;
403 
404  if (m_disablePtCuts) {
405  ATH_MSG_VERBOSE(__FILE__ << ":"<<__LINE__
406  << " Momentum dependent cuts are disabled. Return 0.");
407  return 0.;
408  }
409  const xAOD::TrackParticle* idtrack = muon.trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
410  const xAOD::TrackParticle* metrack = muon.trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
411  if (!idtrack || !metrack) {
412  ATH_MSG_VERBOSE("No ID / MS track. Return dummy large value of 1 mio");
413  return 1.e6;
414  }
415  float mePt{-1.}, idPt{-1.};
416  IdMsPt(muon, idPt, mePt);
417 
418  const float meP = mePt / std::sin(metrack->theta());
419  const float idP = idPt / std::sin(idtrack->theta());
420 
421  float qOverPsigma = std::sqrt(idtrack->definingParametersCovMatrix()(4, 4) + metrack->definingParametersCovMatrix()(4, 4));
422  return std::abs((metrack->charge() / meP) - (idtrack->charge() / idP)) / qOverPsigma;
423  }

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ retrieveParam()

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

Definition at line 1472 of file MuonSelectionTool.cxx.

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

◆ 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 152 of file MuonSelectionTool.h.

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

◆ 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 424 of file MuonSelectionTool.cxx.

424  {
425  if (m_disablePtCuts) {
426  ATH_MSG_VERBOSE(__FILE__ << ":"<<__LINE__
427  << "Momentum dependent cuts are disabled. Return 0.");
428  return 0.;
429  }
430  float mePt{-1.}, idPt{-1.};
431  IdMsPt(muon, idPt, mePt);
432  return std::abs(idPt - mePt) / muon.pt();
433  }

◆ 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 612 of file MuonSelectionTool.cxx.

612 { 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 377 of file MuonSelectionTool.cxx.

377  {
378  mu.setQuality(getQuality(mu));
379  return;
380  }

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_acceptInfo

asg::AcceptInfo CP::MuonSelectionTool::m_acceptInfo
private

Store selection information.

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

◆ 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 239 of file MuonSelectionTool.h.

◆ m_BMVcutFunction_barrel

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

Definition at line 250 of file MuonSelectionTool.h.

◆ m_BMVcutFunction_endcap

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

Definition at line 251 of file MuonSelectionTool.h.

◆ m_calculateTightNNScore

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

Definition at line 285 of file MuonSelectionTool.h.

◆ m_calibration_version

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

Definition at line 233 of file MuonSelectionTool.h.

◆ 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 185 of file MuonSelectionTool.h.

◆ m_custom_dir

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

Definition at line 236 of file MuonSelectionTool.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_developMode

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

Definition at line 191 of file MuonSelectionTool.h.

◆ m_disablePtCuts

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

Definition at line 190 of file MuonSelectionTool.h.

◆ m_doBadMuonVetoMimic

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

Definition at line 201 of file MuonSelectionTool.h.

◆ m_eventInfo

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

Definition at line 208 of file MuonSelectionTool.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_excludeNSWFromPrecisionLayers

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

Definition at line 182 of file MuonSelectionTool.h.

◆ 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 206 of file MuonSelectionTool.h.

◆ m_expertMode_RunNumber

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

Definition at line 205 of file MuonSelectionTool.h.

◆ 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 200 of file MuonSelectionTool.h.

◆ 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 181 of file MuonSelectionTool.h.

◆ m_low_pt_mva_mutex

std::mutex CP::MuonSelectionTool::m_low_pt_mva_mutex
mutableprivate

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

◆ 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 218 of file MuonSelectionTool.h.

◆ 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 211 of file MuonSelectionTool.h.

◆ 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 225 of file MuonSelectionTool.h.

◆ 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 227 of file MuonSelectionTool.h.

◆ 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 229 of file MuonSelectionTool.h.

◆ 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 221 of file MuonSelectionTool.h.

◆ 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 214 of file MuonSelectionTool.h.

◆ m_onnxTool

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

Definition at line 286 of file MuonSelectionTool.h.

◆ m_PixCutOff

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

Definition at line 194 of file MuonSelectionTool.h.

◆ 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 179 of file MuonSelectionTool.h.

◆ m_reader_MUTAGIMO_etaBin1

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

Definition at line 265 of file MuonSelectionTool.h.

◆ m_reader_MUTAGIMO_etaBin2

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

Definition at line 266 of file MuonSelectionTool.h.

◆ m_reader_MUTAGIMO_etaBin3

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

Definition at line 267 of file MuonSelectionTool.h.

◆ m_readerE_MUGIRL

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

Definition at line 262 of file MuonSelectionTool.h.

◆ m_readerE_MUID

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

Definition at line 260 of file MuonSelectionTool.h.

◆ m_readerO_MUGIRL

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

Definition at line 263 of file MuonSelectionTool.h.

◆ m_readerO_MUID

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

Definition at line 261 of file MuonSelectionTool.h.

◆ m_recalcPrecisionLayerswNSW

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

Definition at line 183 of file MuonSelectionTool.h.

◆ m_SctCutOff

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

Definition at line 193 of file MuonSelectionTool.h.

◆ m_SiHolesCutOff

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

Definition at line 195 of file MuonSelectionTool.h.

◆ m_tightWP_highPt_rhoCuts

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

Definition at line 248 of file MuonSelectionTool.h.

◆ m_tightWP_lowPt_qOverPCuts

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

Definition at line 246 of file MuonSelectionTool.h.

◆ m_tightWP_lowPt_rhoCuts

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

Definition at line 245 of file MuonSelectionTool.h.

◆ m_tightWP_mediumPt_rhoCuts

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

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

◆ m_TrtCutOff

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

Definition at line 192 of file MuonSelectionTool.h.

◆ m_turnOffMomCorr

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

Definition at line 189 of file MuonSelectionTool.h.

◆ 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 197 of file MuonSelectionTool.h.

◆ m_useAllAuthors

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

Definition at line 196 of file MuonSelectionTool.h.

◆ 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 203 of file MuonSelectionTool.h.

◆ 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 184 of file MuonSelectionTool.h.

◆ m_useLRT

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

Definition at line 186 of file MuonSelectionTool.h.

◆ 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 198 of file MuonSelectionTool.h.

◆ m_useSegmentTaggedLowPt

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

Definition at line 199 of file MuonSelectionTool.h.

◆ 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:
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:74
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:262
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
xAOD::phiLayer2STGCHits
@ phiLayer2STGCHits
number of phi hits in the second STGC trigger layer (STGC2)
Definition: TrackingPrimitives.h:426
CalculateHighPtTerm.pT
pT
Definition: ICHEP2016/CalculateHighPtTerm.py:57
xAOD::muon
@ muon
Definition: TrackingPrimitives.h:196
CP::MuonSelectionTool::m_MVAreaderFile_MuTagIMO_etaBin2
Gaudi::Property< std::string > m_MVAreaderFile_MuTagIMO_etaBin2
Definition: MuonSelectionTool.h:227
CP::MuonSelectionTool::passTight
bool passTight(const xAOD::Muon &mu, float rho, float oneOverPSig) const
Returns true if the muon passed the tight working point cuts.
Definition: MuonSelectionTool.cxx:1347
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
CP::IMuonSelectionTool::CategoryOne
@ CategoryOne
Definition: IMuonSelectionTool.h:44
CP::MuonSelectionTool::m_acceptInfo
asg::AcceptInfo m_acceptInfo
Store selection information.
Definition: MuonSelectionTool.h:176
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
xAOD::MuGirl
@ MuGirl
MuGirl.
Definition: TrackingPrimitives.h:142
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:407
LikeEnum::VeryLoose
@ VeryLoose
Definition: LikelihoodEnums.h:11
CP::MuonSelectionTool::m_use2stationMuonsHighPt
Gaudi::Property< bool > m_use2stationMuonsHighPt
Definition: MuonSelectionTool.h:197
xAOD::numberOfPrecisionHoleLayers
@ numberOfPrecisionHoleLayers
layers with holes AND no hits [unit8_t].
Definition: TrackingPrimitives.h:290
CP::MuonSelectionTool::m_quality
Gaudi::Property< int > m_quality
Definition: MuonSelectionTool.h:179
CP::IMuonSelectionTool::unclassified
@ unclassified
Definition: IMuonSelectionTool.h:32
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
CP::MuonSelectionTool::m_custom_dir
Gaudi::Property< std::string > m_custom_dir
Definition: MuonSelectionTool.h:236
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:558
CP::MuonSelectionTool::passedCaloTagQuality
virtual bool passedCaloTagQuality(const xAOD::Muon &mu) const override
Returns true if the muon passed additional calo-tag quality cuts.
Definition: MuonSelectionTool.cxx:1296
CP::MuonSelectionTool::m_MVAreaderFile_MuTagIMO_etaBin3
Gaudi::Property< std::string > m_MVAreaderFile_MuTagIMO_etaBin3
Definition: MuonSelectionTool.h:229
xAOD::etaMS
setSAddress etaMS
Definition: L2StandAloneMuon_v1.cxx:117
CP::MuonSelectionTool::getQuality
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&) c...
Definition: MuonSelectionTool.cxx:435
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
CP::MuonSelectionTool::m_MVAreaderFile_EVEN_MuidCB
Gaudi::Property< std::string > m_MVAreaderFile_EVEN_MuidCB
Definition: MuonSelectionTool.h:211
Muon::MuonStationIndex
Definition: MuonStationIndex.h:13
CP::IMuonSelectionTool::BEoverlap
@ BEoverlap
Definition: IMuonSelectionTool.h:39
xAOD::TrackParticle_v1::charge
float charge() const
Returns the charge.
Definition: TrackParticle_v1.cxx:151
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
CP::MuonSelectionTool::m_useAllAuthors
Gaudi::Property< bool > m_useAllAuthors
Definition: MuonSelectionTool.h:196
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
CP::MuonSelectionTool::m_reader_MUTAGIMO_etaBin3
std::unique_ptr< TMVA::Reader > m_reader_MUTAGIMO_etaBin3
Definition: MuonSelectionTool.h:267
CP::MuonSelectionTool::m_disablePtCuts
Gaudi::Property< bool > m_disablePtCuts
Definition: MuonSelectionTool.h:190
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:78
CP::MuonSelectionTool::m_readerE_MUID
std::unique_ptr< TMVA::Reader > m_readerE_MUID
Definition: MuonSelectionTool.h:260
CP::MuonSelectionTool::m_calculateTightNNScore
Gaudi::Property< bool > m_calculateTightNNScore
Definition: MuonSelectionTool.h:285
CP::IMuonSelectionTool::highPt
@ highPt
Definition: IMuonSelectionTool.h:37
plotmaker.hist
hist
Definition: plotmaker.py:148
xAOD::extendedSmallHoles
@ extendedSmallHoles
number of precision holes in the extended small layer
Definition: TrackingPrimitives.h:346
CP::MuonSelectionTool::passedIDCuts
virtual bool passedIDCuts(const xAOD::Muon &) const override
Returns true if the muon passes the standard MCP ID cuts.
Definition: MuonSelectionTool.cxx:614
CP::MuonSelectionTool::m_BMVcutFunction_barrel
std::unique_ptr< TF1 > m_BMVcutFunction_barrel
Definition: MuonSelectionTool.h:250
CP::MuonSelectionTool::isBEE
bool isBEE(const float eta, const float phi) const
Check if muon eta/phi falls in BEE chambers.
Definition: MuonSelectionTool.cxx:1627
TRTCalib_cfilter.p1
p1
Definition: TRTCalib_cfilter.py:130
CP::MuonSelectionTool::m_readerE_MUGIRL
std::unique_ptr< TMVA::Reader > m_readerE_MUGIRL
Definition: MuonSelectionTool.h:262
MuonParameters::scatteringNeighbourSignificance
@ scatteringNeighbourSignificance
Definition: MuonParamDefs.h:135
CP::IMuonSelectionTool::CategoryZero
@ CategoryZero
Definition: IMuonSelectionTool.h:43
test_pyathena.pt
pt
Definition: test_pyathena.py:11
CP::MeVtoGeV
constexpr float MeVtoGeV
Definition: IsolationCloseByCorrectionTool.cxx:38
CP::MuonSelectionTool::m_turnOffMomCorr
Gaudi::Property< bool > m_turnOffMomCorr
Definition: MuonSelectionTool.h:189
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::TrackParticle_v1::chiSquared
float chiSquared() const
Returns the of the overall track fit.
CP::IMuonSelectionTool::CategoryThree
@ CategoryThree
Definition: IMuonSelectionTool.h:46
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
CP::MuonSelectionTool::m_tightWP_highPt_rhoCuts
std::unique_ptr< TH1 > m_tightWP_highPt_rhoCuts
Definition: MuonSelectionTool.h:248
CP::MuonSelectionTool::getHist
StatusCode getHist(TFile *file, const std::string &histName, std::unique_ptr< TH1 > &hist) const
Checks for each histogram.
Definition: MuonSelectionTool.cxx:248
athena.value
value
Definition: athena.py:124
CP::IMuonSelectionTool::CategoryTwo
@ CategoryTwo
Definition: IMuonSelectionTool.h:45
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:260
CP::MuonSelectionTool::passedLowPtEfficiencyCuts
virtual bool passedLowPtEfficiencyCuts(const xAOD::Muon &) const override
Returns true if the muon passes the standard MCP low pt cuts.
Definition: MuonSelectionTool.cxx:695
CP::MuonSelectionTool::m_PixCutOff
Gaudi::Property< bool > m_PixCutOff
Definition: MuonSelectionTool.h:194
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:276
xAOD::middleLargeHoles
@ middleLargeHoles
number of precision holes in the middle large layer
Definition: TrackingPrimitives.h:343
CP::MuonSelectionTool::m_readerO_MUGIRL
std::unique_ptr< TMVA::Reader > m_readerO_MUGIRL
Definition: MuonSelectionTool.h:263
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:9
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
CP::MuonSelectionTool::retrieveParam
void retrieveParam(const xAOD::Muon &muon, float &value, const xAOD::Muon::ParamDef param) const
Definition: MuonSelectionTool.cxx:1472
CP::IMuonSelectionTool::missingMiddle
@ missingMiddle
Definition: IMuonSelectionTool.h:34
CP::MuonSelectionTool::passedCaloScore
virtual bool passedCaloScore(const xAOD::Muon &mu) const override
Returns true if the muon passed the CaloScore calo-tag working point.
Definition: MuonSelectionTool.cxx:1317
CP::MuonSelectionTool::m_isRun3
Gaudi::Property< bool > m_isRun3
Definition: MuonSelectionTool.h:181
xAOD::EventInfo_v1::IS_SIMULATION
@ IS_SIMULATION
true: simulation, false: data
Definition: EventInfo_v1.h:151
x
#define x
CP::MuonSelectionTool::m_MVAreaderFile_ODD_MuGirl
Gaudi::Property< std::string > m_MVAreaderFile_ODD_MuGirl
Definition: MuonSelectionTool.h:221
CP::MuonSelectionTool::m_toroidOff
Gaudi::Property< bool > m_toroidOff
Definition: MuonSelectionTool.h:180
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
CP::MuonSelectionTool::passedHighPtCuts
virtual bool passedHighPtCuts(const xAOD::Muon &) const override
Returns true if the muon passes the standard MCP High Pt cuts.
Definition: MuonSelectionTool.cxx:937
xAOD::innerLargeHits
@ innerLargeHits
number of precision hits in the inner large layer
Definition: TrackingPrimitives.h:332
CP::MuonSelectionTool::m_BMVcutFile
Gaudi::Property< std::string > m_BMVcutFile
file for bad muon veto mimic cut functions
Definition: MuonSelectionTool.h:239
CP::MuonSelectionTool::m_useMVALowPt
Gaudi::Property< bool > m_useMVALowPt
Definition: MuonSelectionTool.h:198
CP::MuonSelectionTool::m_BMVcutFunction_endcap
std::unique_ptr< TF1 > m_BMVcutFunction_endcap
Definition: MuonSelectionTool.h:251
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
MuonParameters::MuTagIMO
@ MuTagIMO
Definition: MuonParamDefs.h:66
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
xAOD::cscUnspoiledEtaHits
@ cscUnspoiledEtaHits
number of unspoiled CSC eta clusters on track
Definition: TrackingPrimitives.h:451
CP::MuonSelectionTool::m_recalcPrecisionLayerswNSW
Gaudi::Property< bool > m_recalcPrecisionLayerswNSW
Definition: MuonSelectionTool.h:183
MuonParameters::momentumBalanceSignificance
@ momentumBalanceSignificance
Definition: MuonParamDefs.h:136
CP::MuonSelectionTool::m_developMode
Gaudi::Property< bool > m_developMode
Definition: MuonSelectionTool.h:191
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
CP::MuonSelectionTool::m_expertMode_EvtNumber
Gaudi::Property< unsigned long long > m_expertMode_EvtNumber
Definition: MuonSelectionTool.h:206
CP::MuonSelectionTool::passedErrorCutCB
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.
Definition: MuonSelectionTool.cxx:1115
xAOD::middleLargeHits
@ middleLargeHits
number of precision hits in the middle large layer
Definition: TrackingPrimitives.h:334
InDet::ExclusiveOrigin::Primary
@ Primary
Definition: InDetTrackTruthOriginDefs.h:163
MuonParameters::highPt
@ highPt
Definition: MuonParamDefs.h:51
CP::IMuonSelectionTool::BIS78
@ BIS78
Definition: IMuonSelectionTool.h:40
CP::MuonSelectionTool::m_doBadMuonVetoMimic
Gaudi::Property< bool > m_doBadMuonVetoMimic
Definition: MuonSelectionTool.h:201
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
CP::MuonSelectionTool::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: MuonSelectionTool.h:208
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
TRTCalib_cfilter.p2
p2
Definition: TRTCalib_cfilter.py:131
CP::MuonSelectionTool::passedBMVmimicCut
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 neces...
Definition: MuonSelectionTool.cxx:1220
CP::MuonSelectionTool::qOverPsignificance
float qOverPsignificance(const xAOD::Muon &muon) const
Returns q/p significance of the muon (see definition in https://cds.cern.ch/record/2665711 )
Definition: MuonSelectionTool.cxx:400
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
CP::MuonSelectionTool::passedMuonCuts
virtual bool passedMuonCuts(const xAOD::Muon &) const override
Returns true if the muon passes a standardized loose preselection.
Definition: MuonSelectionTool.cxx:1245
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
xAOD::extendedLargeHits
@ extendedLargeHits
number of precision hits in the extended large layer
Definition: TrackingPrimitives.h:338
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
ReweightUtils.category
category
Definition: ReweightUtils.py:15
CP::MuonSelectionTool::isBIS78
bool isBIS78(const float eta, const float phi) const
Check if muon eta/phi falls in BIS7/8 chambers.
Definition: MuonSelectionTool.cxx:1609
CP::MuonSelectionTool::m_useLRT
Gaudi::Property< bool > m_useLRT
Definition: MuonSelectionTool.h:186
AthInfer::OutputDataMap
std::map< std::string, InferenceData > OutputDataMap
Definition: IAthInferenceTool.h:17
xAOD::MMHits
@ MMHits
Definition: TrackingPrimitives.h:438
WriteLumiToCool.value2
value2
Definition: WriteLumiToCool.py:50
CP::MuonSelectionTool::m_caloScoreWP
Gaudi::Property< int > m_caloScoreWP
Definition: MuonSelectionTool.h:185
LHEF::Reader
Pythia8::Reader Reader
Definition: Prophecy4fMerger.cxx:11
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
MuonParameters::segmentDeltaEta
@ segmentDeltaEta
MuTag parameters.
Definition: MuonParamDefs.h:139
athena.file_path
file_path
Definition: athena.py:94
file
TFile * file
Definition: tile_monitor.h:29
python.BunchSpacingUtils.rn
rn
Definition: BunchSpacingUtils.py:85
xAOD::middleSmallHoles
@ middleSmallHoles
number of precision holes in the middle small layer
Definition: TrackingPrimitives.h:342
xAOD::combinedTrackOutBoundsPrecisionHits
@ combinedTrackOutBoundsPrecisionHits
total out-of-bounds hits on the combined track
Definition: TrackingPrimitives.h:378
CP::MuonSelectionTool::m_useSegmentTaggedLowPt
Gaudi::Property< bool > m_useSegmentTaggedLowPt
Definition: MuonSelectionTool.h:199
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
CP::MuonSelectionTool::getSegmentsSorted
std::vector< const xAOD::MuonSegment * > getSegmentsSorted(const xAOD::Muon &mu) const
Returns a vector of the muon's segments, sorted according to chamber index.
Definition: MuonSelectionTool.cxx:810
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::eventNumber
eventNumber
Definition: EventInfo_v1.cxx:124
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
CP::MuonSelectionTool::m_calibration_version
Gaudi::Property< std::string > m_calibration_version
Definition: MuonSelectionTool.h:233
CP::MuonSelectionTool::m_excludeNSWFromPrecisionLayers
Gaudi::Property< bool > m_excludeNSWFromPrecisionLayers
Definition: MuonSelectionTool.h:182
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:271
xAOD::isSmallGoodSectors
@ isSmallGoodSectors
if non-deweighted track chambers are small
Definition: TrackingPrimitives.h:381
xAOD::SiSpacePointsSeedMaker_LargeD0
@ SiSpacePointsSeedMaker_LargeD0
Definition: TrackingPrimitives.h:184
CP::MuonSelectionTool::getRunNumber
unsigned int getRunNumber(bool needOnlyCorrectYear=false) const
Definition: MuonSelectionTool.cxx:1548
xAOD::etaLayer2STGCHits
@ etaLayer2STGCHits
number of eta hits in the second STGC trigger layer (STGC2)
Definition: TrackingPrimitives.h:429
Trk::Combined
@ Combined
Definition: TrackSummaryTool.h:32
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
MuonParameters::scatteringCurvatureSignificance
@ scatteringCurvatureSignificance
Definition: MuonParamDefs.h:134
xAOD::TrackParticle_v1::qOverP
float qOverP() const
Returns the parameter.
CP::MuonSelectionTool::m_low_pt_mva_mutex
std::mutex m_low_pt_mva_mutex
Definition: MuonSelectionTool.h:270
xAOD::TrackParticle_v1::definingParametersCovMatrix
const ParametersCovMatrix_t definingParametersCovMatrix() const
Returns the 5x5 symmetric matrix containing the defining parameters covariance matrix.
Definition: TrackParticle_v1.cxx:247
xAOD::middleSmallHits
@ middleSmallHits
number of precision hits in the middle small layer
Definition: TrackingPrimitives.h:333
CP::MuonSelectionTool::accept
virtual asg::AcceptData accept(const xAOD::IParticle *p) const override
Get the decision using a generic IParticle pointer.
Definition: MuonSelectionTool.cxx:271
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
CP::MuonSelectionTool::m_useBEEBISInHighPtRun3
Gaudi::Property< bool > m_useBEEBISInHighPtRun3
Definition: MuonSelectionTool.h:203
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
CP::IMuonSelectionTool::missingBEE
@ missingBEE
Definition: IMuonSelectionTool.h:41
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
CP::MuonSelectionTool::m_reader_MUTAGIMO_etaBin1
std::unique_ptr< TMVA::Reader > m_reader_MUTAGIMO_etaBin1
Definition: MuonSelectionTool.h:265
CP::IMuonSelectionTool::spoiledCSC
@ spoiledCSC
Definition: IMuonSelectionTool.h:38
CP::MuonSelectionTool::m_tightWP_mediumPt_rhoCuts
std::unique_ptr< TH1 > m_tightWP_mediumPt_rhoCuts
Definition: MuonSelectionTool.h:247
CP::MuonSelectionTool::m_readerO_MUID
std::unique_ptr< TMVA::Reader > m_readerO_MUID
Definition: MuonSelectionTool.h:261
CP::MuonSelectionTool::m_useCaloScore
Gaudi::Property< bool > m_useCaloScore
Definition: MuonSelectionTool.h:184
CP::MuonSelectionTool::checkSanity
void checkSanity() const
Definition: MuonSelectionTool.cxx:290
MuonParameters::MuidSA
@ MuidSA
Definition: MuonParamDefs.h:59
xAOD::outerSmallHits
@ outerSmallHits
number of precision hits in the outer small layer
Definition: TrackingPrimitives.h:335
CP::MuonSelectionTool::m_SiHolesCutOff
Gaudi::Property< bool > m_SiHolesCutOff
Definition: MuonSelectionTool.h:195
CP::MuonSelectionTool::m_MVAreaderFile_MuTagIMO_etaBin1
Gaudi::Property< std::string > m_MVAreaderFile_MuTagIMO_etaBin1
Definition: MuonSelectionTool.h:225
IDTPM::chiSquared
float chiSquared(const U &p)
Definition: TrackParametersHelper.h:128
CP::MuonSelectionTool::m_tightWP_lowPt_qOverPCuts
std::unique_ptr< TH1 > m_tightWP_lowPt_qOverPCuts
Definition: MuonSelectionTool.h:246
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:321
Muon
struct TBPatternUnitContext Muon
CP::MuonSelectionTool::m_reader_MUTAGIMO_etaBin2
std::unique_ptr< TMVA::Reader > m_reader_MUTAGIMO_etaBin2
Definition: MuonSelectionTool.h:266
xAOD::score
@ score
Definition: TrackingPrimitives.h:514
CP::MuonSelectionTool::m_tightWP_lowPt_rhoCuts
std::unique_ptr< TH1 > m_tightWP_lowPt_rhoCuts
Definition: MuonSelectionTool.h:245
xAOD::numberOfTRTOutliers
@ numberOfTRTOutliers
number of TRT outliers [unit8_t].
Definition: TrackingPrimitives.h:277
CP::MuonSelectionTool::m_expertMode_RunNumber
Gaudi::Property< int > m_expertMode_RunNumber
Definition: MuonSelectionTool.h:205
CP::MuonSelectionTool::isRun3
bool isRun3(bool forceOnTheFly=false) const
Definition: MuonSelectionTool.h:276
MuonParameters::MuidCo
@ MuidCo
Definition: MuonParamDefs.h:60
DeMoAtlasDataLoss.runNumber
string runNumber
Definition: DeMoAtlasDataLoss.py:64
xAOD::outerLargeHits
@ outerLargeHits
number of precision hits in the outer large layer
Definition: TrackingPrimitives.h:336
a
TList * a
Definition: liststreamerinfos.cxx:10
CP::MuonSelectionTool::m_maxEta
Gaudi::Property< double > m_maxEta
Definition: MuonSelectionTool.h:178
CXXUTILS_TRAPPING_FP
CXXUTILS_TRAPPING_FP
Definition: SegmentLineFitter.cxx:8
h
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
xAOD::numberOfSCTDeadSensors
@ numberOfSCTDeadSensors
number of dead SCT sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:274
CP::MuonSelectionTool::m_onnxTool
ToolHandle< AthInfer::IAthInferenceTool > m_onnxTool
Definition: MuonSelectionTool.h:286
CP::IMuonSelectionTool::oneStation
@ oneStation
Definition: IMuonSelectionTool.h:42
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::MuonSelectionTool::m_TrtCutOff
Gaudi::Property< bool > m_TrtCutOff
Definition: MuonSelectionTool.h:192
xAOD::etaLayer1STGCHits
@ etaLayer1STGCHits
number of eta hits in the first STGC trigger layer (STGC1)
Definition: TrackingPrimitives.h:428
xAOD::numberOfGoodPrecisionLayers
@ numberOfGoodPrecisionLayers
layers with at least 3 hits that are not deweighted [uint8_t]
Definition: TrackingPrimitives.h:295
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
CP::MuonSelectionTool::IdMsPt
void IdMsPt(const xAOD::Muon &muon, float &idPt, float &msPt) const
Definition: MuonSelectionTool.cxx:381
CP::MuonSelectionTool::retrieveSummaryValue
void retrieveSummaryValue(const P &muon, T &value, const S type, bool ignoreMissing=false) const
helper function to retrieve a hitSummary value
Definition: MuonSelectionTool.h:152
CP::IMuonSelectionTool::CategoryFour
@ CategoryFour
Definition: IMuonSelectionTool.h:47
CP::MuonSelectionTool::m_geoOnTheFly
Gaudi::Property< bool > m_geoOnTheFly
Definition: MuonSelectionTool.h:200
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:269
xAOD::TrackParticle_v1::numberDoF
float numberDoF() const
Returns the number of degrees of freedom of the overall track or vertex fit as float.
CP::MuonSelectionTool::m_allowComm
Gaudi::Property< bool > m_allowComm
Definition: MuonSelectionTool.h:202
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
xAOD::STACO
@ STACO
Tracks produced by STACO.
Definition: TrackingPrimitives.h:100
xAOD::numberOfPixelDeadSensors
@ numberOfPixelDeadSensors
number of dead pixel sensors crossed [unit8_t].
Definition: TrackingPrimitives.h:267
xAOD::phiLayer1STGCHits
@ phiLayer1STGCHits
number of phi hits in the first STGC trigger layer (STGC1)
Definition: TrackingPrimitives.h:425
CP::IMuonSelectionTool::highPt2station
@ highPt2station
Definition: IMuonSelectionTool.h:36
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
xAOD::extendedSmallHits
@ extendedSmallHits
number of precision hits in the extended small layer
Definition: TrackingPrimitives.h:337
CP::MuonSelectionTool::m_MVAreaderFile_ODD_MuidCB
Gaudi::Property< std::string > m_MVAreaderFile_ODD_MuidCB
Definition: MuonSelectionTool.h:214
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
collisions.reader
reader
read the goodrunslist xml file(s)
Definition: collisions.py:22
xAOD::innerSmallHits
@ innerSmallHits
number of precision hits in the inner small layer
Definition: TrackingPrimitives.h:331
CP::MuonSelectionTool::passedLowPtEfficiencyMVACut
bool passedLowPtEfficiencyMVACut(const xAOD::Muon &) const
Definition: MuonSelectionTool.cxx:826
asg::AcceptData
Definition: AcceptData.h:30
CP::MuonSelectionTool::fillSummary
void fillSummary(const xAOD::Muon &muon, hitSummary &summary) const
functions that fills a hitSummary for a muon
Definition: MuonSelectionTool.cxx:1420
SG::DataProxy
Definition: DataProxy.h:45
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:51
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
CP::IMuonSelectionTool::missingOuter
@ missingOuter
Definition: IMuonSelectionTool.h:35
AthInfer::InputDataMap
std::map< std::string, InferenceData > InputDataMap
Definition: IAthInferenceTool.h:16
xAOD::TrackParticle_v1::theta
float theta() const
Returns the parameter, which has range 0 to .
CP::MuonSelectionTool::m_SctCutOff
Gaudi::Property< bool > m_SctCutOff
Definition: MuonSelectionTool.h:193
CP::MuonSelectionTool::m_MVAreaderFile_EVEN_MuGirl
Gaudi::Property< std::string > m_MVAreaderFile_EVEN_MuGirl
Definition: MuonSelectionTool.h:218
MuonParameters::spectrometerFieldIntegral
@ spectrometerFieldIntegral
Discriminators and further variables.
Definition: MuonParamDefs.h:133
CP::IMuonSelectionTool::missingInner
@ missingInner
Definition: IMuonSelectionTool.h:33
fitman.rho
rho
Definition: fitman.py:532
TRTCalib_cfilter.p0
p0
Definition: TRTCalib_cfilter.py:129
xAOD::TrackParticle_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle (has range to .)
fitman.k
k
Definition: fitman.py:528
GlobalVariables.eta_range
eta_range
Definition: GlobalVariables.py:358
Muon::MuonStationIndex::toInt
constexpr int toInt(const EnumType enumVal)
Definition: MuonStationIndex.h:61
asg::AcceptInfo::addCut
int addCut(const std::string &cutName, const std::string &cutDescription)
Add a cut; returning the cut position.
Definition: AcceptInfo.h:53
xAOD::TauJetParameters::unclassified
@ unclassified
Definition: TauDefs.h:410
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
CP::MuonSelectionTool::rhoPrime
float rhoPrime(const xAOD::Muon &muon) const
Returns rhoPrime of the muon (see definition in https://cds.cern.ch/record/2665711 )
Definition: MuonSelectionTool.cxx:424
xAOD::numberOfPrecisionLayers
@ numberOfPrecisionLayers
layers with at least 3 hits [unit8_t].
Definition: TrackingPrimitives.h:289
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Fri Oct 24 2025 21:58:23 for ATLAS Offline Software by   doxygen 1.8.18