MuonTree.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "MuonHistUtils/MuonTree.h"
 
#include "AthContainers/ConstAccessor.h"
#include "TROOT.h"
#include "TVector3.h"
#include "xAODTracking/TrackingPrimitives.h"
 
namespace Muon {
 
MuonTree::MuonTree(PlotBase* pParent, const std::string& sDir, bool mcFlag)
    : PlotBase(pParent, sDir),
      m_isMC(mcFlag),
      m_runNumber(-999),
      m_lumiBlock(-999),
      m_eventNumber(-999),
      m_mcChannelNumber(-999),
      m_mcBeamSpotWeight(1.0) {}
 
MuonTree::MuonTree(PlotBase* pParent, const std::string& sDir)
    : PlotBase(pParent, sDir),
      m_isMC(true),
      m_runNumber(-999),
      m_lumiBlock(-999),
      m_eventNumber(-999),
      m_mcChannelNumber(-999),
      m_mcBeamSpotWeight(1.0) {}
 
MuonTree::~MuonTree() {}
 
void MuonTree::initializePlots() {
    m_tree.reset(BookTree("MuonTree"));
 
    // EventInfo
    m_tree->Branch("runNumber", &m_runNumber, "runNumber/i");
    m_tree->Branch("lumiBlock", &m_lumiBlock, "lumiBlock/i");
    m_tree->Branch("eventNumber", &m_eventNumber, "eventNumber/l");
    m_tree->Branch("mcChannelNumber", &m_mcChannelNumber, "mcChannelNumber/i");
    m_tree->Branch("mcBeamSpotWeight", &m_mcBeamSpotWeight,
                   "mcBeamSpotWeight/f");
 
    //
    // Reco
    //
    // General properties
    m_tree->Branch("pt", &m_pt);
    m_tree->Branch("eta", &m_eta);
    m_tree->Branch("phi", &m_phi);
    m_tree->Branch("e", &m_e);
    m_tree->Branch("rapidity", &m_rapidity);
 
    // authors and types
    m_tree->Branch("allAuthors", &m_allAuthors);
    m_tree->Branch("muonType", &m_muonType);
 
    // summary values
    m_tree->Branch("innerSmallHits", &m_innerSmallHits);
    m_tree->Branch("innerLargeHits", &m_innerLargeHits);
    m_tree->Branch("innerSmallHoles", &m_innerSmallHoles);
    m_tree->Branch("innerLargeHoles", &m_innerLargeHoles);
 
    // parameters
    m_tree->Branch("msInnerMatchChi2", &m_msInnerMatchChi2);
    m_tree->Branch("msInnerMatchDOF", &m_msInnerMatchDOF);
    m_tree->Branch("msOuterMatchChi2", &m_msOuterMatchChi2);
    m_tree->Branch("msOuterMatchDOF", &m_msOuterMatchDOF);
    m_tree->Branch("CaloLRLikelihood", &m_CaloLRLikelihood);
    m_tree->Branch("CaloMuonIDTag", &m_CaloMuonIDTag);
    m_tree->Branch("EnergyLoss", &m_EnergyLoss);
 
    // quality
    m_tree->Branch("Quality", &m_Quality);
 
    // isolation
    m_tree->Branch("iso_ptcone20", &m_iso_ptcone20);
    m_tree->Branch("iso_topoetcon20", &m_iso_topoetcon20);
    m_tree->Branch("iso_ptvarcon20", &m_iso_ptvarcon20);
    m_tree->Branch("iso_neflowisol20", &m_iso_neflowisol20);
 
    // associated TrackParticle
    m_tree->Branch("trkp_d0", &m_trkp_d0);
    m_tree->Branch("trkp_z0", &m_trkp_z0);
    m_tree->Branch("trkp_qOverP", &m_trkp_qOverP);
    m_tree->Branch("trkp_chiSquared", &m_trkp_chiSquared);
    m_tree->Branch("trkp_numberDoF", &m_trkp_numberDoF);
 
    // used MuonSegment
    m_tree->Branch("nMuonSegments", &m_nMuonSegments);
    m_tree->Branch("museg_x", &m_museg_x);
    m_tree->Branch("museg_y", &m_museg_y);
    m_tree->Branch("museg_z", &m_museg_z);
    m_tree->Branch("museg_sector", &m_museg_sector);
    m_tree->Branch("museg_chamberIndex", &m_museg_chamberIndex);
    m_tree->Branch("museg_technology", &m_museg_technology);
    m_tree->Branch("museg_nPrecisionHits", &m_museg_nPrecisionHits);
    m_tree->Branch("museg_nPhiLayers", &m_museg_nPhiLayers);
    m_tree->Branch("museg_nTrigEtaLayers", &m_museg_nTrigEtaLayers);
 
    if (!m_isMC) {
        return;
    }
 
    //
    // Truth
    //
    // Trk::Param
    // all TruthTrack
    m_tree->Branch("th_isGoodTruthTrack", &m_th_isGoodTruthTrack);
 
    m_tree->Branch("th_pt", &m_th_pt);
    m_tree->Branch("th_eta", &m_th_eta);
    m_tree->Branch("th_phi", &m_th_phi);
 
    // Trk::TruthInfo
    //  all TruthTrack
    m_tree->Branch("th_truthType", &m_th_truthType);
    m_tree->Branch("th_truthOrigin", &m_th_truthOrigin);
 
    // Trk::TruthTrkExtrapolation
    //  all TruthTrack
    m_tree->Branch("th_CaloEntryLayer_p", &m_th_CaloEntry_p);
    m_tree->Branch("th_MuonEntryLayer_p", &m_th_MuonEntry_p);
    m_tree->Branch("th_MuonExitLayer_p", &m_th_MuonExit_p);
 
    // Trk::MSHit
    //  all TruthTrack
    m_tree->Branch("th_nprecLayers", &m_th_nprecLayers);
    m_tree->Branch("th_nphiLayers", &m_th_nphiLayers);
    m_tree->Branch("th_ntrigEtaLayers", &m_th_ntrigEtaLayers);
}
 
void MuonTree::fillEventBranches(const xAOD::EventInfo* eventInfo,
                                 bool isData) {
    m_runNumber = eventInfo->runNumber();
    if (isData) {
        m_lumiBlock = eventInfo->lumiBlock();
        m_eventNumber = eventInfo->eventNumber();
        m_mcChannelNumber = 0;
        m_mcBeamSpotWeight = 1.0;
    } else {
        m_lumiBlock = 0;
        m_eventNumber = eventInfo->mcEventNumber();
        m_mcChannelNumber = eventInfo->mcChannelNumber();
        m_mcBeamSpotWeight = eventInfo->beamSpotWeight();
    }
}
 
void MuonTree::fillRecoMuonBranches(const xAOD::Muon& mu) {
    // general properties
    m_pt.push_back(mu.pt());
    m_eta.push_back(mu.eta());
    m_phi.push_back(mu.phi());
    m_e.push_back(mu.e());
    m_rapidity.push_back(mu.rapidity());
 
    // authors and types
    m_allAuthors.push_back(mu.allAuthors());
    m_muonType.push_back(mu.muonType());
 
    int8_t hitVal = 0;
    if (!mu.summaryValue((uint8_t&)hitVal,
                         xAOD::MuonSummaryType::innerSmallHits)) {
        hitVal = -1;
    }
    m_innerSmallHits.push_back(hitVal);
    if (!mu.summaryValue((uint8_t&)hitVal,
                         xAOD::MuonSummaryType::innerLargeHits)) {
        hitVal = -1;
    }
    m_innerLargeHits.push_back(hitVal);
    if (!mu.summaryValue((uint8_t&)hitVal,
                         xAOD::MuonSummaryType::innerSmallHoles)) {
        hitVal = -1;
    }
    m_innerSmallHoles.push_back(hitVal);
    if (!mu.summaryValue((uint8_t&)hitVal,
                         xAOD::MuonSummaryType::innerLargeHoles)) {
        hitVal = -1;
    }
    m_innerLargeHoles.push_back(hitVal);
 
    // parameters
    float value;
    int ivalue;
    if (!(mu.parameter(value, xAOD::Muon::ParamDef::msInnerMatchChi2))) {
        value = -999.;
    }
    m_msInnerMatchChi2.push_back(value);
    if (!(mu.parameter(ivalue, xAOD::Muon::ParamDef::msInnerMatchDOF))) {
        ivalue = -999;
    }
    m_msInnerMatchDOF.push_back(ivalue);
    if (!(mu.parameter(value, xAOD::Muon::ParamDef::msOuterMatchChi2))) {
        value = -999.;
    }
    m_msOuterMatchChi2.push_back(value);
    if (!(mu.parameter(ivalue, xAOD::Muon::ParamDef::msOuterMatchDOF))) {
        ivalue = -999;
    }
    m_msOuterMatchDOF.push_back(ivalue);
    if (!(mu.parameter(value, xAOD::Muon::ParamDef::CaloLRLikelihood))) {
        value = -999.;
    }
    m_CaloLRLikelihood.push_back(value);
    if (!(mu.parameter(ivalue, xAOD::Muon::ParamDef::CaloMuonIDTag))) {
        ivalue = -999;
    }
    m_CaloMuonIDTag.push_back(ivalue);
    if (!(mu.parameter(value, xAOD::Muon::ParamDef::EnergyLoss))) {
        value = -999.;
    }
    m_EnergyLoss.push_back(value);
 
    // quality
    m_Quality.push_back(mu.quality());
 
    // isolation
    if (!(mu.isolation(value, xAOD::Iso::IsolationType::ptcone20))) {
        value = -999.;
    }
    m_iso_ptcone20.push_back(value);
    if (!(mu.isolation(value, xAOD::Iso::IsolationType::topoetcone20))) {
        value = -999.;
    }
    m_iso_topoetcon20.push_back(value);
    if (!(mu.isolation(value, xAOD::Iso::IsolationType::ptvarcone20))) {
        value = -999.;
    }
    m_iso_ptvarcon20.push_back(value);
    if (!(mu.isolation(value, xAOD::Iso::IsolationType::neflowisol20))) {
        value = -999.;
    }
    m_iso_neflowisol20.push_back(value);
 
    // associated TrackParticle
    m_trkp_d0.push_back(mu.primaryTrackParticle()->d0());
    m_trkp_z0.push_back(mu.primaryTrackParticle()->z0());
    m_trkp_qOverP.push_back(mu.primaryTrackParticle()->qOverP());
    m_trkp_chiSquared.push_back(mu.primaryTrackParticle()->chiSquared());
    m_trkp_numberDoF.push_back(mu.primaryTrackParticle()->numberDoF());
 
    // used MuonSegments
    size_t nMuonSegments = mu.nMuonSegments();
    m_nMuonSegments.push_back(nMuonSegments);
    size_t muonIndx = m_nMuonSegments.size() - 1;
 
    m_museg_x.push_back(std::vector<float>());
    m_museg_y.push_back(std::vector<float>());
    m_museg_z.push_back(std::vector<float>());
    m_museg_sector.push_back(std::vector<int>());
    m_museg_chamberIndex.push_back(std::vector<unsigned int>());
    m_museg_technology.push_back(std::vector<unsigned int>());
    m_museg_nPrecisionHits.push_back(std::vector<int>());
    m_museg_nPhiLayers.push_back(std::vector<int>());
    m_museg_nTrigEtaLayers.push_back(std::vector<int>());
 
    for (int i = 0; (size_t)i < nMuonSegments; i++) {
        const xAOD::MuonSegment* muonSegment = mu.muonSegment(i);
        m_museg_x[muonIndx].push_back(muonSegment->x());
        m_museg_y[muonIndx].push_back(muonSegment->y());
        m_museg_z[muonIndx].push_back(muonSegment->z());
        m_museg_sector[muonIndx].push_back(muonSegment->sector());
        m_museg_chamberIndex[muonIndx].push_back(
            (int)muonSegment->chamberIndex());
        m_museg_technology[muonIndx].push_back((int)muonSegment->technology());
        m_museg_nPrecisionHits[muonIndx].push_back(
            muonSegment->nPrecisionHits());
        m_museg_nPhiLayers[muonIndx].push_back(muonSegment->nPhiLayers());
        m_museg_nTrigEtaLayers[muonIndx].push_back(
            muonSegment->nTrigEtaLayers());
    }
}
 
void MuonTree::fillTruthMuonBranches(const xAOD::TruthParticle& truthMu,
                                     bool isGoodTruthTrack) {
 
    //
    // Trk::Param
    //
    if (isGoodTruthTrack) {
        m_th_isGoodTruthTrack.push_back(true);
    } else {
        m_th_isGoodTruthTrack.push_back(false);
    }
 
    m_th_pt.push_back(truthMu.pt());
    m_th_eta.push_back(truthMu.eta());
    m_th_phi.push_back(truthMu.phi());
 
    //
    // Trk::TruthInfo
    //
    static const SG::ConstAccessor<int> truthTypeAcc("truthType");
    static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
    if (truthTypeAcc.isAvailable(truthMu)) {
        m_th_truthType.push_back(truthTypeAcc(truthMu));
    } else {
        m_th_truthType.push_back(-999);
    }
 
    if (truthOriginAcc.isAvailable(truthMu)) {
        m_th_truthOrigin.push_back(truthOriginAcc(truthMu));
    } else {
        m_th_truthOrigin.push_back(-999);
    }
 
    //
    // Trk::TruthTrkExtrapolation
    //
    static const SG::ConstAccessor<float> caloEnt_pxAcc("CaloEntryLayer_px");
    static const SG::ConstAccessor<float> caloEnt_pyAcc("CaloEntryLayer_py");
    static const SG::ConstAccessor<float> caloEnt_pzAcc("CaloEntryLayer_pz");
    if (caloEnt_pxAcc.isAvailable(truthMu) &&
        caloEnt_pyAcc.isAvailable(truthMu) &&
        caloEnt_pzAcc.isAvailable(truthMu)) {
        TVector3 v(caloEnt_pxAcc(truthMu), caloEnt_pyAcc(truthMu),
                   caloEnt_pzAcc(truthMu));
        m_th_CaloEntry_p.push_back(v.Mag() * 0.001);
    } else {
        m_th_CaloEntry_p.push_back(-999.);
    }
 
    static const SG::ConstAccessor<float> muonEnt_pxAcc("MuonEntryLayer_px");
    static const SG::ConstAccessor<float> muonEnt_pyAcc("MuonEntryLayer_py");
    static const SG::ConstAccessor<float> muonEnt_pzAcc("MuonEntryLayer_pz");
    if (muonEnt_pxAcc.isAvailable(truthMu) &&
        muonEnt_pyAcc.isAvailable(truthMu) &&
        muonEnt_pzAcc.isAvailable(truthMu)) {
 
        TVector3 v(muonEnt_pxAcc(truthMu), muonEnt_pyAcc(truthMu),
                   muonEnt_pzAcc(truthMu));
        m_th_MuonEntry_p.push_back(v.Mag() * 0.001);
    } else {
        m_th_MuonEntry_p.push_back(-999.);
    }
 
    static const SG::ConstAccessor<float> muonExit_pxAcc("MuonExitLayer_px");
    static const SG::ConstAccessor<float> muonExit_pyAcc("MuonExitLayer_py");
    static const SG::ConstAccessor<float> muonExit_pzAcc("MuonExitLayer_pz");
    if (muonExit_pxAcc.isAvailable(truthMu) &&
        muonExit_pyAcc.isAvailable(truthMu) &&
        muonExit_pzAcc.isAvailable(truthMu)) {
 
        TVector3 v(muonExit_pxAcc(truthMu), muonExit_pyAcc(truthMu),
                   muonExit_pzAcc(truthMu));
        m_th_MuonExit_p.push_back(v.Mag() * 0.001);
    } else {
        m_th_MuonExit_p.push_back(-999.);
    }
 
    //
    // Trk::MSHit
    //
    static const SG::ConstAccessor<uint8_t> nprecAcc("nprecLayers");
    if (nprecAcc.isAvailable(truthMu)) {
        m_th_nprecLayers.push_back(nprecAcc(truthMu));
    } else {
        m_th_nprecLayers.push_back(-99);
    }
 
    static const SG::ConstAccessor<uint8_t> nphiAcc("nphiLayers");
    if (nphiAcc.isAvailable(truthMu)) {
        m_th_nphiLayers.push_back(nphiAcc(truthMu));
    } else {
        m_th_nphiLayers.push_back(-99);
    }
 
    static const SG::ConstAccessor<uint8_t> ntrigEtaAcc("ntrigEtaLayers");
    if (ntrigEtaAcc.isAvailable(truthMu)) {
        m_th_ntrigEtaLayers.push_back(ntrigEtaAcc(truthMu));
    } else {
        m_th_ntrigEtaLayers.push_back(-99);
    }
}
 
void MuonTree::fillTruthMuonBranches(
    const xAOD::TruthParticle& truthMu, const xAOD::Muon& mu,
    const xAOD::TrackParticleContainer* MSTracks, bool isGoodTruthTrack) {
    // If there is an interest to have an additional observable, which is
    // derived from both reco and truth muon objects, stored in the validation
    // tree, then this observable can be calculated/retrieved like, e.g., it is
    // done here:
    //
    // line:0175
    // athena/MuonSpectrometer/MuonValidation/MuonDQA/MuonPhysValMonitoring/src/MuonValidationPlots.cxx
    //                  athena/MuonSpectrometer/MuonValidation/MuonHistogramming/MuonHistUtils/MuonHistUtils/TruthRelatedMuonPlotOrganizer.h
    //      line: 0090
    //      athena/MuonSpectrometer/MuonValidation/MuonHistogramming/MuonHistUtils/Root/TruthRelatedMuonPlotOrganizer.cxx
    //
    //
    // Meanwhile, use these useless statements to void compilation warnings
    if (MSTracks) {
        return;
    }
    if (isGoodTruthTrack) {
        return;
    }
    if (mu.m()) {
        return;
    }
    if (truthMu.status()) {
        return;
    }
}
 
void MuonTree::postFillTreeActions() {
 
    //
    // Event Info
    //
    m_runNumber = -999;
    m_lumiBlock = -999;
    m_eventNumber = -999;
    m_mcChannelNumber = -999;
 
    //
    // Reco
    //
    m_pt.clear();
    m_eta.clear();
    m_phi.clear();
    m_e.clear();
    m_rapidity.clear();
 
    // authors and types
    m_allAuthors.clear();
    m_muonType.clear();
 
    // summary values
    m_innerSmallHits.clear();
    m_innerLargeHits.clear();
    m_innerSmallHoles.clear();
    m_innerLargeHoles.clear();
 
    // parameters
    m_msInnerMatchChi2.clear();
    m_msInnerMatchDOF.clear();
    m_msOuterMatchChi2.clear();
    m_msOuterMatchDOF.clear();
    m_CaloLRLikelihood.clear();
    m_CaloMuonIDTag.clear();
    m_EnergyLoss.clear();
 
    // quality
    m_Quality.clear();
 
    // isolation
    m_iso_ptcone20.clear();
    m_iso_topoetcon20.clear();
    m_iso_ptvarcon20.clear();
    m_iso_neflowisol20.clear();
 
    // associated TrackParticle
    m_trkp_d0.clear();
    m_trkp_z0.clear();
    m_trkp_qOverP.clear();
    m_trkp_chiSquared.clear();
    m_trkp_numberDoF.clear();
 
    // used MuonSegments
    m_nMuonSegments.clear();
    m_museg_x.clear();
    m_museg_y.clear();
    m_museg_z.clear();
    m_museg_sector.clear();
    m_museg_chamberIndex.clear();
    m_museg_technology.clear();
    m_museg_nPrecisionHits.clear();
    m_museg_nPhiLayers.clear();
    m_museg_nTrigEtaLayers.clear();
 
    //
    // Truth
    //
    // Trk::Param
    m_th_isGoodTruthTrack.clear();
    m_th_pt.clear();
    m_th_eta.clear();
    m_th_phi.clear();
 
    // Trk::TruthInfo
    m_th_truthType.clear();
    m_th_truthOrigin.clear();
 
    // Trk::TruthTrkExtrapolation
    m_th_CaloEntry_p.clear();
    m_th_MuonEntry_p.clear();
    m_th_MuonExit_p.clear();
 
    // Trk::MSHit
    m_th_nprecLayers.clear();
    m_th_nphiLayers.clear();
    m_th_ntrigEtaLayers.clear();
}
 
TTree* MuonTree::getTree() {
    return m_tree.get();
}
 
}  // namespace Muon