AsgLeptonTrackSelectionAlg.cxx

Go to the documentation of this file.

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

 
 
 
//
// includes
//
 
#include <AsgAnalysisAlgorithms/AsgLeptonTrackSelectionAlg.h>
 
#include <xAODEgamma/Electron.h>
#include <xAODMuon/Muon.h>
#include <xAODTracking/TrackParticlexAODHelpers.h>
 
//
// method implementations
//
 
namespace CP
{
 
  StatusCode AsgLeptonTrackSelectionAlg ::
  initialize ()
  {
 
    if (m_maxD0Significance < 0 || !std::isfinite (m_maxD0Significance))
    {
      ATH_MSG_ERROR ("invalid value of maxD0Significance: " << m_maxD0Significance);
      return StatusCode::FAILURE;
    }
    if (m_maxDeltaZ0SinTheta < 0 || !std::isfinite (m_maxDeltaZ0SinTheta))
    {
      ATH_MSG_ERROR ("invalid value of maxDeltaZ0SinTheta: " << m_maxDeltaZ0SinTheta);
      return StatusCode::FAILURE;
    }
 
    m_accept.addCut ("trackRetrieval", "whether the track retrieval failed");
    if (m_maxD0Significance > 0)
      m_accept.addCut ("maxD0Significance", "maximum D0 significance cut");
    if (m_maxDeltaZ0SinTheta > 0)
      m_accept.addCut ("maxDeltaZ0SinTheta", "maximum Delta z0 sin theta cut");
    if (m_nMinPixelHits != -1 || m_nMaxPixelHits != -1)
      m_accept.addCut ("numPixelHits", "Minimum and/or maxiumum Pixel hits");
    if (m_nMinSCTHits != -1 || m_nMaxSCTHits != -1)
      m_accept.addCut ("numSCTHits", "Minimum and/or maxiumum SCT hits");
 
    ANA_CHECK (m_particlesHandle.initialize (m_systematicsList));
    ANA_CHECK (m_preselection.initialize (m_systematicsList, m_particlesHandle, SG::AllowEmpty));
    ANA_CHECK (m_selectionHandle.initialize (m_systematicsList, m_particlesHandle));
    ANA_CHECK (m_systematicsList.initialize());
 
    ANA_CHECK (m_eventInfoKey.initialize());
    ANA_CHECK (m_primaryVerticesKey.initialize());
 
    if (!m_nameSvc.empty())
    {
      ANA_CHECK (m_nameSvc.retrieve());
      ANA_CHECK (m_nameSvc->addAcceptInfo (m_particlesHandle.getNamePattern(), m_selectionHandle.getLabel(),
          m_accept));
    }
 
    return StatusCode::SUCCESS;
  }
 
 
 
  StatusCode AsgLeptonTrackSelectionAlg ::
  execute (const EventContext &ctx) const
  {
    SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey, ctx);
    SG::ReadHandle<xAOD::VertexContainer> vertices(m_primaryVerticesKey, ctx);
    if (!vertices.isValid())
      {
        ANA_MSG_ERROR ("Cannot retrieve primary vertex container " << m_primaryVerticesKey.key());
        return StatusCode::FAILURE;
      }
    const xAOD::Vertex *primaryVertex {nullptr};
 
    for (const xAOD::Vertex *vertex : *vertices)
    {
      if (vertex->vertexType() == xAOD::VxType::PriVtx)
      {
        // The default "PrimaryVertex" container is ordered in
        // sum-pt, and the tracking group recommends to pick the one
        // with the maximum sum-pt, so this will do the right thing.
        // If the user needs a different primary vertex, they need to
        // provide a reordered primary vertex container and point
        // this algorithm to it.  Currently there is no central
        // algorithm to do that, so users will have to write their
        // own (15 Aug 18).
        primaryVertex = vertex;
        break;
      }
    }
 
    for (const auto& sys : m_systematicsList.systematicsVector())
    {
      const xAOD::IParticleContainer *particles = nullptr;
      ANA_CHECK (m_particlesHandle.retrieve (particles, sys, ctx));
      for (const xAOD::IParticle *particle : *particles)
      {
        asg::AcceptData acceptData (&m_accept);
        float d0sig = -999;
        float deltaZ0SinTheta = -999;
 
        if (m_preselection.getBool (*particle, sys))
        {
          std::size_t cutIndex {0};
 
          const xAOD::TrackParticle *track {nullptr};
          if (const xAOD::Muon *muon = dynamic_cast<const xAOD::Muon *>(particle)){
            track = muon->trackParticle(xAOD::Muon::TrackParticleType::Primary);
          } else if (const xAOD::Electron *electron = dynamic_cast<const xAOD::Electron *>(particle)){
            track = electron->trackParticle();
          } else {
            ANA_MSG_ERROR ("failed to cast input to electron or muon");
            return StatusCode::FAILURE;
          }
 
          acceptData.setCutResult (cutIndex ++, track != nullptr);
 
          if (track != nullptr) {
            if (m_maxD0Significance > 0) {
              try {
                d0sig = xAOD::TrackingHelpers::d0significance(track, eventInfo->beamPosSigmaX(), eventInfo->beamPosSigmaY(), eventInfo->beamPosSigmaXY());
                acceptData.setCutResult (cutIndex ++, fabs( d0sig ) < m_maxD0Significance);
              } catch (const std::runtime_error &) {
                acceptData.setCutResult (cutIndex ++, false);
              }
            }
 
            const double vertex_z = primaryVertex ? primaryVertex->z() : 0;
            deltaZ0SinTheta = (track->z0() + track->vz() - vertex_z) * sin (particle->p4().Theta());
            if (m_maxDeltaZ0SinTheta > 0) acceptData.setCutResult (cutIndex ++, fabs (deltaZ0SinTheta) < m_maxDeltaZ0SinTheta);
 
            if (m_nMinPixelHits != -1 || m_nMaxPixelHits != -1) {
              uint8_t nPixelHits = 0;
              bool accept = track->summaryValue(nPixelHits, xAOD::numberOfPixelHits);
              if(accept && m_nMinPixelHits != -1) {
                accept = nPixelHits >= m_nMinPixelHits;
              }
              if(accept && m_nMaxPixelHits != -1) {
                accept = nPixelHits <= m_nMaxPixelHits;
              }
              acceptData.setCutResult (cutIndex++, accept);
            }
            if (m_nMinSCTHits != -1 || m_nMaxSCTHits != -1) {
              uint8_t nSCTHits = 0;
              bool accept = track->summaryValue(nSCTHits, xAOD::numberOfSCTHits);
              if(accept && m_nMinSCTHits != -1) {
                accept = nSCTHits >= m_nMinSCTHits;
              }
              if(accept && m_nMaxSCTHits != -1) {
                accept = nSCTHits <= m_nMaxSCTHits;
              }
              acceptData.setCutResult (cutIndex++, accept);
            }
          }
        }
 
        m_selectionHandle.setBits(*particle, selectionFromAccept (acceptData), sys);
      }
    }
 
    return StatusCode::SUCCESS;
  }
}