MuonMatchingTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGMUONMONITORING_MUONMATCHINGTOOL_H
#define TRIGMUONMONITORING_MUONMATCHINGTOOL_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "xAODMuon/MuonContainer.h"
#include "xAODTrigMuon/L2StandAloneMuonContainer.h"
#include "xAODTrigger/MuonRoIContainer.h"
#include "xAODTracking/TrackParticle.h"
#include "xAODTruth/TruthParticle.h"
#include "TrigDecisionTool/TrigDecisionTool.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkExInterfaces/IExtrapolator.h"
#include "FourMomUtils/xAODP4Helpers.h"
#include <string>
#include <memory>
#include <tuple>
#include "TrigT1Interfaces/ITrigThresholdDecisionTool.h"
 

class MuonMatchingTool : public AthAlgTool {
 
 public:
  MuonMatchingTool(const std::string& type, const std::string &name, const IInterface* parent);
 
  virtual StatusCode initialize() override;

  const xAOD::MuonRoI* matchL1(const EventContext& ctx, const xAOD::Muon *mu, const std::string& trigger, bool &pass) const;

  const xAOD::MuonRoI* matchL1(const EventContext& ctx, const xAOD::TruthParticle *mu, const std::string& trigger, bool &pass) const;

  const xAOD::MuonRoI* matchL1(const EventContext& ctx, double eta, double phi, double dR, const std::string& trigger, bool &pass) const;

  const xAOD::L2StandAloneMuon* matchL2SA(const EventContext& ctx, const xAOD::Muon *mu, const std::string& trigger, bool &pass) const;

  const xAOD::Muon* matchFastRecoSA(const EventContext& ctx, const xAOD::Muon *mu, const std::string& trigger, bool &pass) const;

  const xAOD::L2StandAloneMuon* matchL2SA(const xAOD::TruthParticle *mu, const std::string& trigger, bool &pass) const;

  const xAOD::Muon* matchFastRecoSA(const xAOD::TruthParticle *mu, const std::string& trigger, bool &pass) const;

  const TrigCompositeUtils::LinkInfo<xAOD::L2StandAloneMuonContainer> searchL2SALinkInfo(const xAOD::Muon *mu, std::string trigger) const;

  const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> searchFastRecoSALinkInfo(const xAOD::Muon *mu, std::string trigger) const;

  const xAOD::L2StandAloneMuon* matchL2SAReadHandle(const EventContext& ctx, const xAOD::Muon *mu) const;
  
  const xAOD::Muon* matchFastRecoSAReadHandle(const EventContext& ctx, const xAOD::Muon *mu) const;

  const xAOD::L2CombinedMuon* matchL2CB(const xAOD::Muon *mu, std::string trigger, bool &pass) const;

