EFMuonMon.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "EFMuonMon.h"
 
#include "MuonMatchingTool.h"
#include "StoreGate/ReadDecorHandle.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
 
EFMuonMon::EFMuonMon(const std::string& name, ISvcLocator* pSvcLocator )
  : TrigMuonMonitorAlgorithm(name, pSvcLocator)
{}
 
 
StatusCode EFMuonMon::initialize(){
  StatusCode sc = TrigMuonMonitorAlgorithm::initialize();
  ATH_CHECK( m_EFSAMuonKey.initialize() );
  ATH_CHECK( m_EFSAMlbktMuonKey.initialize(!m_EFSAMlbktMuonKey.empty()) );
  ATH_CHECK( m_EFSANewFastMuonKey.initialize(!m_EFSANewFastMuonKey.empty()) );
  ATH_CHECK( m_EFCBMuonKey.initialize() );
  ATH_CHECK( m_EFSATrackKey.initialize() );
  ATH_CHECK( m_EFSAMlbktTrackKey.initialize(!m_EFSAMlbktTrackKey.empty()) );
  ATH_CHECK( m_EFSANewFastTrackKey.initialize(!m_EFSANewFastTrackKey.empty()) );
  ATH_CHECK( m_EFCBTrackKey.initialize() );
  ATH_CHECK( m_muonIso30Key.initialize() );
 
  for( const std::string& chain : m_monitored_chains ){
    m_doEFSA[chain] = true;
 
    if(chain.contains("msonly")) m_doEFCB[chain] = false;
    else m_doEFCB[chain] = true;
 
    if(chain.contains("ivar")) m_doEFIso[chain] = true;
    else m_doEFIso[chain] = false;
  }
 
  return sc;
}
 
 
StatusCode EFMuonMon::fillVariablesPerChain(const EventContext &ctx, const std::string &chain) const {
 
  ATH_MSG_DEBUG ("Filling histograms for " << name() << "...");
 
  const float ZERO_LIMIT = 0.00001;
 
  // EFSA
  if( m_doEFSA.at(chain) ){
    std::vector< TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> > featureContSA = getTrigDecisionTool()->features<xAOD::MuonContainer>( chain, TrigDefs::includeFailedDecisions, "HLT_Muons_.*");
  
    for (const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>& muSALinkInfo : featureContSA) {
      ATH_CHECK( muSALinkInfo.isValid() );
      const ElementLink<xAOD::MuonContainer> muSAEL = muSALinkInfo.link;
      if ( (*muSAEL)->muonType() != xAOD::Muon::MuonType::MuonStandAlone ) continue;
  
      auto EFSAPt = Monitored::Scalar<float>(chain+"_EFSA_Pt", -999.);
      auto EFSAEta = Monitored::Scalar<float>(chain+"_EFSA_Eta", -999.);
      auto EFSAPhi = Monitored::Scalar<float>(chain+"_EFSA_Phi", -999.);
  
      EFSAPt = (*muSAEL)->pt()/1e3 * (*muSAEL)->charge();
      EFSAEta = (*muSAEL)->eta();
      EFSAPhi = (*muSAEL)->phi(); 
  
      fill(m_group+"_"+chain, EFSAPt, EFSAEta, EFSAPhi);
    }
  }
 
 
  // EFCB
  if( m_doEFCB.at(chain) ){
    std::vector< TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> > featureContCB = getTrigDecisionTool()->features<xAOD::MuonContainer>( chain, TrigDefs::includeFailedDecisions, "HLT_MuonsCB.*");
  
    for (const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>& muCBLinkInfo : featureContCB) {
      ATH_CHECK( muCBLinkInfo.isValid() );
      const ElementLink<xAOD::MuonContainer> muCBEL = muCBLinkInfo.link;
      if ( (*muCBEL)->muonType() != xAOD::Muon::MuonType::Combined ) continue;
  
      auto EFCBPt = Monitored::Scalar<float>(chain+"_EFCB_Pt", -999.);
      auto EFCBEta = Monitored::Scalar<float>(chain+"_EFCB_Eta", -999.);
      auto EFCBPhi = Monitored::Scalar<float>(chain+"_EFCB_Phi", -999.);
  
      EFCBPt = (*muCBEL)->pt()/1e3 * (*muCBEL)->charge();
      EFCBEta = (*muCBEL)->eta();
      EFCBPhi = (*muCBEL)->phi(); 
  
      fill(m_group+"_"+chain, EFCBPt, EFCBEta, EFCBPhi);
    }
  }
 
 
  // EFIso
  if( m_doEFIso.at(chain) ){
    std::vector< TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> > featureContIso = getTrigDecisionTool()->features<xAOD::MuonContainer>( chain, TrigDefs::includeFailedDecisions, "HLT_MuonsIso");
    for (const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer>& muIsoLinkInfo : featureContIso) {
      ATH_CHECK( muIsoLinkInfo.isValid() );
      const ElementLink<xAOD::MuonContainer> muIsoEL = muIsoLinkInfo.link;
      if ( (*muIsoEL)->muonType() != xAOD::Muon::MuonType::Combined ) continue;
  
      // basic variables used decision
      auto PtCone03 = Monitored::Scalar<float>(chain+"_PtCone03",-999.);
      auto PtCone03overMuonPt = Monitored::Scalar<float>(chain+"_PtCone03overMuonPt",-999.);
  
      SG::ReadDecorHandle<xAOD::MuonContainer, double> muonIso30 ( m_muonIso30Key, ctx );
      float ptcone30 = muonIso30(*(*muIsoEL));
  
      if (ptcone30 > ZERO_LIMIT ){
        PtCone03 = ptcone30/1e3;
        PtCone03overMuonPt = ptcone30 / (*muIsoEL)->pt();
      }
  
      fill(m_group+"_"+chain, PtCone03, PtCone03overMuonPt);
    }
  }
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode EFMuonMon::fillVariablesPerOfflineMuonPerChain(const EventContext &ctx, const xAOD::Muon* mu, const std::string &chain) const {
 
  ATH_MSG_DEBUG ("Filling histograms for " << name() << "...");
 
  const float ZERO_LIMIT = 0.00001;
 
  const xAOD::TrackParticle* OfflineSATrack = mu->trackParticle(xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
  const xAOD::TrackParticle* OfflineCBTrack = mu->trackParticle(xAOD::Muon::TrackParticleType::CombinedTrackParticle);
 
 
  // OfflineSA
  if( m_doEFSA.at(chain) && OfflineSATrack ){
    auto OfflineSAPt = Monitored::Scalar<float>(chain+"_OfflineSA_Pt",-999.);
    auto OfflineSAEta = Monitored::Scalar<float>(chain+"_OfflineSA_Eta",-999.);
    auto OfflineSAPhi = Monitored::Scalar<float>(chain+"_OfflineSA_Phi",-999.);
 
    auto matchedEFSA = Monitored::Scalar<bool>(chain+"_matchedEFSA",false);
    auto matchedL2SA = Monitored::Scalar<bool>(chain+"_matchedL2SA",false);
 
    auto OfflineSAmatchedL2SAPt = Monitored::Scalar<float>(chain+"_OfflineSAmatchedL2SA_Pt",-999.);
    auto OfflineSAmatchedL2SAEta = Monitored::Scalar<float>(chain+"_OfflineSAmatchedL2SA_Eta",-999.);
    auto OfflineSAmatchedL2SAPhi = Monitored::Scalar<float>(chain+"_OfflineSAmatchedL2SA_Phi",-999.);
 
    auto MatchedEFSAPt = Monitored::Scalar<float>(chain+"_MatchedEFSA_Pt",-999.);
    auto MatchedEFSAEta = Monitored::Scalar<float>(chain+"_MatchedEFSA_Eta",-999.);
    auto MatchedEFSAPhi = Monitored::Scalar<float>(chain+"_MatchedEFSA_Phi",-999.);
 
    auto SAdR = Monitored::Scalar<float>(chain+"_SAdR",1000.);
    auto SAdPt = Monitored::Scalar<float>(chain+"_SAdPt",-999.);
    auto SAdEta = Monitored::Scalar<float>(chain+"_SAdEta",-999.);
    auto SAdPhi = Monitored::Scalar<float>(chain+"_SAdPhi",-999.);
 
    // basic EDM variables
    OfflineSAPt = OfflineSATrack->pt()/1e3 * OfflineSATrack->charge(); // convert to GeV
    OfflineSAEta = OfflineSATrack->eta();
    OfflineSAPhi = OfflineSATrack->phi();
 
    // correlation histograms EFSA vs. OfflineSA
    // get the EFSA muon matched to offlineSA muon
    const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> EFSAMuonLinkInfo = m_matchTool->matchEFSALinkInfo(mu, chain); 
    if( EFSAMuonLinkInfo.isValid() ){
      const auto& trkReadHandleKey {chain.contains("newFast") ? m_EFSANewFastTrackKey 
        : (chain.contains("mlbkt") ? m_EFSAMlbktTrackKey : m_EFSATrackKey)};
      const xAOD::TrackParticle* EFSATrack = m_matchTool->SearchEFTrack(ctx, EFSAMuonLinkInfo, trkReadHandleKey);
      if ( EFSATrack ){
        matchedEFSA = true;
  
        MatchedEFSAPt = EFSATrack->pt()/1e3 * EFSATrack->charge(); // convert to GeV
        MatchedEFSAEta = EFSATrack->eta();
        MatchedEFSAPhi = EFSATrack->phi();
  
        SAdR = xAOD::P4Helpers::deltaR(OfflineSATrack, EFSATrack, false); 
        SAdPt = std::abs(OfflineSAPt) - std::abs(MatchedEFSAPt);
        SAdEta = OfflineSAEta - MatchedEFSAEta;
        SAdPhi = OfflineSAPhi - MatchedEFSAPhi;
  
  
        // correlation histograms offlineSA (matched to EFSA) vs. offlineSA (matched to L2SA)
        // get L2SA feature
        const xAOD::Muon *OfflineSAmatchedL2SA {nullptr};
        if (chain.contains("newFast")) {
            
            const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> L2SALinkInfo = m_matchTool->searchFastRecoSALinkInfo(mu, chain);
            ATH_CHECK( L2SALinkInfo.isValid());
 
            // get offline muon matched to L2SA
            const ElementLink<xAOD::MuonContainer> L2SAEL = L2SALinkInfo.link;
            OfflineSAmatchedL2SA = m_matchTool->matchFastRecoSAtoOff(ctx, (*L2SAEL));
        } else {
 
            const TrigCompositeUtils::LinkInfo<xAOD::L2StandAloneMuonContainer> L2SALinkInfo = m_matchTool->searchL2SALinkInfo(mu, chain);
            ATH_CHECK( L2SALinkInfo.isValid());
            
            // get offline muon matched to L2SA
            const ElementLink<xAOD::L2StandAloneMuonContainer> L2SAEL = L2SALinkInfo.link;
            OfflineSAmatchedL2SA = m_matchTool->matchL2SAtoOff(ctx, (*L2SAEL));
        }
        
        if (OfflineSAmatchedL2SA){
          const xAOD::TrackParticle* OfflineSATrackmatchedL2SA = OfflineSAmatchedL2SA->trackParticle(xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle);
          if ( OfflineSATrackmatchedL2SA ){
            matchedL2SA = true;
            OfflineSAmatchedL2SAPt = OfflineSATrackmatchedL2SA->pt()/1e3 * OfflineSATrackmatchedL2SA->charge(); // convert to GeV
            OfflineSAmatchedL2SAEta = OfflineSATrackmatchedL2SA->eta();
            OfflineSAmatchedL2SAPhi = OfflineSATrackmatchedL2SA->phi();
          }
        }
      }
    }
    fill(m_group+"_"+chain, OfflineSAPt, OfflineSAEta, OfflineSAPhi, OfflineSAmatchedL2SAPt, OfflineSAmatchedL2SAEta, OfflineSAmatchedL2SAPhi,
         MatchedEFSAPt, MatchedEFSAEta, MatchedEFSAPhi, SAdPt, SAdEta, SAdPhi, SAdR, matchedEFSA, matchedL2SA);
  }
 
 
  // OfflineCB
  if( m_doEFCB.at(chain) && OfflineCBTrack ){
    auto OfflineCBPt = Monitored::Scalar<float>(chain+"_OfflineCB_Pt",-999.);
    auto OfflineCBEta = Monitored::Scalar<float>(chain+"_OfflineCB_Eta",-999.);
    auto OfflineCBPhi = Monitored::Scalar<float>(chain+"_OfflineCB_Phi",-999.);
 
    auto matchedEFCB = Monitored::Scalar<bool>(chain+"_matchedEFCB",false);
    auto matchedL2CB = Monitored::Scalar<bool>(chain+"_matchedL2CB",false);
 
    auto OfflineCBmatchedL2CBPt = Monitored::Scalar<float>(chain+"_OfflineCBmatchedL2CB_Pt",-999.);
    auto OfflineCBmatchedL2CBEta = Monitored::Scalar<float>(chain+"_OfflineCBmatchedL2CB_Eta",-999.);
    auto OfflineCBmatchedL2CBPhi = Monitored::Scalar<float>(chain+"_OfflineCBmatchedL2CB_Phi",-999.);
 
    auto MatchedEFCBPt = Monitored::Scalar<float>(chain+"_MatchedEFCB_Pt",-999.);
    auto MatchedEFCBEta = Monitored::Scalar<float>(chain+"_MatchedEFCB_Eta",-999.);
    auto MatchedEFCBPhi = Monitored::Scalar<float>(chain+"_MatchedEFCB_Phi",-999.);
  
    auto CBdR = Monitored::Scalar<float>(chain+"_CBdR",1000.);
    auto CBdPt = Monitored::Scalar<float>(chain+"_CBdPt",-999.);
    auto CBdEta = Monitored::Scalar<float>(chain+"_CBdEta",-999.);
    auto CBdPhi = Monitored::Scalar<float>(chain+"_CBdPhi",-999.);
 
    // basic EDM variables
    OfflineCBPt = OfflineCBTrack->pt()/1e3 * OfflineCBTrack->charge(); // convert to GeV
    OfflineCBEta = OfflineCBTrack->eta();
    OfflineCBPhi = OfflineCBTrack->phi();
 
    // correlation histograms EFCB vs. OfflineCB
    // get the closest EFCB muon
    const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> EFCBMuonLinkInfo = m_matchTool->matchEFCBLinkInfo(mu, chain);
    if( EFCBMuonLinkInfo.isValid() ){
      const xAOD::TrackParticle* EFCBTrack = m_matchTool->SearchEFTrack(ctx, EFCBMuonLinkInfo, m_EFCBTrackKey);
      if ( EFCBTrack ){
        matchedEFCB = true;
  
        MatchedEFCBPt = EFCBTrack->pt()/1e3 * EFCBTrack->charge(); // convert to GeV
        MatchedEFCBEta = EFCBTrack->eta();
        MatchedEFCBPhi = EFCBTrack->phi();
  
        CBdR = xAOD::P4Helpers::deltaR(OfflineCBTrack, EFCBTrack, false); 
        CBdPt = std::abs(OfflineCBPt) - std::abs(MatchedEFCBPt);
        CBdEta = OfflineCBEta - MatchedEFCBEta;
        CBdPhi = OfflineCBPhi - MatchedEFCBPhi;
  
  
        // correlation histograms offlineCB (matched to EFCB) vs. offlineCB (matched to  L2CB)
        // get L2CB feature
        const TrigCompositeUtils::Decision* EFCBMuonDecision = EFCBMuonLinkInfo.source;
        const std::vector<TrigCompositeUtils::LinkInfo<xAOD::L2CombinedMuonContainer>>L2CBLinkInfo = TrigCompositeUtils::findLinks<xAOD::L2CombinedMuonContainer>(ctx, EFCBMuonDecision, "feature");
        if(L2CBLinkInfo.size() >1) {
           ATH_MSG_DEBUG("More than one L2CB muon associated to EFCBMuon");
        }
        ATH_CHECK( L2CBLinkInfo.at(0).isValid() );
        const ElementLink<xAOD::L2CombinedMuonContainer> L2CBEL = L2CBLinkInfo.at(0).link;
  
        // get offline muon matched to L2CB
        const xAOD::Muon *OfflineCBmatchedL2CB = m_matchTool->matchL2CBtoOff(ctx, (*L2CBEL));
        if (OfflineCBmatchedL2CB){
          const xAOD::TrackParticle* OfflineCBTrackmatchedL2CB = OfflineCBmatchedL2CB->trackParticle(xAOD::Muon::TrackParticleType::CombinedTrackParticle);
          if ( OfflineCBTrackmatchedL2CB ){
            matchedL2CB = true;
            OfflineCBmatchedL2CBPt = OfflineCBTrackmatchedL2CB->pt()/1e3 * OfflineCBTrackmatchedL2CB->charge(); // convert to GeV
            OfflineCBmatchedL2CBEta = OfflineCBTrackmatchedL2CB->eta();
            OfflineCBmatchedL2CBPhi = OfflineCBTrackmatchedL2CB->phi();
          }
        }
      }
    }
    fill(m_group+"_"+chain, OfflineCBPt, OfflineCBEta, OfflineCBPhi, OfflineCBmatchedL2CBPt, OfflineCBmatchedL2CBEta, OfflineCBmatchedL2CBPhi,
         MatchedEFCBPt, MatchedEFCBEta, MatchedEFCBPhi, CBdPt, CBdEta, CBdPhi, CBdR, matchedEFCB, matchedL2CB);
  }
 
 
  // offoine isolation variable
  float OfflineIsoptcone30=-1.;
  mu->isolation(OfflineIsoptcone30, xAOD::Iso::IsolationType::ptvarcone30);
  if ( m_doEFIso.at(chain) && OfflineIsoptcone30 > ZERO_LIMIT ){
 
    auto OfflineIsoPtCone03 = Monitored::Scalar<float>(chain+"_OfflineIsoPtCone03",-999.);
    auto OfflineIsoPtCone03overMuonPt = Monitored::Scalar<float>(chain+"_OfflineIsoPtCone03overMuonPt",-999.);
    auto MatchedEFIsoPtCone03 = Monitored::Scalar<float>(chain+"_MatchedEFPIsotCone03",-999.);
    auto MatchedEFIsoPtCone03overMuonPt = Monitored::Scalar<float>(chain+"_MatchedEFIsoPtCone03overMuonPt",-999.);
 
    OfflineIsoPtCone03 = OfflineIsoptcone30/1e3;
    OfflineIsoPtCone03overMuonPt = OfflineIsoptcone30 / mu->pt();
 
    // get the closest EFIso muon
    const TrigCompositeUtils::LinkInfo<xAOD::MuonContainer> EFIsoMuonLinkInfo = m_matchTool->matchEFIsoLinkInfo(mu, chain);
    if( EFIsoMuonLinkInfo.isValid() ){
      const ElementLink<xAOD::MuonContainer> EFIsoMuon = EFIsoMuonLinkInfo.link;
 
      SG::ReadDecorHandle<xAOD::MuonContainer, double> muonIso30 ( m_muonIso30Key, ctx );
      float EFIsoptcone30 = muonIso30(*(*EFIsoMuon));
 
      if ( EFIsoptcone30 > ZERO_LIMIT ){
        MatchedEFIsoPtCone03 = EFIsoptcone30/1e3;
        MatchedEFIsoPtCone03overMuonPt = EFIsoptcone30 / (*EFIsoMuon)->pt();
      }
    }
    fill(m_group+"_"+chain, OfflineIsoPtCone03, OfflineIsoPtCone03overMuonPt, MatchedEFIsoPtCone03, MatchedEFIsoPtCone03overMuonPt);
  }
 
  return StatusCode::SUCCESS;
}
 
 
StatusCode EFMuonMon::fillVariables(const EventContext &ctx) const {
 
  ATH_MSG_DEBUG ("Filling histograms for " << name() << "...");
 
  ATH_CHECK( fillVariableEtaPhi<xAOD::Muon>(ctx, m_EFSAMuonKey, "EFSA", &MuonMatchingTool::trigPosForMatchSATrack));
 
  if (!m_EFSAMlbktMuonKey.empty()) {
    ATH_CHECK( fillVariableEtaPhi<xAOD::Muon>(ctx, m_EFSAMlbktMuonKey, "EFSA_mlbkt", &MuonMatchingTool::trigPosForMatchSATrack));
  }
 
  if (!m_EFSANewFastMuonKey.empty()) {
    ATH_CHECK( fillVariableEtaPhi<xAOD::Muon>(ctx, m_EFSANewFastMuonKey, "EFSA_newFast", &MuonMatchingTool::trigPosForMatchSATrack));
  }
  
  ATH_CHECK( fillVariableEtaPhi<xAOD::Muon>(ctx, m_EFCBMuonKey, "EFCB", &MuonMatchingTool::trigPosForMatchCBTrack));
  return StatusCode::SUCCESS;
}
 
 
StatusCode EFMuonMon::fillVariablesPerOfflineMuon(const EventContext &ctx, const xAOD::Muon* mu) const {
 
  ATH_CHECK( fillVariablesRatioPlots<xAOD::Muon>(ctx, mu, "EFSA", xAOD::Muon::TrackParticleType::ExtrapolatedMuonSpectrometerTrackParticle,
                                                 [this](const EventContext &c, const xAOD::Muon *m){ return m_matchTool->matchEFSAReadHandle(c,m); }
                                                 )); 
 
  ATH_CHECK( fillVariablesRatioPlots<xAOD::Muon>(ctx, mu, "EFCB", xAOD::Muon::TrackParticleType::CombinedTrackParticle,
                                                 [this](const EventContext &c, const xAOD::Muon *m){ return m_matchTool->matchEFCBReadHandle(c,m); }
                                                 )); 
 
  return StatusCode::SUCCESS;
}