EgammaFSRForMuonsCollectorAlg.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/

//   EgammaFSRForMuonsCollectorAlg
//
//   Algorithm to collect photons and electrons which close in dR
//   to muons as FSR candidates
 
#include "EgammaAnalysisAlgorithms/EgammaFSRForMuonsCollectorAlg.h"
#include <FourMomUtils/xAODP4Helpers.h>
#include <xAODEgamma/Electron.h>
 
#include "xAODEgamma/ElectronxAODHelpers.h"
 
#include <SelectionHelpers/SelectionHelpers.h>
 
namespace CP
{
    EgammaFSRForMuonsCollectorAlg::EgammaFSRForMuonsCollectorAlg(const std::string &name, ISvcLocator *svcLoc)
        : EL::AnaAlgorithm(name, svcLoc)
    {
    }
 
    StatusCode EgammaFSRForMuonsCollectorAlg::initialize()
    {
        // Greet the user:
        ATH_MSG_INFO("Initialising");
 
        ATH_CHECK(m_egammaContKey.initialize(m_systematicsList));
        ATH_CHECK(m_muonContKey.initialize(m_systematicsList));
        ATH_CHECK(m_wpSelection.initialize(m_systematicsList, m_egammaContKey));
        ATH_CHECK(m_outputDec.initialize(m_systematicsList, m_egammaContKey));
        ANA_CHECK(m_systematicsList.initialize());
 
        if (!m_vetoFSR) {
            ATH_MSG_INFO("Reading container " << m_egammaContKey.getNamePattern() << " for FSR search for muons from " <<  m_muonContKey.getNamePattern() << ". Those passing " << m_wpSelection.getSelectionName() << " are also accepted.");
        }
        else {
            ATH_MSG_INFO("Reading container " << m_egammaContKey.getNamePattern() << " for FSR search for muons from " <<  m_muonContKey.getNamePattern() << ". The electrons or photons matching FSR requirements with muons will be vetoed with " << m_outputDec.getDecorName());
        }
 
        // Return gracefully:
        return StatusCode::SUCCESS;
    }
 
 
    StatusCode EgammaFSRForMuonsCollectorAlg::execute()
    {
        // Loop over systematics
        for (const auto& sys : m_systematicsList.systematicsVector()) {
 
            // Retrieve electrons or photons
            const xAOD::IParticleContainer* egammaCont = nullptr;
            ANA_CHECK(m_egammaContKey.retrieve(egammaCont, sys));
 
            // Retrieve muons
            const xAOD::MuonContainer* muonCont = nullptr;
            ANA_CHECK(m_muonContKey.retrieve(muonCont, sys));
 
            // Loop over each electron or photon and compute the combined selection
            for (const xAOD::IParticle* eg : *egammaCont) {
 
                // Read the WP selection (if configured)
                bool passesWP = m_wpSelection.getBool(*eg, sys);
 
                // Check if this particle passes FSR criteria (close to a muon)
                bool passesFSR = false;
 
                const xAOD::Electron* el = (eg->type() == xAOD::Type::Electron)
                    ? dynamic_cast<const xAOD::Electron*>(eg) : nullptr;
 
                ATH_MSG_DEBUG("Incoming eg: pt, eta, phi " << eg->pt()/1000. << ", "
                    << eg->eta() << ", " << eg->phi() << ", is electron " << (el != nullptr)
                    << ", passesWP " << passesWP);
 
                // Loop over muons and check dR
                for (const xAOD::Muon* mu : *muonCont) {
                    float dR = xAOD::P4Helpers::deltaR(*eg, *mu);
 
                    ATH_MSG_DEBUG("dR with mu: " << dR << ", pt, eta, phi "
                        << mu->pt()/1000. << ", " << mu->eta() << ", " << mu->phi());
 
                    if (dR < m_dRMax) {
                        // if electron (not photon) check track matching
                        bool elmutrackmatchOK = true; // default true for photons
                        if (el) {
                            const xAOD::TrackParticle* electron_track = el->trackParticle();
                            const xAOD::TrackParticle* elOrig_track = xAOD::EgammaHelpers::getOriginalTrackParticle(el);
                            const xAOD::TrackParticle* muon_track = mu->primaryTrackParticle();
 
                            if (electron_track && muon_track) {
                                elmutrackmatchOK =
                                    (std::abs(electron_track->theta() - muon_track->theta()) < 0.01) &&
                                    (xAOD::P4Helpers::deltaPhi(electron_track->phi(), muon_track->phi()) < 0.01);
                                ATH_MSG_DEBUG("dtheta trk " << std::abs(electron_track->theta() - muon_track->theta())
                                    << ", dphi trk " << xAOD::P4Helpers::deltaPhi(electron_track->phi(), muon_track->phi()));
                                if (elOrig_track) {
                                    ATH_MSG_DEBUG("origTrk: dtheta trk " << std::abs(elOrig_track->theta() - muon_track->theta())
                                        << ", dphi trk " << xAOD::P4Helpers::deltaPhi(elOrig_track->phi(), muon_track->phi()));
                                }
                            } else {
                                elmutrackmatchOK = false;
                            }
                            ATH_MSG_DEBUG("track match " << (elmutrackmatchOK ? "OK" : "NOT OK"));
                        }
 
                        if (elmutrackmatchOK) {
                            passesFSR = true;
                            ATH_MSG_DEBUG("FSR match found");
                            break;
                        }
                    }
                }
 
                // Compute and write the output selection
                char outputValue;
                if (!m_vetoFSR) {
                    // Normal mode: output = WP || FSR
                    outputValue = (passesWP || passesFSR) ? 1 : 0;
                } else {
                    // Veto mode: output = WP && !FSR
                    outputValue = (passesWP && !passesFSR) ? 1 : 0;
                }
 
                m_outputDec.set(*eg, outputValue, sys);
                ATH_MSG_DEBUG("Output selection: " << static_cast<int>(outputValue)
                    << " (passesWP=" << passesWP << ", passesFSR=" << passesFSR << ")");
            }
        }
 
        ATH_MSG_DEBUG("Done !");
 
        return StatusCode::SUCCESS;
    }
 
}