dRMatchingTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef INDETPHYSVALMONITORING_DRMATCHINGTOOL_H
#define INDETPHYSVALMONITORING_DRMATCHINGTOOL_H 1

 
// STL include(s)
#include <atomic>
#include <cmath> /* std::fabs, sqrt, pow */
#include <algorithm> /* std::all_of (C++11), std::sort, std::lower_bound, std::upper_bound, std::set_intersection */
#include <iterator> /* std::back_inserter */
#include <mutex>
 
// ATLAS software include(s)
#include "AthenaBaseComps/AthAlgTool.h"
#include "AthenaKernel/SlotSpecificObj.h"
#include "CxxUtils/checker_macros.h"
#include "PATCore/IAsgSelectionTool.h"
#include "AsgTools/AsgTool.h"
 
// xAOD include(s)
#include "xAODTracking/TrackParticle.h"
#include "xAODTracking/TrackParticleContainer.h"
#include "xAODTruth/TruthParticle.h"
#include "xAODTruth/TruthParticleContainer.h"
 
// Local include(s)
#include "../src/TrackTruthSelectionTool.h"

class dRMatchingTool:
  public virtual ::IAsgSelectionTool,
  public asg::AsgTool  {
  ASG_TOOL_CLASS1(dRMatchingTool, IAsgSelectionTool);
public:
  dRMatchingTool(const std::string& name);

  virtual
  ~dRMatchingTool();

  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
  virtual const asg::AcceptInfo& getAcceptInfo( ) const override;
  virtual asg::AcceptData accept(const xAOD::IParticle* p) const override;

  // For matching single track to set of truth particles.
  virtual asg::AcceptData
  acceptLegacy(const xAOD::TrackParticle* p,
               const xAOD::TruthParticleContainer* truthParticles,
               bool (* truthSelectionTool)(const xAOD::TruthParticle*) = nullptr) const;
 
  asg::AcceptData
  accept(const xAOD::TrackParticle* p,
         const xAOD::TruthParticleContainer* truthParticles,
         bool (* truthSelectionTool)(const xAOD::TruthParticle*) = nullptr) const;
 
  // For matching single truth particle to set of tracks.
  virtual asg::AcceptData
  acceptLegacy(const xAOD::TruthParticle* p,
               const xAOD::TrackParticleContainer* trackParticles,
               bool (* trackSelectionTool)(const xAOD::TrackParticle*) = nullptr) const;
 
  asg::AcceptData
  accept(const xAOD::TruthParticle* p,
         const xAOD::TrackParticleContainer* trackParticles,
         bool (* trackSelectionTool)(const xAOD::TrackParticle*) = nullptr) const;
 
  // Accessor for the minimal dR from the latest matching of either type.
  float dRmin() const;
protected:
  // Struct for event cache
  struct CacheEntry {
    EventContext::ContextEvt_t m_evt{EventContext::INVALID_CONTEXT_EVT};
 
    // The minimal dR for latest successful matching of either type.
    float m_dRmin = 9999.;
 
    // Copy of the xAOD::TruthParticleContainer used to perform the caching. A
    // copy, rather than a pointer or reference, is necessary to check when a new
    // container is encountered (i.e. when a new event is processed).
    xAOD::TruthParticleContainer m_baseTruthContainer;
    // Copy of the xAOD::TrackParticleContainer used to perform the caching.
    xAOD::TrackParticleContainer m_baseTrackContainer;
 
    // Cached vectors of the xAOD::TruthParticles in m_baseTruthContainer, sorted
    // in ascending order accoring to their pT, eta, and phi, resp.
    std::vector< const xAOD::TruthParticle* > m_truthParticlesSortedPt;
    std::vector< const xAOD::TruthParticle* > m_truthParticlesSortedEta;
    std::vector< const xAOD::TruthParticle* > m_truthParticlesSortedPhi;
    // Cached vectors of the xAOD::TrackParticles in m_baseTrackContainer, sorted
    // in ascending order accoring to their pT, eta, and phi, resp.
    std::vector< const xAOD::TrackParticle* > m_trackParticlesSortedPt;
    std::vector< const xAOD::TrackParticle* > m_trackParticlesSortedEta;
    std::vector< const xAOD::TrackParticle* > m_trackParticlesSortedPhi;
 
    void check(EventContext::ContextEvt_t evt) {
      // Check event number and reset variables if a new event
      if (m_evt==evt) return;
 
      m_dRmin = 9999.;
      m_truthParticlesSortedPt.clear();
      m_truthParticlesSortedEta.clear();
      m_truthParticlesSortedPhi.clear();
      m_trackParticlesSortedPt.clear();
      m_trackParticlesSortedEta.clear();
      m_trackParticlesSortedPhi.clear();
      m_evt = evt;
    }
  };

  // Cache track particles.
  void checkCacheTrackParticles(const xAOD::TrackParticleContainer* trackParticles,
                                CacheEntry* ent,
                                bool (* trackSelectionTool)(const xAOD::TrackParticle*) = nullptr) const;
  // Cache truth particles.
  void checkCacheTruthParticles(const xAOD::TruthParticleContainer* truthParticles,
                                CacheEntry* ent,
                                bool (* truthSelectionTool)(const xAOD::TruthParticle*) = nullptr) const;
 
  // Clear cached track particle arrays.
  inline void
  clearTrackParticles(CacheEntry* ent) const {
    ent->m_trackParticlesSortedPt.clear();
    ent->m_trackParticlesSortedEta.clear();
    ent->m_trackParticlesSortedPhi.clear();
    return;
  }
 
  // Clear cached truth particle arrays.
  inline void
  clearTruthParticles(CacheEntry* ent) const {
    ent->m_truthParticlesSortedPt.clear();
    ent->m_truthParticlesSortedEta.clear();
    ent->m_truthParticlesSortedPhi.clear();
    return;
  }
 
  // Sort and cache all particles of type U in container into the three vectors,
  // subject to their passing the selectionTool.
  template<class T, class U>
  void sortVectors(const T* container,
                   std::vector< const U* >& vec_pt,
                   std::vector< const U* >& vec_eta,
                   std::vector< const U* >& vec_phi,
                   bool (* selectionTool)(const U*)) const;
 
  // Match the particle p by dR and/or pT to the particles in the three cached
  // vectors.
  template<class U, class V>
  bool sortedMatch(const U* p,
                   std::vector< const V* >& vec_pt,
                   std::vector< const V* >& vec_eta,
                   std::vector< const V* >& vec_phi,
                   float& dRmin) const;
private:
  // AcceptInfo object.
  asg::AcceptInfo m_accept{"dRMatching"};
  // Vector of stored cut names and descriptions.
  std::vector<std::pair<std::string, std::string> > m_cuts;
 
  // Counters.
  mutable std::atomic<ULong64_t> m_numProcessed{0}; // !< a counter of the number of tracks proccessed
  mutable std::atomic<ULong64_t> m_numPassed{0}; // !< a counter of the number of tracks that passed all cuts
  mutable std::vector<ULong64_t> m_numPassedCuts ATLAS_THREAD_SAFE; // !< tracks the number of tracks that passed each cut family. Guarded by m_mutex
  mutable std::mutex m_mutex; // !< To guard m_numPassedCuts and m_cache

  // The maximal dR-distance allowed for successful matching.
  FloatProperty m_dRmax{this, "dRmax", -1.};
  // The maximal pT-resolution allowed for successful matching.
  FloatProperty m_pTResMax{this, "pTResMax", -1.};
 
  // Event cache
  mutable SG::SlotSpecificObj<CacheEntry> m_cache ATLAS_THREAD_SAFE; // Guarded by m_mutex
};
 
#endif // > !INDETPHYSVALMONITORING_DRMATCHINGTOOL_H