TrackStatHelper.h

Go to the documentation of this file.

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

// StatBox.h
// Authors: Sven Vahsen
 
// Private utility class used by IDTrackStat to do track counting
// Since this StatBox is likely to change to without notification 
// as needed,  I would not recommend anyone else to use it
 
#ifndef INDETRECSTATISTICS_TrackStatHelper_H
#define INDETRECSTATISTICS_TrackStatHelper_H
 
#include "TrkTrack/TrackInfo.h"
#include "TrkTrackSummary/TrackSummary.h" // needed by Trk::numberOfTrackSummaryTypes
#include "TrkTrack/TrackCollection.h"
#include "AtlasHepMC/GenParticle.h"
#include "GeneratorObjects/HepMcParticleLink.h"
#include "TrkToolInterfaces/IExtendedTrackSummaryTool.h"
#include "TrkTruthData/TrackTruthCollection.h"
 
#include <vector>
#include <string>
#include <map>
#include <atomic>
 
// forward declarations:
class PixelID;
class SCT_ID;
class AtlasDetectorID;
class Track;
 
namespace InDet {
 
  enum track_types {TRACK_ALL, 
            TRACK_PRIMARY, 
            TRACK_SECONDARY, //LT 06.21
            TRACK_TRUNCATED,
            TRACK_LOWTRUTHPROB, 
            TRACK_LOWTRUTHPROB2, 
            TRACK_NOHEPMCPARTICLELINK, 
            TRACK_MATCHED,
            TRACK_MATCHED_PRIMARY, 
            TRACK_MATCHED_SECONDARY, // LT 06.21
                    TRACK_MULTMATCH,
            TRACK_MULTMATCH_PRIMARY, 
            TRACK_MULTMATCH_SECONDARY, // LT 06.21
            TRACK_ALL_SIGNAL,
            TRACK_LOWTRUTHPROB_SIGNAL, 
            TRACK_LOWTRUTHPROB2_SIGNAL, 
            TRACK_MATCHED_SIGNAL,
            N_TRACKTYPES};
 
 
 
  enum hit_types   {HIT_ALL, 
            HIT_PIXEL_ALL, 
            HIT_PIX1, 
            HIT_PIX2, 
            HIT_PIX3, 
            HIT_SCT_ALL, 
            HIT_SCT1,
            HIT_SCT2, 
            HIT_SCT3, 
            HIT_SCT4,  
            HIT_SCT5TO9, 
            HIT_TRT_ALL,
            HIT_UNKNOWN, 
            N_HITTYPES};
 
  enum eta_region  {ETA_ALL, 
            ETA_BARREL, 
            ETA_TRANSITION, 
            ETA_ENDCAP, 
            ETA_OUTSIDE,
            ETA_FORWARD,
            ETA_UNKNOWN,
            N_ETAREGIONS}; 
 
  struct cuts {
    float maxEtaBarrel;
    float maxEtaTransition;
    float maxEtaEndcap;
    float minEtaFORWARD;
    float maxEtaFORWARD;
    float fakeTrackCut;
    float fakeTrackCut2;
    float matchTrackCut;
    float maxRStartPrimary;
    float maxRStartSecondary;
    float maxZStartPrimary;
    float maxZStartSecondary;
    float minREndPrimary;
    float minREndSecondary;
    float minZEndPrimary;
    float minZEndSecondary;
    float minPt;
    cuts(){
      maxEtaBarrel    =0;
      maxEtaTransition=0;
      maxEtaEndcap    =0;
      minEtaFORWARD = 2.5;
      maxEtaFORWARD=4.2;
      fakeTrackCut=0;
      fakeTrackCut2     =0;
      matchTrackCut     =0;
      maxRStartPrimary  =  25.0;
      maxRStartSecondary= 360.0;
      maxZStartPrimary  = 200.0;
      maxZStartSecondary=2000.0;
      minREndPrimary    = 400.0;
      minREndSecondary  =1000.0; 
      minZEndPrimary    =2300.0;
      minZEndSecondary  =3200.0;
      minPt = 1000;
    }
 
 
 
  };
 
 
  class TrackStatHelper{
 