  const xAOD::L2CombinedMuon* matchL2CB(const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const;

  const TrigCompositeUtils::LinkInfo<xAOD::L2CombinedMuonContainer> searchL2CBLinkInfo(const xAOD::Muon *mu, std::string trigger) const;

  const xAOD::L2CombinedMuon* matchL2CBReadHandle(const EventContext& ctx, const xAOD::Muon *mu) const;

  const xAOD::Muon* matchEFSA(const xAOD::Muon *mu, std::string trigger, bool &pass) const;

  const xAOD::Muon* matchEFSA(const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const;

  const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> matchEFSALinkInfo( const xAOD::Muon *mu, std::string trig) const;

  const xAOD::Muon* matchEFSAReadHandle(const EventContext& ctx, const xAOD::Muon *mu) const;

  const xAOD::Muon* matchEFCB(const xAOD::Muon *mu, std::string trigger, bool &pass) const;

  const xAOD::Muon* matchEFCB(const xAOD::TruthParticle *mu, std::string trig, bool &pass) const;

  const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> matchEFCBLinkInfo( const xAOD::Muon *mu, std::string trig) const;

  const xAOD::Muon* matchEFCBReadHandle(const EventContext& ctx, const xAOD::Muon *mu) const;

  const xAOD::Muon* matchEFSAFS(const xAOD::Muon *mu, std::string trigger, bool &pass) const;
  const xAOD::Muon* matchEFSAFS(const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const;

  const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> matchEFSAFSLinkInfo( const xAOD::Muon *mu, std::string trig) const;

  const xAOD::Muon* matchEFSAFSReadHandle(const EventContext& ctx, const xAOD::Muon *mu) const;

  const xAOD::Muon* matchEFCBFS(const xAOD::Muon *mu, std::string trigger, bool &pass) const;

  const xAOD::Muon* matchEFCBFS(const xAOD::TruthParticle *mu, std::string trig, bool &pass) const;

  const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> matchEFCBFSLinkInfo( const xAOD::Muon *mu, std::string trig) const;

  const xAOD::Muon* matchEFCBFSReadHandle(const EventContext& ctx, const xAOD::Muon *mu) const;

  const xAOD::Muon* matchEFIso(const xAOD::Muon *mu, std::string trigger, bool &pass) const;

  const xAOD::Muon* matchEFIso(const xAOD::TruthParticle *mu, std::string trigger, bool &pass) const;

  const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> matchEFIsoLinkInfo(const xAOD::Muon *mu, std::string trig) const;
 

  const xAOD::TrackParticle* SearchEFTrack(const EventContext &ctx, const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>& muLinkInfo, const SG::ReadHandleKey<xAOD::TrackParticleContainer>& ReadHandleKey) const;
 

  const xAOD::Muon* matchL2SAtoOff(const EventContext& ctx, const xAOD::L2StandAloneMuon* samu) const;

  const xAOD::Muon* matchFastRecoSAtoOff(const EventContext& ctx, const xAOD::Muon* samu) const;

  const xAOD::Muon* matchL2CBtoOff(const EventContext& ctx, const xAOD::L2CombinedMuon* cbmu) const;
 
 
  bool isMatchedL2SA(const xAOD::L2StandAloneMuon*, const xAOD::Muon*) const;
  bool isMatchedFastRecoSA(const xAOD::Muon*, const xAOD::Muon*) const;
  bool isMatchedL2CB(const xAOD::L2CombinedMuon*, const xAOD::Muon*) const;
  bool isMatchedL2InsideOut(const xAOD::L2CombinedMuon*, const xAOD::Muon*) const;

  std::unique_ptr<Trk::TrackParameters> extTrackToPivot(const EventContext& ctx, const xAOD::TrackParticle *track) const;

  static double reqdRL1byPt(double mupt);
 
 
  static std::tuple<bool,double,double> trigPosForMatchSATrack(const xAOD::Muon *mu);
  static std::tuple<bool,double,double> trigPosForMatchCBTrack(const xAOD::Muon *mu);
  static std::tuple<bool,double,double> PosForMatchSATrack(const xAOD::Muon *mu, const bool isPhaseII = false);
  static std::tuple<bool,double,double> PosForMatchCBTrack(const xAOD::Muon *mu);
 
  
 private:
 
  enum L1Items{ L1B_MU3V=1, L1B_MU5VF=2, L1B_MU8F=3, L1B_MU14FCH=6, L1B_MU14FCHR=6 , L1E_MU3V=1, L1E_MU5VF=3, L1E_MU8F=6, L1E_MU14FCH=12, L1E_MU14FCHR=12, ERROR};
  int L1ItemStringToInt(const std::string& l1item, int roiSource) const {
    if( "L1_MU3V"==l1item) return roiSource==0 ? L1Items::L1B_MU3V : L1Items::L1E_MU3V;
    if( "L1_MU5VF"==l1item) return roiSource==0 ? L1Items::L1B_MU5VF : L1Items::L1E_MU5VF;
    if( "L1_MU8F"==l1item) return roiSource==0 ? L1Items::L1B_MU8F : L1Items::L1E_MU8F;
    if( "L1_MU14FCH"==l1item) return roiSource==0 ? L1Items::L1B_MU14FCH : L1Items::L1E_MU14FCH;
    if( "L1_MU14FCHR"==l1item) return roiSource==0 ? L1Items::L1B_MU14FCHR : L1Items::L1E_MU14FCHR;
    return L1Items::ERROR;
  }
 
  const float m_L2SAreqdR = 0.25;
  const float m_L2CBreqdR = 0.03;
  const float m_L2InsideOutreqdR = 0.01;
  const float m_EFreqdR = 0.03;
 
  // private methods
  template<class T, class OFFL> const T* matchReadHandle(const OFFL* offl, float reqdR,
                                                         const SG::ReadHandleKey<DataVector<T> > & ReadHandleKey, const EventContext& ctx,
                                                         std::tuple<bool,double,double> (*trigPosForMatchFunc)(const T*) = &MuonMatchingTool::trigPosForMatch<T>) const;
 

  template<class T, class OFFL> 
  const TrigCompositeUtils::LinkInfo<DataVector<T> > matchLinkInfo(const OFFL *offl, std::string trigger, float reqdR, bool &pass,
                                                                   const std::string& containerSGKey = "",
                                                   std::tuple<bool,double,double> (*trigPosForMatchFunc)(const T*) = &MuonMatchingTool::trigPosForMatch<T>) const;

  template<class T, class OFFL> const T* match(const OFFL *offl, std::string trigger, float reqdR, bool &pass,
                                               const std::string& containerSGKey = "",
                               std::tuple<bool,double,double> (*trigPosForMatchFunc)(const T*) = &MuonMatchingTool::trigPosForMatch<T>) const;

  template<class T> const xAOD::Muon* matchOff(const EventContext& ctx, const T* trig, float reqdR,
                                               std::function<std::tuple<bool,double,double>(const xAOD::Muon*)> offlinePosForMatchFunc,
                                               std::function<std::tuple<bool,double,double>(const T*)> trigPosForMatchFunc = &MuonMatchingTool::trigPosForMatch<T>) const;
 
 
  Amg::Vector3D offlineMuonAtPivot(const EventContext& ctx, const xAOD::Muon& mu) const;
  std::unique_ptr<Trk::TrackParameters> extTrackToTGC(const EventContext& ctx, const xAOD::TrackParticle& track) const;
  std::unique_ptr<Trk::TrackParameters> extTrackToRPC(const EventContext& ctx, const xAOD::TrackParticle& track) const;
 
  // static methods
  // Template methods that perform different matching schemes for T=xAOD::L2StandAloneMuon, xAOD::L2CombinedMuon and xAOD::Muon (EF).
  template<class T> static inline std::tuple<bool,double,double> trigPosForMatch(const T *trig);
 
  SG::ReadHandleKey<xAOD::MuonRoIContainer> m_MuonRoIKey {this, "MuonRoIContainerName", "LVL1MuonRoIs", "Level 1 muon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_MuonKey {this, "MuonContainerName", "Muons", "Offline muon container"};
  SG::ReadHandleKey<xAOD::L2StandAloneMuonContainer> m_L2SAMuonKey {this, "L2StandAloneMuonContainerName", "HLT_FastMuons_RoI", "L2MuonSA container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_FastRecoSAMuonKey {this, "FastRecoSAContainerName", "HLT_FastMuonsInfo", "EFFastRecoSA container (Phase2)"};
  SG::ReadHandleKey<xAOD::L2CombinedMuonContainer> m_L2CBMuonKey {this, "L2CombinedMuonContainerName", "HLT_MuonL2CBInfo", "L2muComb container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFSAMuonKey {this, "EFSAMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFSAMlbktMuonKey {this, "EFSAMlbktMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFSANewFastMuonKey {this, "EFSANewFastMuonContainerName", "HLT_Muons_RoI", "EFSAMuon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFCBMuonKey {this, "EFCBMuonContainerName", "HLT_MuonsCB_RoI", "EFCBMuon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFSAFSMuonKey {this, "EFSAFSMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFSAFSMlbktMuonKey {this, "EFSAFSMlbktMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFSAFSNewFastMuonKey {this, "EFSAFSNewFastMuonContainerName", "HLT_Muons_FS", "EFSAFSMuon container"};
  SG::ReadHandleKey<xAOD::MuonContainer> m_EFCBFSMuonKey {this, "EFCBFSMuonContainerName", "HLT_MuonsCB_FS", "EFCBFSMuon container"};
 
  // properties
  Gaudi::Property<bool> m_use_extrapolator {this, "UseExtrapolator", false, "Flag to enable the extrapolator for matching offline and trigger muons"};
  BooleanProperty m_isPhII {this, "isPhaseII", false, "Whether the muons have been processed with Phase II software"};
 
  // tools
  ToolHandle<LVL1::ITrigThresholdDecisionTool> m_thresholdTool{
    this, "TrigThresholdDecisionTool", "LVL1::TrigThresholdDecisionTool/LVL1__TrigThresholdDecisionTool",
    "Tool to get pass/fail of each trigger threshold"};
  PublicToolHandle<Trig::TrigDecisionTool> m_trigDec {this, "TrigDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", "TrigDecisionTool"};
  PublicToolHandle<Trk::IExtrapolator> m_extrapolator {"Trk::Extrapolator/AtlasExtrapolator"};
  
  //The extrapolator is currently not available. Once it gets available, initialize it with the following, which attempts to retrieve:
  //{this, "Extrapolator", "Trk::Extrapolator/AtlasExtrapolator", "Track extrapolator"}; 
};
 
#include "MuonMatchingTool.icc"
 
#endif //TRIGMUONMONITORING_MUONMATCHINGTOOL_H