ChargeSelectorAlg.cxx

Go to the documentation of this file.

/*
   Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "EventSelectionAlgorithms/ChargeSelectorAlg.h"
 
namespace CP {
 
  ChargeSelectorAlg::ChargeSelectorAlg(const std::string &name, ISvcLocator *pSvcLocator)
  : EL::AnaAlgorithm(name, pSvcLocator)
  {}
 
  StatusCode ChargeSelectorAlg::initialize() {
    ANA_CHECK(m_electronsHandle.initialize(m_systematicsList, SG::AllowEmpty));
    ANA_CHECK(m_electronSelection.initialize(m_systematicsList, m_electronsHandle, SG::AllowEmpty));
    ANA_CHECK(m_muonsHandle.initialize(m_systematicsList, SG::AllowEmpty));
    ANA_CHECK(m_muonSelection.initialize(m_systematicsList, m_muonsHandle, SG::AllowEmpty));
    ANA_CHECK(m_tausHandle.initialize(m_systematicsList, SG::AllowEmpty));
    ANA_CHECK(m_tauSelection.initialize(m_systematicsList, m_tausHandle, SG::AllowEmpty));
    ANA_CHECK(m_electronsTruthHandle.initialize(m_systematicsList, SG::AllowEmpty));
    ANA_CHECK(m_electronTruthSelection.initialize(m_systematicsList, m_electronsHandle, SG::AllowEmpty));
    ANA_CHECK(m_muonsTruthHandle.initialize(m_systematicsList, SG::AllowEmpty));
    ANA_CHECK(m_muonTruthSelection.initialize(m_systematicsList, m_muonsHandle, SG::AllowEmpty));
    ANA_CHECK(m_tausTruthHandle.initialize(m_systematicsList, SG::AllowEmpty));
    ANA_CHECK(m_tauTruthSelection.initialize(m_systematicsList, m_tausHandle, SG::AllowEmpty));
    ANA_CHECK(m_eventInfoHandle.initialize(m_systematicsList));
 
    ANA_CHECK(m_preselection.initialize(m_systematicsList, m_eventInfoHandle, SG::AllowEmpty));
    ANA_CHECK(m_decoration.initialize(m_systematicsList, m_eventInfoHandle));
    ANA_CHECK(m_systematicsList.initialize());
 
    return StatusCode::SUCCESS;
  }
 
  StatusCode ChargeSelectorAlg::execute() {
    for (const auto &sys : m_systematicsList.systematicsVector()) {
      // retrieve the EventInfo
      const xAOD::EventInfo *evtInfo = nullptr;
      ANA_CHECK(m_eventInfoHandle.retrieve(evtInfo, sys));
 
      // default-decorate EventInfo
      m_decoration.setBool(*evtInfo, 0, sys);
 
      // check the preselection
      if (m_preselection && !m_preselection.getBool(*evtInfo, sys))
        continue;
 
      // retrieve the electron container
      const xAOD::ElectronContainer *electrons = nullptr;
      if (m_electronsHandle)
    ANA_CHECK(m_electronsHandle.retrieve(electrons, sys));
      // retrieve the muon container
      const xAOD::MuonContainer *muons = nullptr;
      if (m_muonsHandle)
    ANA_CHECK(m_muonsHandle.retrieve(muons, sys));
      // retrieve the tau-jet container
      const xAOD::TauJetContainer *taus = nullptr;
      if (m_tausHandle)
    ANA_CHECK(m_tausHandle.retrieve(taus, sys));
      // retrieve the truth electron container
      const xAOD::TruthParticleContainer *truthElectrons = nullptr;
      if (m_electronsTruthHandle)
    ANA_CHECK(m_electronsTruthHandle.retrieve(truthElectrons, sys));
      // retrieve the truth muon container
      const xAOD::TruthParticleContainer *truthMuons = nullptr;
      if (m_muonsTruthHandle)
    ANA_CHECK(m_muonsTruthHandle.retrieve(truthMuons, sys));
      // retrieve the truth tau container
      const xAOD::TruthParticleContainer *truthTaus = nullptr;
      if (m_tausTruthHandle)
    ANA_CHECK(m_tausTruthHandle.retrieve(truthTaus, sys));
 
      // apply the requested selection and compute the local charge
      int total_charge = 0;
      int total_leptons = 0;
      if (m_electronsHandle || m_muonsHandle || m_tausHandle) {
    if (m_electronsHandle) {
      for (const xAOD::Electron *el : *electrons) {
        if (!m_electronSelection || m_electronSelection.getBool(*el, sys)){
          total_charge += el->charge();
          total_leptons++;
        }
      }
    }
    if (m_muonsHandle) {
      for (const xAOD::Muon *mu : *muons) {
        if (!m_muonSelection || m_muonSelection.getBool(*mu, sys)){
          total_charge += mu->charge();
          total_leptons++;
        }
      }
    }
  if (m_tausHandle) {
      for (const xAOD::TauJet *tau : *taus) {
        if (!m_tauSelection || m_tauSelection.getBool(*tau, sys)){
          total_charge += tau->charge();
          total_leptons++;
        }
      }
    }
      }
      else {
    if (m_electronsTruthHandle) {
      for (const xAOD::TruthParticle *el : *truthElectrons) {
        if (!m_electronTruthSelection || m_electronTruthSelection.getBool(*el, sys)){
          total_charge += el->charge();
          total_leptons++;
        }
      }
    }
    if (m_muonsTruthHandle) {
      for (const xAOD::TruthParticle *mu : *truthMuons) {
        if (!m_muonTruthSelection || m_muonTruthSelection.getBool(*mu, sys)){
          total_charge += mu->charge();
          total_leptons++;
        }
      }
    }
  if (m_tausTruthHandle) {
      for (const xAOD::TruthParticle *tau : *truthTaus) {
        if (!m_tauTruthSelection || m_tauTruthSelection.getBool(*tau, sys)){
          total_charge += tau->charge();
          total_leptons++;
        }
      }
    }
      }
 
      // check that there are only 2 leptons
      if (total_leptons != 2 ) {
        ATH_MSG_ERROR("Exactly two leptons are required to check whether the event is OS or SS!");
        return StatusCode::FAILURE;
      }
 
      // compare to the requested mode
      bool decision = m_OSmode ? total_charge == 0 : std::abs(total_charge) == 2;
      m_decoration.setBool(*evtInfo, decision, sys);
    }
    return StatusCode::SUCCESS;
  }
} // namespace CP