      public:
    TrackStatHelper     (const std::string&, const std::string&, bool careAboutTruth = true);
    void     SetCuts(const struct cuts&);
    void     addEvent   (const EventContext& ctx,
                   const TrackCollection *,
                   std::vector<const Trk::Track *> &, 
                   const std::vector <std::pair<HepMC::ConstGenParticlePtr,int> > &,   
                   const TrackTruthCollection *, 
                   const AtlasDetectorID * const, 
                   const PixelID *, 
                   const SCT_ID *,
                   const Trk::IExtendedTrackSummaryTool *,
                   bool,
                   const unsigned int *,
                               const unsigned int *) const;
    void     reset      ();
    void     print      (MsgStream &out) const; 
    void     printRegion1(MsgStream &out, enum eta_region) const;
    void     printRegion2(MsgStream &out, enum eta_region, float denominator) const;
    void     printSecondary      (MsgStream &out) const; 
    void     printRegionSecondary(MsgStream &out, enum eta_region, float denominator) const;
 

    bool     printTrackSummaryRegion (MsgStream &out, enum track_types, enum eta_region) const;
    void     printTrackSummaryAverage(MsgStream &out, enum track_types, enum eta_region, int summary_type) const;
    bool     PassTrackCuts(const Trk::TrackParameters *para) const;
    int      ClassifyParticle( const HepMC::ConstGenParticlePtr& particle, const double prob) const;
 
 
    static std::string getSummaryTypeHeader();

    const std::string &key() const { return m_TrackCollectionKey; }
    const std::string &Truthkey() const { return m_TrackTruthCollectionKey; }
 
  private:
 
    std::string  m_TrackCollectionKey;
    std::string  m_TrackTruthCollectionKey;  
 
    mutable std::atomic<bool>  m_author_found [Trk::TrackInfo::NumberOfTrackFitters]{}; 
    mutable std::atomic<long>  m_events {} ;
 
    template <int N_Categories, int N_Types, int N_Regions, typename T_Int=long>
    struct Counter {
       Counter() { reset(); }
       void reset() {
          for (unsigned int cat_i=0; cat_i < N_Categories; ++cat_i ) {
             for (unsigned int type_i=0; type_i < N_Types; ++type_i) {
                for (unsigned int eta_i=0; eta_i < N_Regions; ++eta_i) {
                   m_counter[cat_i][type_i][eta_i]=0;
                }
             }
          }
       }
       template <typename T_IntB>
       Counter &operator +=(const Counter<N_Categories,N_Types,N_Regions,T_IntB> &a) {
          for (unsigned int cat_i=0; cat_i < N_Categories; ++cat_i ) {
             for (unsigned int type_i=0; type_i < N_Types; ++type_i) {
                for (unsigned int eta_i=0; eta_i < N_Regions; ++eta_i) {
                   m_counter[cat_i][type_i][eta_i] += a.m_counter[cat_i][type_i][eta_i];
                }
             }
          }
          return *this;
       }
       T_Int m_counter[N_Categories][N_Types][N_Regions];
    };
 
    template <int N_Categories, int N_Types, int N_Regions, int N_SubCategories, typename T_Int=long>
    struct Counter4D {
       Counter4D() { reset(); }
       void reset() {
          for (unsigned int cat_i=0; cat_i < N_Categories; ++cat_i ) {
             for (unsigned int type_i=0; type_i < N_Types; ++type_i) {
                for (unsigned int eta_i=0; eta_i < N_Regions; ++eta_i) {
                   for (unsigned int sub_i=0; sub_i < N_SubCategories; ++sub_i) {
                      m_counter[cat_i][type_i][eta_i][sub_i]=0;
                   }
                }
             }
          }
       }
       template <typename T_IntB>
       Counter4D &operator +=(const Counter4D<N_Categories,N_Types,N_Regions,N_SubCategories,T_IntB> &a) {
          for (unsigned int cat_i=0; cat_i < N_Categories; ++cat_i ) {
             for (unsigned int type_i=0; type_i < N_Types; ++type_i) {
                for (unsigned int eta_i=0; eta_i < N_Regions; ++eta_i) {
                   for (unsigned int sub_i=0; sub_i < N_SubCategories; ++sub_i) {
                      m_counter[cat_i][type_i][eta_i][sub_i] += a.m_counter[cat_i][type_i][eta_i][sub_i];
                   }
                }
             }
          }
          return *this;
       }
       T_Int m_counter[N_Categories][N_Types][N_Regions][N_SubCategories];
    };
 
    enum ETrackCounter {kTracks_rec,        
                        kTracks_gen,        
                        kTracks_gen_signal, 
                        kNTracksCounter};
 
    using TracksCounter = Counter<kNTracksCounter,N_TRACKTYPES,N_ETAREGIONS, int>;
    using TracksCounterAtomic = Counter<kNTracksCounter,N_TRACKTYPES,N_ETAREGIONS, std::atomic<long> >;
    mutable TracksCounterAtomic m_tracks ATLAS_THREAD_SAFE;
 
    enum EHitsCounter {
       kHits_rec,     
       kHits_pri,     
       kHits_sec,     
       kNHitsCounter
    };
    using HitsCounter = Counter<kNHitsCounter,N_HITTYPES, N_ETAREGIONS, int>;
    using HitsCounterAtomic = Counter<kNHitsCounter,N_HITTYPES, N_ETAREGIONS, std::atomic<long> >;
    mutable HitsCounterAtomic m_hits ATLAS_THREAD_SAFE;
    enum ETrackSummaryCounter {
       kTrackSummarySum,     
       kNTrackSummaryOK,     
       kNTrackSummaryBAD,    
       kNTrackSummaryCounter
    };
 
    // The ETrackSummaryTypes should be synchronised with the arrays summaryTypes and
    // summaryTypeName i.e. matching order and number of elements. Of these enums only
    // two are used: kNSummaryTypes which defines the summary statistics array sizes;
    // kNumberOfPixelHits, which is used to get counts for some denominators.
    enum ETrackSummaryTypes {
        kNumberOfInnermostPixelLayerHits,
        kNumberOfPixelHits,
        kNumberOfPixelHoles,
        kNumberOfGangedPixels,
        kNumberOfSCTHits,
        kNumberOfSCTHoles,
        kNumberOfSCTDoubleHoles,
        kNumberOfTRTHits,
        kNumberOfTRTOutliers,
        kNumberOfTRTHighThresholdHits,
        kNumberOfTRTHighThresholdOutliers,
        kNumberOfOutliersOnTrack,
        kNSummaryTypes
    };
    static const Trk::SummaryType       s_summaryTypes                      [kNSummaryTypes]; 
    static const char            *const s_summaryTypeName [kNSummaryTypes]; 
 
    using TrackSummaryCounter = Counter4D<kNTrackSummaryCounter,
                                          N_TRACKTYPES,
                                          N_ETAREGIONS,
                                          kNSummaryTypes,
                                          int>;
    using TrackSummaryCounterAtomic = Counter4D<kNTrackSummaryCounter,
                                                N_TRACKTYPES,
                                                N_ETAREGIONS,
                                                kNSummaryTypes,
                                                std::atomic<long> >;
    mutable TrackSummaryCounterAtomic m_trackSummarySum ATLAS_THREAD_SAFE;
 
 
    void setSummaryStat(track_types track_i,
                        eta_region region_i,
                        const Trk::TrackSummary *summary,
                        TrackSummaryCounter &trackSummarySum) const
    {
       if (summary) {
          for (int stype=0; stype < kNSummaryTypes; stype++) {
             int value = summary->get(s_summaryTypes[stype]);
             //value is -1 if undefined
             if (value>0) {
                trackSummarySum.m_counter[kTrackSummarySum][track_i][region_i][stype] += value;
                trackSummarySum.m_counter[kNTrackSummaryOK][track_i][region_i][stype] ++;
             }
             else {
                trackSummarySum.m_counter[kNTrackSummaryBAD][track_i][region_i][stype] ++;
             }
          }
       }
    }
 
    mutable std::atomic<bool>  m_truthMissing; 
    bool  m_careAboutTruth;
    struct cuts m_cuts;
 
    mutable std::mutex m_authorMutex;
    mutable std::bitset<Trk::TrackInfo::NumberOfTrackRecoInfo>   m_recoInfo ATLAS_THREAD_SAFE;
    mutable std::bitset<Trk::TrackInfo::NumberOfTrackProperties> m_patternProperties ATLAS_THREAD_SAFE;
 
    typedef std::multimap<HepMcParticleLink,float> recoToTruthMap;
  };
 
 
 
} // close of namespace
 
#endif // INDETRECSTATISTICS_TrackStatHelper_H