ActsTrk::TrackParticleTruthDecorationAlg Class Reference

#include <TrackParticleTruthDecorationAlg.h>

Inheritance diagram for ActsTrk::TrackParticleTruthDecorationAlg:

Collaboration diagram for ActsTrk::TrackParticleTruthDecorationAlg:

Public Member Functions
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
	Get filter decision:
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
	Set filter decision:
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Types
using	EventStat = EventStatBase<TrackFindingValidationDetailedStat>

Protected Member Functions
const TruthParticleHitCounts &	getTruthParticleHitCounts (const EventContext &ctx) const
std::size_t	perEtaSize () const
std::size_t	perPdgIdSize () const
TruthMatchResult	analyseTrackTruth (const TruthParticleHitCounts &truth_particle_hit_counts, const HitCountsPerTrack &track_hit_counts, EventStat &event_stat) const
void	postProcessEventStat (const TruthParticleHitCounts &truth_particle_hit_counts, std::size_t n_tracks, EventStat &event_stat) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
ToolHandle< IAthSelectionTool >	m_truthSelectionTool {this, "TruthSelectionTool","AthTruthSelectionTool", "Truth selection tool (for efficiencies and resolutions)"}

Private Types
enum	FloatDecorations { kMatchingProbability , kHitPurity , kHitEfficiency , kNFloatDecorators }
enum	IntDecorations { kTruthType , kTruthOrigin , kNIntDecorators }
enum	ECounter {   NTracksTotal , NTruthWithCountsTotal , MissingTruthParticleHitCounts , NoAssociatedTruthParticle ,   NoSelectedTruthParticle , TruthParticleNoNoiseMismatch , kNCounter }
enum	ECategorisedCounter {   kNTotalParticles , kNParticleWithAssociatedTrack , kNParticleWithMultipleAssociatedTracks , kNTotalTracks ,   kNCategorisedCounter }
enum	ECategorisedStat { kHitEfficiency , kHitPurity , kMatchProbability , kNCategorisedStat }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	checkBinOrder (const std::vector< float > &bin_edges, const std::string &bin_label) const
	check that bins are in increasing order.
std::size_t	getPtEtaStatCategory (float pt, float eta) const
	Return the category based on the provided eta value.
std::size_t	getPtPdgIdStatCategory (float pt, int pdg_id) const
	Return the category based on the PDG ID.
void	initStatTables ()
void	printStatTables () const
void	printCategories (const std::vector< std::string > &pt_category_labels, const std::vector< std::string > &eta_category_labels, std::vector< std::string > &counter_labels, std::vector< std::array< ActsUtils::Stat, kNCategorisedStat > > &stat_per_category, std::vector< std::array< std::size_t, kNCategorisedCounter > > &counts_per_category, const std::string &top_left_label, bool print_sub_categories) const
void	printData2D (const std::vector< std::string > &row_category_labels, const std::vector< std::string > &col_category_labels, const std::string &top_left_label, std::vector< std::array< ActsUtils::Stat, kNCategorisedStat > > &stat_per_category, std::vector< std::array< std::size_t, kNCategorisedCounter > > &counts_per_category, bool rotate) const
StatusCode	checkMatchWeights ()
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static double	weightedCountSum (const ActsTrk::HitCounterArray &counts, const std::vector< float > &weights)
static double	noiseCorrection (const ActsTrk::HitCounterArray &noise_counts, const std::vector< float > &weights)

Private Attributes
SG::ReadHandleKeyArray< TrackToTruthParticleAssociation >	m_trackToTruth
	Hit-based truth matching from the Acts::Track -> truth particle.
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trkParticleName {this,"TrackParticleContainerName", "InDetTrackParticles",""}
SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_derivateTruthKey {this, "DerivateTruthKey", ""}
	Muon tracks are matched to the truth particle container insert a bypass to bend the link to the desired truth particle container.
SG::WriteDecorHandleKeyArray< xAOD::TrackParticleContainer >	m_floatDecor {this, "FloatDecorators", {}}
SG::WriteDecorHandleKeyArray< xAOD::TrackParticleContainer >	m_intDecor {this, "IntDecorators", {}}
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_truthClassDecor {this, "TruthClassification", m_trkParticleName, "truthClassification"}
ToolHandle< IMCTruthClassifier >	m_truthClassifier {this, "MCTruthClassifier", "MCTruthClassifier/MCTruthClassifier"}
SG::WriteDecorHandleKey< xAOD::TrackParticleContainer >	m_linkDecor {this, "LinkDecoration", m_trkParticleName, "truthParticleLink"}
SG::ReadHandleKey< TruthParticleHitCounts >	m_truthHitCounts {this, "TruthParticleHitCounts","", "Map from truth particle to hit counts." }
Gaudi::Property< std::vector< float > >	m_weightsForProb
Gaudi::Property< std::vector< float > >	m_weights
Gaudi::Property< bool >	m_truthLinkedFakeRate
Gaudi::Property< std::vector< float > >	m_statEtaBins {this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these eta bins."}
Gaudi::Property< std::vector< float > >	m_statPtBins {this, "StatisticPtBins", {1.e3,2.5e3,10e3, 100e3}, "Gather statistics separately for these pt bins."}
Gaudi::Property< bool >	m_pdgIdCategorisation {this, "PdgIdCategorisation", false, "Categorise by pdg id."}
Gaudi::Property< bool >	m_showRawCounts {this, "ShowRawCounts", false, "Show all counters."}
Gaudi::Property< bool >	m_printDetails {this, "ShowDetailedTables", false, "Show more details; stat. uncert., RMS, entries"}
Gaudi::Property< bool >	m_computeTrackRecoEfficiency {this, "ComputeTrackRecoEfficiency", true, "Compute and print track reconstruction efficiency."}
DebugCounter< TrackFindingValidationDebugHists >	m_debugCounter
bool	m_useAbsEtaForStat = false
std::mutex m_statMutex	ATLAS_THREAD_SAFE
std::array< std::size_t, kNCounter > m_counter	ATLAS_THREAD_SAFE {}
std::vector< int > m_pdgId	ATLAS_THREAD_SAFE
BaseStat< TrackFindingValidationDetailedStat > m_detailedStat	ATLAS_THREAD_SAFE
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static constexpr unsigned int	s_NMeasurementTypes = Acts::toUnderlying(xAOD::UncalibMeasType::nTypes)
static constexpr int	s_pdgIdMax = 1000000000

Detailed Description

Definition at line 26 of file TrackParticleTruthDecorationAlg.h.

Member Typedef Documentation

EventStat

using ActsTrk::TrackTruthMatchingBaseAlg::EventStat = EventStatBase<TrackFindingValidationDetailedStat>

protectedinherited

Definition at line 124 of file TrackTruthMatchingBaseAlg.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

Member Enumeration Documentation

ECategorisedCounter

enum ActsTrk::TrackTruthMatchingBaseAlg::ECategorisedCounter

privateinherited

Enumerator
kNTotalParticles
kNParticleWithAssociatedTrack
kNParticleWithMultipleAssociatedTracks
kNTotalTracks
kNCategorisedCounter

Definition at line 221 of file TrackTruthMatchingBaseAlg.h.

                              {
        kNTotalParticles,
        kNParticleWithAssociatedTrack,
        kNParticleWithMultipleAssociatedTracks,
        kNTotalTracks,
        kNCategorisedCounter
     };

ECategorisedStat

enum ActsTrk::TrackTruthMatchingBaseAlg::ECategorisedStat

privateinherited

Enumerator
kHitEfficiency
kHitPurity
kMatchProbability
kNCategorisedStat

Definition at line 228 of file TrackTruthMatchingBaseAlg.h.

                           {
        kHitEfficiency,
        kHitPurity,
        kMatchProbability,
        kNCategorisedStat
     };

ECounter

enum ActsTrk::TrackTruthMatchingBaseAlg::ECounter

privateinherited

Enumerator
NTracksTotal
NTruthWithCountsTotal
MissingTruthParticleHitCounts
NoAssociatedTruthParticle
NoSelectedTruthParticle
TruthParticleNoNoiseMismatch
kNCounter

Definition at line 211 of file TrackTruthMatchingBaseAlg.h.

                   {
        NTracksTotal,
        NTruthWithCountsTotal,
        MissingTruthParticleHitCounts,
        NoAssociatedTruthParticle,
        NoSelectedTruthParticle,
        TruthParticleNoNoiseMismatch,
        kNCounter
     };

FloatDecorations

enum ActsTrk::TrackParticleTruthDecorationAlg::FloatDecorations

private

Enumerator
kMatchingProbability
kHitPurity
kHitEfficiency
kNFloatDecorators

Definition at line 47 of file TrackParticleTruthDecorationAlg.h.

{ kMatchingProbability, kHitPurity, kHitEfficiency, kNFloatDecorators};

IntDecorations

enum ActsTrk::TrackParticleTruthDecorationAlg::IntDecorations

private

Enumerator
kTruthType
kTruthOrigin
kNIntDecorators

Definition at line 50 of file TrackParticleTruthDecorationAlg.h.

{kTruthType, kTruthOrigin, kNIntDecorators};

Member Function Documentation

analyseTrackTruth()

TrackTruthMatchingBaseAlg::TruthMatchResult ActsTrk::TrackTruthMatchingBaseAlg::analyseTrackTruth ( const TruthParticleHitCounts & truth_particle_hit_counts, const HitCountsPerTrack & track_hit_counts, TrackTruthMatchingBaseAlg::EventStat & event_stat ) const

protectedinherited

Parameters

return

tuple containing pointer to best matching truth particle, matching probability, hit purity and hit efficiency.

Definition at line 198 of file TrackTruthMatchingBaseAlg.cxx.

  {
       TruthMatchResult ret{};
       auto best_match_i{Acts::filledArray<unsigned, 2>(std::numeric_limits<unsigned>::max())};
       auto best_match_i_nonoise{Acts::filledArray<unsigned, 2>(std::numeric_limits<unsigned>::max())};
 
       std::array<float,2> best_match_prob{};
       std::array<float,2> best_match_prob_nonoise{};
 
       const HitCounterArray &total_counts = track_hit_counts.totalCounts();
       const HitCounterArray &noise_counts = track_hit_counts.noiseCounts();
 
       double total_sum=weightedCountSum(total_counts, m_weights.value() );
       double total_sum_for_prob=weightedCountSum(total_counts, m_weightsForProb.value() );
       // measurements without truth particle keep their full weight unless only truth-linked measurements count
       double noise_sum= m_truthLinkedFakeRate.value() ? noiseCorrection(noise_counts, m_weightsForProb.value() ) : 0.;
       double total_sum_for_prob_nonoise=total_sum_for_prob;
       total_sum_for_prob += noise_sum;
 
       if (total_sum_for_prob>0.) {
         // compute total hit count per truth particle and remember the highest and second highest
         // count per truth particle.
         // The match probability is then max_counter / sum_{i in associated truth particles} counts_i
         for (const auto&[truth_i,
                 hit_counts_for_associated_truth_particle] : Acts::enumerate(track_hit_counts.countsPerTruthParticle())) {
            double truth_sum_for_prob=weightedCountSum(hit_counts_for_associated_truth_particle.second, m_weightsForProb.value() );
            float match_prob_nonoise = truth_sum_for_prob /total_sum_for_prob_nonoise;
            float match_prob = truth_sum_for_prob /total_sum_for_prob;
            if (match_prob>1 || match_prob<0.) {
               THROW_EXCEPTION("Negative or too large truth match \"probability\". This should not happen."
                             << " Track hits: " << dumpCounts(total_counts)
                             << " noise hits of those: " << dumpCounts(noise_counts)
                             << " truth hits: " << dumpCounts(hit_counts_for_associated_truth_particle.second));
            }          // remember the highest and next-to-highest hit count per truth particle
            if (match_prob> best_match_prob[1]) {
               int dest_i=match_prob < best_match_prob[0];
               best_match_i[1]=best_match_i[0];
               best_match_prob[1]=best_match_prob[0];
               best_match_prob[dest_i]=match_prob;
               best_match_i[dest_i]=truth_i;
            }
            if (match_prob_nonoise>best_match_prob_nonoise[1]) {
               int dest_i=match_prob_nonoise<best_match_prob_nonoise[0];
               best_match_i_nonoise[1]=best_match_i_nonoise[0];
               best_match_prob_nonoise[1]=best_match_prob_nonoise[0];
               best_match_prob_nonoise[dest_i]=match_prob_nonoise;
               best_match_i_nonoise[dest_i]=truth_i;
            }
         }
       }
 
       // as in the legacy matching, the measurements without truth particle form one pseudo particle which can be the
       // best match, unless only truth-linked measurements count
       float noise_match_prob = 0.f;
       if (!m_truthLinkedFakeRate.value() && total_sum_for_prob>0.) {
          noise_match_prob = weightedCountSum(noise_counts, m_weightsForProb.value() ) / total_sum_for_prob;
       }
       const bool noise_is_best_match = noise_match_prob > best_match_prob[0];
 
       if (best_match_i_nonoise[0] != best_match_i[0]) {
          ++event_stat.m_nTruthParticleNonoiseMismatches;
       }
       if (   !noise_is_best_match
           && best_match_i[0] < track_hit_counts.countsPerTruthParticle().size()
           && track_hit_counts.countsPerTruthParticle()[ best_match_i[0] ].first) {
          ret.m_truthParticle  = track_hit_counts.countsPerTruthParticle()[ best_match_i[0] ].first;
          ret.m_matchProbability = best_match_prob[0];
 
          const xAOD::TruthParticle *best_match = ret.m_truthParticle;
          const IAthSelectionTool::CutResult accept = m_truthSelectionTool->accept(best_match);
          event_stat.m_truthSelectionCuts.add( event_stat.m_nTruthCuts - accept.missingCuts() );
          if (accept) {
 
             double common_truth_sum=weightedCountSum(track_hit_counts.countsPerTruthParticle()[ best_match_i[0] ].second, m_weights.value() );
 
             float hit_efficiency = 0.;
             std::unordered_map<const xAOD::TruthParticle *,HitCounterArray>::const_iterator
                best_truth_particle_counts_iter  = truth_particle_hit_counts.find( best_match );
 
             if (best_truth_particle_counts_iter != truth_particle_hit_counts.end()) {
                double truth_sum=weightedCountSum(best_truth_particle_counts_iter->second, m_weights.value() );
                // in principle truth_measuremnts should always be larger than 0
                hit_efficiency = truth_sum > 0u ? (common_truth_sum/truth_sum) : 0.;
             }
             else {
                // this can happen if the total number of hits are below threshold for
                // accepting a truth particle
                ++event_stat.m_nTruthParticleWithoutAssociatedCounts;
                m_debugCounter.fillMeasForTruthParticleWithoutCount(total_sum);
             }
 
             // in principle a track matched to a truth particle should always have n_total > 0
             // but the hits could be filtered out.
             if (total_sum>0.) {
                float hit_purity = common_truth_sum / total_sum;
                ret.m_hitPurity = hit_purity;
                ret.m_hitEfficiency = hit_efficiency;
                m_debugCounter.fillTruthMatchProb(best_match_prob);
 
                if constexpr(TrackFindingValidationDetailedStat) {
                   float best_match_pt = best_match->pt();
                   std::size_t eta_category_i    = getPtEtaStatCategory(best_match_pt, best_match->eta());
                   std::size_t pdg_id_category_i = getPtPdgIdStatCategory(best_match_pt, best_match->pdg_id());
                   event_stat.fill( eta_category_i, pdg_id_category_i, hit_efficiency, hit_purity, best_match_prob[0], best_match );
                }
             }
          }
          else {
             ++event_stat.m_nTracksWithoutSelectedTruthParticle;
          }
       } else {
          // no eta, pdg_id for tracks without associated truth particle
          // could use eta of track but not available to the algorithm
 
          ++event_stat.m_nTracksWithoutAssociatedTruthParticle;
 
          if (noise_is_best_match) {
             ret.m_matchProbability = noise_match_prob;
          }
       }
       return ret;
    }

checkBinOrder()

void ActsTrk::TrackTruthMatchingBaseAlg::checkBinOrder ( const std::vector< float > & bin_edges, const std::string & bin_label ) const

privateinherited

check that bins are in increasing order.

will cause a FATAL error if bins are not in increasing order.

Definition at line 397 of file TrackTruthMatchingBaseAlg.cxx.

                                                                                                                    {
    if (!bin_edges.empty())
    {
      float last_eta = bin_edges[0];
      for (float eta : bin_edges)
      {
        if (eta < last_eta)
        {
          ATH_MSG_FATAL(bin_label + " bins for statistics counter not in ascending order.");
        }
        last_eta = eta;
      }
    }
  }

checkMatchWeights()

StatusCode ActsTrk::TrackTruthMatchingBaseAlg::checkMatchWeights ( )

privateinherited

Definition at line 780 of file TrackTruthMatchingBaseAlg.cxx.

                                                          {
     if (m_weights.size() != s_NMeasurementTypes) {
        ATH_MSG_FATAL( "There must be exactly one weight per measurement type. But got "
                       << m_weights.size() << " != " << s_NMeasurementTypes);
        return StatusCode::FAILURE;
     }
     if (m_weightsForProb.size() != s_NMeasurementTypes) {
        ATH_MSG_FATAL( "There must be exactly one weight for computing the matching probability per measurement type. But got "
                       << m_weightsForProb.size() << " != " << s_NMeasurementTypes);
        return StatusCode::FAILURE;
     }
     for (unsigned int type_i=0; type_i<s_NMeasurementTypes; ++type_i) {
        if (m_weightsForProb[type_i]<0. || m_weights[type_i]<0. || (m_weights[type_i]>0) != (m_weightsForProb[type_i]>0.)) {
           ATH_MSG_FATAL( "Invalid weights (should be positive) or inconsistency of weights which are zero (match prob. weights, weights):"
                          << m_weightsForProb[type_i] << " vs " << m_weights[type_i]);
           return StatusCode::FAILURE;
        }
     }
     return StatusCode::SUCCESS;
  }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode ActsTrk::TrackParticleTruthDecorationAlg::execute ( const EventContext & ctx ) const

overridevirtual

Muon tracks are linked to the MuonTruthParticle container instead of the TruthParticles insert bend the link to the MuonTruthParticle if available

Definition at line 47 of file TrackParticleTruthDecorationAlg.cxx.

  {
    const TruthParticleHitCounts &truth_particle_hit_counts = getTruthParticleHitCounts(ctx);
    // @TODO or use simply a vector ?
    std::unordered_map<const ActsTrk::TrackContainerBase *, const ActsTrk::TrackToTruthParticleAssociation *> truth_association_map;
    truth_association_map.reserve( m_trackToTruth.size());
    for (const SG::ReadHandleKey<TrackToTruthParticleAssociation> &key : m_trackToTruth) {
      const TrackToTruthParticleAssociation* assocMap{};
      ATH_CHECK(SG::get(assocMap, key, ctx));
      truth_association_map.insert(std::make_pair( assocMap->sourceContainer(), assocMap));
    }
 
    const xAOD::TrackParticleContainer* track_particle_handle{};
    ATH_CHECK(SG::get(track_particle_handle, m_trkParticleName, ctx));
 
   const xAOD::TruthParticleContainer* derivateTruth{};
   ATH_CHECK(SG::get(derivateTruth, m_derivateTruthKey, ctx));
   std::vector<std::pair<const xAOD::TruthParticle*, const xAOD::TruthParticle*>> derivateTruthMap{};
   if (derivateTruth) {
      for (const xAOD::TruthParticle* linkMeTo : *derivateTruth) {
            const xAOD::TruthParticle* parentP = xAOD::TruthHelpers::getTruthParticle(*linkMeTo);
            if (!parentP){
               ATH_MSG_ERROR("Link to the original truth particle contianer not present "
                           <<m_derivateTruthKey.fullKey());
               return StatusCode::FAILURE;
            }
            derivateTruthMap.emplace_back(parentP, linkMeTo);
      }
   }
  
    auto truthParticleToLink =[&derivateTruthMap](const xAOD::TruthParticle* part) {
         if (!part) {
            return part;
         }
         if (auto itr = std::ranges::find_if(derivateTruthMap, [part](const auto& truthPair){
            return truthPair.first == part;
         }); itr != derivateTruthMap.end()) {
            return itr->second;
         }
         return part;
    };
 
    std::vector<FloatDecorator_t> float_decor = xAOD::createDecorators(m_floatDecor, ctx, 0.f);
    std::vector<IntDecorator_t> int_decor = xAOD::createDecorators(m_intDecor, ctx, 0);
    UintDecorator_t truthClass_decor{m_truthClassDecor, ctx};
    LinkDecorator_t link_decor{m_linkDecor, ctx};
 
    EventStat event_stat(*m_truthSelectionTool,
                         perEtaSize(),
                         perPdgIdSize(),
                         track_particle_handle->size());
 
    std::pair<const ActsTrk::TrackContainerBase *, const ActsTrk::TrackToTruthParticleAssociation *>
             the_track_truth_association{ nullptr, nullptr};
    for(const xAOD::TrackParticle *track_particle : *track_particle_handle) {
       TruthMatchResult truth_match{} ;
       MCTruthPartClassifier::ParticleType type = MCTruthPartClassifier::Unknown;
       MCTruthPartClassifier::ParticleOrigin origin = MCTruthPartClassifier::NonDefined;
       unsigned int classification = 0;
       auto optional_track = getActsTrack(*track_particle);
 
       if (!optional_track.has_value()) {
         continue;
       }
      const ActsTrk::TrackContainerBase *track_container = &(optional_track->container());
      if (track_container != the_track_truth_association.first) {
         auto truth_association_map_iter = truth_association_map.find( track_container );
         if (truth_association_map_iter != truth_association_map.end()) {
            the_track_truth_association = *truth_association_map_iter;
         } else {
            ATH_MSG_WARNING("No truth association available");
            continue;
         }
      }
      truth_match = analyseTrackTruth(truth_particle_hit_counts,
                                      (*the_track_truth_association.second).at(optional_track->index()),
                                     event_stat);
         
      // the match probability is also meaningful without a matching truth particle (legacy truth matching)
      float_decor[kMatchingProbability](*track_particle) = truth_match.m_matchProbability;
      float_decor[kHitPurity](*track_particle) = truth_match.m_hitPurity;
      float_decor[kHitEfficiency](*track_particle) = truth_match.m_hitEfficiency;
 
      const xAOD::TruthParticle* truth_particle = truthParticleToLink(truth_match.m_truthParticle);
      if (!truth_particle) {
         continue;
      }
      const auto* container = static_cast<const xAOD::TruthParticleContainer*>(truth_particle->container());
 
      link_decor(*track_particle) = ElementLink<xAOD::TruthParticleContainer>{*container, truth_particle->index(), ctx};
 
      auto truthClass = m_truthClassifier->particleTruthClassifier(truth_particle);
      type = truthClass.first;
      origin = truthClass.second;
      classification = std::get<0>(MCTruthPartClassifier::defOrigOfParticle(truth_particle));
      int_decor[kTruthType](*track_particle) = type;
      int_decor[kTruthOrigin](*track_particle) = origin;
      truthClass_decor(*track_particle) = classification;
    }
    postProcessEventStat(truth_particle_hit_counts,
                         track_particle_handle->size(),
                         event_stat);
    return StatusCode::SUCCESS;
  }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 89 of file AthCommonAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode ActsTrk::TrackTruthMatchingBaseAlg::finalize ( )

overridevirtualinherited

Definition at line 162 of file TrackTruthMatchingBaseAlg.cxx.

  {
     if (msgLvl(MSG::INFO)) {
        if constexpr(TrackFindingValidationDebugHists) {
           m_debugCounter.dumpStatistics(msg());
        }
        msg(MSG::INFO) << "Truth selection cuts: " << std::endl;
        unsigned int cut_i=0;
        std::size_t total = std::accumulate ( m_detailedStat.m_truthSelectionCuts.m_histogram.begin(),
                                              m_detailedStat.m_truthSelectionCuts.m_histogram.end(), 0u);
        msg() << std::setw(3) << "" << " " << std::setw(20) << total << " total" << std::endl;
        if (m_detailedStat.m_truthSelectionCuts.m_histogram.at(cut_i) > 0) {
           msg() << std::setw(3) << "" << " "
                 << std::setw(20) << (total - m_detailedStat.m_truthSelectionCuts.m_histogram.at(cut_i))
                 << " underflow" << std::endl;
        }
        total -= m_detailedStat.m_truthSelectionCuts.m_histogram.at(cut_i++);
        for (const std::string &name : m_truthSelectionTool->names()) {
           total -= m_detailedStat.m_truthSelectionCuts.m_histogram.at(cut_i);
           msg() << std::setw(3) << cut_i << " " << std::setw(20) << total  << " " << name << std::endl;
           ++cut_i;
        }
        total -= m_detailedStat.m_truthSelectionCuts.m_histogram.at(cut_i);
        if (total>0) {
           msg() << std::setw(3) << "" << " " << std::setw(20) << total << " overflow" << std::endl;
        }
        if (msgLvl(MSG::DEBUG)) {
           msg() << m_detailedStat.m_truthSelectionCuts.histogramToString();
        }
        msg() << endmsg;
     }
     printStatTables();
     return StatusCode::SUCCESS;
  }

getPtEtaStatCategory()

std::size_t ActsTrk::TrackTruthMatchingBaseAlg::getPtEtaStatCategory ( float pt, float eta ) const

inlineprivateinherited

Return the category based on the provided eta value.

Parameters

pt	the pt of the truth particle
eta	the eta of the truth particle

Returns

a bin assigned to the give eta value

Definition at line 362 of file TrackTruthMatchingBaseAlg.cxx.

  {
     std::vector<float>::const_iterator pt_bin_iter = std::upper_bound(m_statPtBins.begin(),
                                                                       m_statPtBins.end(),
                                                                       pt);
     std::vector<float>::const_iterator eta_bin_iter = std::upper_bound(m_statEtaBins.begin(),
                                                                        m_statEtaBins.end(),
                                                                        m_useAbsEtaForStat ? std::abs(eta) : eta);
     return   (m_statEtaBins.size()+2u) * static_cast<std::size_t>(pt_bin_iter - m_statPtBins.begin())
            + static_cast<std::size_t>(eta_bin_iter - m_statEtaBins.begin());
  }

getPtPdgIdStatCategory()

std::size_t ActsTrk::TrackTruthMatchingBaseAlg::getPtPdgIdStatCategory ( float pt, int pdg_id ) const

privateinherited

Return the category based on the PDG ID.

Parameters

pt	the pt of the truth particle
pdg_id	the PDG ID

Returns

0 or a slot associated to a single PDG ID (absolut value)

Definition at line 373 of file TrackTruthMatchingBaseAlg.cxx.

                                                                                        {
     std::vector<float>::const_iterator pt_bin_iter = std::upper_bound(m_statPtBins.begin(),
                                                                       m_statPtBins.end(),
                                                                       pt);
     int abs_pdg_id = std::min(std::abs(pdg_id), s_pdgIdMax);
     std::vector< int >::const_iterator iter = std::find(m_pdgId.begin(), m_pdgId.end(), abs_pdg_id);
     if (iter == m_pdgId.end()){
        if (m_pdgId.size() < m_pdgId.capacity()) {
           std::lock_guard<std::mutex> lock(m_statMutex); // @TODO pdg id list specific mutex ?
           // make sure that the pdg id still does not exist.
           iter = std::find(m_pdgId.begin(), m_pdgId.end(), abs_pdg_id);
           if (iter == m_pdgId.end()){
              m_pdgId.push_back(abs_pdg_id);
              iter = m_pdgId.end()-1;
           }
        }
        else {
           iter=m_pdgId.begin();
        }
     }
     return   (m_pdgId.capacity()) * static_cast<std::size_t>(pt_bin_iter - m_statPtBins.begin())
            + (iter - m_pdgId.begin());
  }

getTruthParticleHitCounts()

const TruthParticleHitCounts & ActsTrk::TrackTruthMatchingBaseAlg::getTruthParticleHitCounts ( const EventContext & ctx ) const

inlineprotectedinherited

Definition at line 58 of file TrackTruthMatchingBaseAlg.h.

                                                                                            {
        const TruthParticleHitCounts* truth_particle_hit_counts_handle{};
       if (!SG::get(truth_particle_hit_counts_handle, m_truthHitCounts, ctx).isSuccess()) {
           ATH_MSG_ERROR("No truth particle hit count map for key " << m_truthHitCounts.key() );
           throw std::runtime_error("Failed to get truth particle hit count map");
        }
        return *truth_particle_hit_counts_handle;
     }

initialize()

StatusCode ActsTrk::TrackParticleTruthDecorationAlg::initialize ( )

overridevirtual

Reimplemented from ActsTrk::TrackTruthMatchingBaseAlg.

Definition at line 25 of file TrackParticleTruthDecorationAlg.cxx.

                                                         {
     ATH_CHECK(TrackTruthMatchingBaseAlg::initialize());
     ATH_CHECK( m_trackToTruth.initialize() );
     ATH_CHECK( m_trkParticleName.initialize() );
 
     m_floatDecor.emplace_back(m_trkParticleName, "truthMatchProbability");
     m_floatDecor.emplace_back(m_trkParticleName, "truthHitPurity");
     m_floatDecor.emplace_back(m_trkParticleName, "truthHitEfficiency");
     ATH_CHECK(m_floatDecor.initialize());
    
     m_intDecor.emplace_back(m_trkParticleName, "truthType");
     m_intDecor.emplace_back(m_trkParticleName, "truthOrigin");
     ATH_CHECK(m_intDecor.initialize());
     ATH_CHECK(m_truthClassDecor.initialize());
     ATH_CHECK(m_linkDecor.initialize());
     ATH_CHECK(m_derivateTruthKey.initialize(!m_derivateTruthKey.empty()));
 
     ATH_CHECK(m_truthClassifier.retrieve());
     return StatusCode::SUCCESS;
  }

initStatTables()

void ActsTrk::TrackTruthMatchingBaseAlg::initStatTables ( )

privateinherited

Definition at line 411 of file TrackTruthMatchingBaseAlg.cxx.

  {
    if (!m_statEtaBins.empty())
    {
      m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
      checkBinOrder(m_statEtaBins.value(),"Eta");
    }
    checkBinOrder(m_statPtBins.value(),"Pt");
 
 
    unsigned int max_pdg_id_slots=( m_pdgIdCategorisation.value() ? 20 : 1 );
 
    // last element in statPerEta and counterPerEta will be used accumulate statistics of all eta bins
    m_detailedStat.reset( *m_truthSelectionTool,
                          (m_statPtBins.size() + 2) * (m_statEtaBins.size() + 2),
                          (m_statPtBins.size() + 2) * max_pdg_id_slots);
 
    m_pdgId.reserve(max_pdg_id_slots);
    m_pdgId.push_back(1000000000);
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

noiseCorrection()

double ActsTrk::TrackTruthMatchingBaseAlg::noiseCorrection ( const ActsTrk::HitCounterArray & noise_counts, const std::vector< float > & weights )

inlinestaticprivateinherited

Definition at line 811 of file TrackTruthMatchingBaseAlg.cxx.

                                                                                            {
     assert( weights.size() == noise_counts.size());
     double sum=0.;
     for (unsigned int count_i=0; count_i < noise_counts.size(); ++count_i) {
        sum -= weights[count_i] * noise_counts[count_i] - noise_counts[count_i];
     }
     return sum;
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

perEtaSize()

std::size_t ActsTrk::TrackTruthMatchingBaseAlg::perEtaSize ( ) const

inlineprotectedinherited

Definition at line 66 of file TrackTruthMatchingBaseAlg.h.

                                   {
        return m_detailedStat.perEtaSize();
     }

perPdgIdSize()

std::size_t ActsTrk::TrackTruthMatchingBaseAlg::perPdgIdSize ( ) const

inlineprotectedinherited

Definition at line 69 of file TrackTruthMatchingBaseAlg.h.

                                    {
        return m_detailedStat.perPdgIdSize();
     }

postProcessEventStat()

void ActsTrk::TrackTruthMatchingBaseAlg::postProcessEventStat ( const TruthParticleHitCounts & truth_particle_hit_counts, std::size_t n_tracks, TrackTruthMatchingBaseAlg::EventStat & event_stat ) const

protectedinherited

Definition at line 325 of file TrackTruthMatchingBaseAlg.cxx.

  {
     if constexpr(EventStat::doDetail) {
        if (m_computeTrackRecoEfficiency.value()) {
           for(const std::pair<const xAOD::TruthParticle * const,ActsTrk::HitCounterArray> &truth_particle : truth_particle_hit_counts) {
              const IAthSelectionTool::CutResult accept = m_truthSelectionTool->accept(truth_particle.first);
              if (accept) {
                 double truth_sum=weightedCountSum(truth_particle.second, m_weights.value() );
                 if (truth_sum>0.) {
                    float truth_particle_pt = truth_particle.first->pt();
                    std::size_t eta_category_i =  getPtEtaStatCategory(truth_particle_pt, truth_particle.first->eta());
                    std::size_t pdg_id_category_i =  getPtPdgIdStatCategory(truth_particle_pt, truth_particle.first->pdg_id());
                    event_stat.incrementTotal(eta_category_i, pdg_id_category_i);
                 }
              }
           }
        }
     }
 
    // update total statistic counter
    {
       std::lock_guard<std::mutex> lock(m_statMutex);
       m_counter[MissingTruthParticleHitCounts] += event_stat.m_nTruthParticleWithoutAssociatedCounts;
       m_counter[NoAssociatedTruthParticle] += event_stat.m_nTracksWithoutAssociatedTruthParticle;
       m_counter[NoSelectedTruthParticle] += event_stat.m_nTracksWithoutSelectedTruthParticle;
       m_counter[TruthParticleNoNoiseMismatch]+=event_stat.m_nTruthParticleNonoiseMismatches;
       m_counter[NTracksTotal]+=n_tracks;
       m_counter[NTruthWithCountsTotal]+=truth_particle_hit_counts.size();
 
       if constexpr(EventStat::doDetail) {
          m_detailedStat += event_stat;
       }
    }
  }

printCategories()

void ActsTrk::TrackTruthMatchingBaseAlg::printCategories ( const std::vector< std::string > & pt_category_labels, const std::vector< std::string > & eta_category_labels, std::vector< std::string > & counter_labels, std::vector< std::array< ActsUtils::Stat, kNCategorisedStat > > & stat_per_category, std::vector< std::array< std::size_t, kNCategorisedCounter > > & counts_per_category, const std::string & top_left_label, bool print_sub_categories ) const

privateinherited

Definition at line 566 of file TrackTruthMatchingBaseAlg.cxx.

                                                                                   {
     if (!row_category_labels.empty() && !col_category_labels.empty()) {
        if (row_category_labels.size() * col_category_labels.size() > counts_per_category.size() ) {
           ATH_MSG_ERROR( "Mismatch between category labels and number of counters (logic error -> fix needed):"
                          << row_category_labels.size() << " * " << col_category_labels.size()
                          << " > " << counts_per_category.size() );
        }
        constexpr std::size_t stat_column_width=14*4 + 3*3+4 + 9; // floats + seperators + integer of Stat output
        assert( stat_per_category.size() == counts_per_category.size());
        const unsigned int n_rows = row_category_labels.size();
        const unsigned int n_cols = stat_per_category.size() / n_rows; // some columns at the end of a row might not have labels
                                                                       // and are to be ignored
 
        assert( stat_per_category.size() % n_rows == 0 );
        const std::string hitEffStr{"Hit Efficiency"};
        const std::string hitPurStr{"Hit Purity"};
        const std::string matchProbStr{"Match probability"};
        const std::string recoEffStr{"reco efficiency"};
        const std::string statUncertainty{"stat. uncertainty"};
        const std::string space{" "};
        const std::string newline{"\n"};
        for(unsigned int row_i=(print_sub_categories ? 0 : n_rows-1); row_i<n_rows; ++row_i) {
           {
              std::vector<std::string> stat_labels { hitEffStr};
              msg() << makeTable( stat_per_category, row_i*n_cols, kNCategorisedStat, kHitEfficiency, 1u, col_category_labels, stat_labels, top_left)
                         .columnWidth(stat_column_width)
                         .labelPrefix(row_category_labels.at(row_i)+space)
                         .precision(std::vector<unsigned int>{3})
                    << newline;
           }
           {
              std::vector<std::string> stat_labels { hitPurStr };
              msg() << makeTable( stat_per_category, row_i*n_cols, kNCategorisedStat, kHitPurity, 1u, col_category_labels, stat_labels, top_left)
                          .columnWidth(stat_column_width)
                          .labelPrefix(row_category_labels.at(row_i)+space)
                          .precision(std::vector<unsigned int>{3})
                    << newline;
           }
           {
              std::vector<std::string> stat_labels { matchProbStr };
              msg() << makeTable( stat_per_category, row_i*n_cols, kNCategorisedStat, kMatchProbability, 1u, col_category_labels, stat_labels, top_left)
                          .columnWidth(stat_column_width)
                          .labelPrefix(row_category_labels.at(row_i)+space)
                          .precision(std::vector<unsigned int>{3})
                    << newline;
           }
           if (m_showRawCounts.value()) {
              msg() << makeTable( counts_per_category, row_i*n_cols, kNCategorisedCounter, 0u, 1u, col_category_labels, counter_labels, top_left)
                          .labelPrefix(row_category_labels.at(row_i)+space)
                    << newline;
           }
 
           if (m_computeTrackRecoEfficiency.value()) {
              std::vector< std::array< float, 2> > eff;
              eff.reserve(m_pdgId.size());
              for (unsigned int category_i=0; category_i< col_category_labels.size(); ++category_i) {
                 eff.push_back( computeRatio( counts_per_category[category_i+row_i*n_cols][kNParticleWithAssociatedTrack],
                                              counts_per_category[category_i+row_i*n_cols][kNTotalParticles] ) );
              }
              std::vector<std::string> eff_labels { recoEffStr,
                 statUncertainty };
              msg() << makeTable( eff, 0u, eff.begin()->size(),0u,1u, col_category_labels, eff_labels, top_left)
                          .labelPrefix(row_category_labels.at(row_i)+space)
                          .precision(std::vector<unsigned int>{3,3})
                    << newline;
           }
        }
     }
  }

printData2D()

void ActsTrk::TrackTruthMatchingBaseAlg::printData2D ( const std::vector< std::string > & row_category_labels, const std::vector< std::string > & col_category_labels, const std::string & top_left_label, std::vector< std::array< ActsUtils::Stat, kNCategorisedStat > > & stat_per_category, std::vector< std::array< std::size_t, kNCategorisedCounter > > & counts_per_category, bool rotate ) const

privateinherited

Definition at line 720 of file TrackTruthMatchingBaseAlg.cxx.

   {
     if (!row_category_labels.empty() && !col_category_labels.empty()) {
        if (row_category_labels.size() * col_category_labels.size() > counts_per_category.size() ) {
           ATH_MSG_ERROR( "Mismatch between category labels and number of counters (logic error -> fix needed):"
                          << row_category_labels.size() << " * " << col_category_labels.size()
                          << " > " << counts_per_category.size() );
        }
        std::vector<unsigned int> column_precision;
        column_precision.resize( rotate ? row_category_labels.size() : col_category_labels.size(), 3u);
        assert( stat_per_category.size() == counts_per_category.size());
        msg() << "Hit efficiency : contributing hits over all hits of best matching truth particle" << std::endl
              << create2DTable( row_category_labels, col_category_labels, top_left_label, stat_per_category,
                                [](const std::array< ActsUtils::Stat, kNCategorisedStat> &stat) {
                                   return stat.at(kHitEfficiency).mean();
                                },
                                rotate)
                    .columnWidth(10)
                    .precision(std::vector<unsigned int>(column_precision))
              << std::endl;
        msg() << "Hit purity : contributing hits of best matching truth particle over all hits on track" << std::endl
              << create2DTable( row_category_labels, col_category_labels, top_left_label, stat_per_category,
                                [](const std::array< ActsUtils::Stat, kNCategorisedStat> &stat) {
                                   return stat.at(kHitPurity).mean();
                                },
                                rotate)
                    .columnWidth(10)
                   .precision(std::vector<unsigned int>(column_precision))
              << std::endl;
        msg() << "Match probability : weighted common hit sum of best matching truth particle over total track weighted hit sum" << std::endl
              << create2DTable( row_category_labels, col_category_labels, top_left_label, stat_per_category,
                                [](const std::array< ActsUtils::Stat, kNCategorisedStat> &stat) {
                                   return stat.at(kMatchProbability).mean();
                                },
                                rotate)
                    .columnWidth(10)
                   .precision(std::vector<unsigned int>(column_precision))
              << std::endl;
 
        if (m_computeTrackRecoEfficiency.value()) {
           msg() << "Reco efficiency : tracks with assoc. truth particle over all selected truth particles with assoc. measurements."
                 << std::endl
                 << create2DTable( row_category_labels, col_category_labels, top_left_label, counts_per_category,
                                   [](const std::array< std::size_t, kNCategorisedCounter> &counter) {
                                      return computeRatio( counter[kNParticleWithAssociatedTrack],
                                                           counter[kNTotalParticles] )[0];
                                   },
                                   rotate)
                     .columnWidth(10)
                     .precision(std::move(column_precision))
                 << std::endl;
        }
     }
  }

printStatTables()

void ActsTrk::TrackTruthMatchingBaseAlg::printStatTables ( ) const

privateinherited

Definition at line 544 of file TrackTruthMatchingBaseAlg.cxx.

  {
    if (msgLvl(MSG::INFO))
    {
       msg() << MSG::INFO << std::endl;
       m_detailedStat.printStatTables( *this, m_statPtBins, m_statEtaBins, m_pdgId, m_printDetails.value(), m_pdgIdCategorisation.value(), m_useAbsEtaForStat );
      {
          std::array<std::string, kNCounter> counter_labels { std::string("Number of tracks"),
                                                              std::string("Number of truth particles with hit counts"),
                                                              std::string("Associated truth particles without hit counts"),
                                                              std::string("Tracks without associated truth particle"),
                                                              std::string("Tracks without selected, associated truth particle"),
                                                              std::string("Best truth particle without noise correction mismatch")
          };
          msg() << makeTable( m_counter, counter_labels) << std::endl;
      }
      msg() << endmsg;
    }
  }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

                                                      {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

weightedCountSum()

double ActsTrk::TrackTruthMatchingBaseAlg::weightedCountSum ( const ActsTrk::HitCounterArray & counts, const std::vector< float > & weights )

inlinestaticprivateinherited

Definition at line 801 of file TrackTruthMatchingBaseAlg.cxx.

                                                                                             {
     assert( weights.size() == counts.size());
     double sum=0.;
     for (unsigned int count_i=0; count_i < counts.size(); ++count_i) {
        sum += counts[count_i] * weights[count_i];
     }
     return sum;
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/4]

BaseStat<TrackFindingValidationDetailedStat> m_detailedStat ActsTrk::TrackTruthMatchingBaseAlg::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 339 of file TrackTruthMatchingBaseAlg.h.

ATLAS_THREAD_SAFE [2/4]

std::vector< int > m_pdgId ActsTrk::TrackTruthMatchingBaseAlg::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 338 of file TrackTruthMatchingBaseAlg.h.

ATLAS_THREAD_SAFE [3/4]

std::array< std::size_t, kNCounter > m_counter ActsTrk::TrackTruthMatchingBaseAlg::ATLAS_THREAD_SAFE {}

mutableprivateinherited

Definition at line 337 of file TrackTruthMatchingBaseAlg.h.

{};

ATLAS_THREAD_SAFE [4/4]

std::mutex m_statMutex ActsTrk::TrackTruthMatchingBaseAlg::ATLAS_THREAD_SAFE

mutableprivateinherited

Definition at line 336 of file TrackTruthMatchingBaseAlg.h.

m_computeTrackRecoEfficiency

Gaudi::Property<bool> ActsTrk::TrackTruthMatchingBaseAlg::m_computeTrackRecoEfficiency {this, "ComputeTrackRecoEfficiency", true, "Compute and print track reconstruction efficiency."}

privateinherited

Definition at line 177 of file TrackTruthMatchingBaseAlg.h.

{this, "ComputeTrackRecoEfficiency", true, "Compute and print track reconstruction efficiency."};

m_debugCounter

DebugCounter<TrackFindingValidationDebugHists> ActsTrk::TrackTruthMatchingBaseAlg::m_debugCounter

privateinherited

Definition at line 205 of file TrackTruthMatchingBaseAlg.h.

m_derivateTruthKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> ActsTrk::TrackParticleTruthDecorationAlg::m_derivateTruthKey {this, "DerivateTruthKey", ""}

private

Muon tracks are matched to the truth particle container insert a bypass to bend the link to the desired truth particle container.

Definition at line 45 of file TrackParticleTruthDecorationAlg.h.

{this, "DerivateTruthKey", ""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_floatDecor

SG::WriteDecorHandleKeyArray<xAOD::TrackParticleContainer> ActsTrk::TrackParticleTruthDecorationAlg::m_floatDecor {this, "FloatDecorators", {}}

private

Definition at line 48 of file TrackParticleTruthDecorationAlg.h.

{this, "FloatDecorators", {}};

m_intDecor

SG::WriteDecorHandleKeyArray<xAOD::TrackParticleContainer> ActsTrk::TrackParticleTruthDecorationAlg::m_intDecor {this, "IntDecorators", {}}

private

Definition at line 51 of file TrackParticleTruthDecorationAlg.h.

{this, "IntDecorators", {}};

m_linkDecor

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::TrackParticleTruthDecorationAlg::m_linkDecor {this, "LinkDecoration", m_trkParticleName, "truthParticleLink"}

private

Definition at line 58 of file TrackParticleTruthDecorationAlg.h.

{this, "LinkDecoration", m_trkParticleName, "truthParticleLink"};

m_pdgIdCategorisation

Gaudi::Property<bool> ActsTrk::TrackTruthMatchingBaseAlg::m_pdgIdCategorisation {this, "PdgIdCategorisation", false, "Categorise by pdg id."}

privateinherited

Definition at line 171 of file TrackTruthMatchingBaseAlg.h.

{this, "PdgIdCategorisation", false, "Categorise by pdg id."};

m_printDetails

Gaudi::Property<bool> ActsTrk::TrackTruthMatchingBaseAlg::m_printDetails {this, "ShowDetailedTables", false, "Show more details; stat. uncert., RMS, entries"}

privateinherited

Definition at line 175 of file TrackTruthMatchingBaseAlg.h.

{this, "ShowDetailedTables", false, "Show more details; stat. uncert., RMS, entries"};

m_showRawCounts

Gaudi::Property<bool> ActsTrk::TrackTruthMatchingBaseAlg::m_showRawCounts {this, "ShowRawCounts", false, "Show all counters."}

privateinherited

Definition at line 173 of file TrackTruthMatchingBaseAlg.h.

{this, "ShowRawCounts", false, "Show all counters."};

m_statEtaBins

Gaudi::Property<std::vector<float> > ActsTrk::TrackTruthMatchingBaseAlg::m_statEtaBins {this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these eta bins."}

privateinherited

Definition at line 167 of file TrackTruthMatchingBaseAlg.h.

{this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these eta bins."};

m_statPtBins

Gaudi::Property<std::vector<float> > ActsTrk::TrackTruthMatchingBaseAlg::m_statPtBins {this, "StatisticPtBins", {1.e3,2.5e3,10e3, 100e3}, "Gather statistics separately for these pt bins."}

privateinherited

Definition at line 169 of file TrackTruthMatchingBaseAlg.h.

{this, "StatisticPtBins", {1.e3,2.5e3,10e3, 100e3}, "Gather statistics separately for these pt bins."};

m_trackToTruth

SG::ReadHandleKeyArray<TrackToTruthParticleAssociation> ActsTrk::TrackParticleTruthDecorationAlg::m_trackToTruth

private

Initial value:

{this, "TrackToTruthAssociationMaps",{},
         "Association maps from tracks to generator particles for all Acts tracks linked from the given track particle." }

Hit-based truth matching from the Acts::Track -> truth particle.

Definition at line 36 of file TrackParticleTruthDecorationAlg.h.

        {this, "TrackToTruthAssociationMaps",{},
         "Association maps from tracks to generator particles for all Acts tracks linked from the given track particle." };

m_trkParticleName

SG::ReadHandleKey<xAOD::TrackParticleContainer> ActsTrk::TrackParticleTruthDecorationAlg::m_trkParticleName {this,"TrackParticleContainerName", "InDetTrackParticles",""}

private

Definition at line 40 of file TrackParticleTruthDecorationAlg.h.

{this,"TrackParticleContainerName", "InDetTrackParticles",""};

m_truthClassDecor

SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> ActsTrk::TrackParticleTruthDecorationAlg::m_truthClassDecor {this, "TruthClassification", m_trkParticleName, "truthClassification"}

private

Definition at line 52 of file TrackParticleTruthDecorationAlg.h.

{this, "TruthClassification", m_trkParticleName, "truthClassification"};

m_truthClassifier

ToolHandle<IMCTruthClassifier> ActsTrk::TrackParticleTruthDecorationAlg::m_truthClassifier {this, "MCTruthClassifier", "MCTruthClassifier/MCTruthClassifier"}

private

Definition at line 55 of file TrackParticleTruthDecorationAlg.h.

{this, "MCTruthClassifier", "MCTruthClassifier/MCTruthClassifier"};

m_truthHitCounts

SG::ReadHandleKey<TruthParticleHitCounts> ActsTrk::TrackTruthMatchingBaseAlg::m_truthHitCounts {this, "TruthParticleHitCounts","", "Map from truth particle to hit counts." }

privateinherited

Definition at line 148 of file TrackTruthMatchingBaseAlg.h.

{this, "TruthParticleHitCounts","", "Map from truth particle to hit counts." };

m_truthLinkedFakeRate

Gaudi::Property<bool> ActsTrk::TrackTruthMatchingBaseAlg::m_truthLinkedFakeRate

privateinherited

Initial value:

{this, "TruthLinkedFakeRate", false, "Compute the match probability from the truth-linked measurements only:"
                                             " measurements without truth particle weigh 1 and cannot be the best match, so a"
                                             " track made only of them has probability 0. By default the probability is"
                                             " computed the way the legacy truth matching does (DetailedTrackTruthBuilder,"
                                             " TruthMatchRatio): measurements without truth particle keep their full weight and"
                                             " together compete for the best match as one pseudo particle; if it wins, the"
                                             " probability is their weighted fraction and there is no matching truth particle." }

Definition at line 159 of file TrackTruthMatchingBaseAlg.h.

        {this, "TruthLinkedFakeRate", false, "Compute the match probability from the truth-linked measurements only:"
                                             " measurements without truth particle weigh 1 and cannot be the best match, so a"
                                             " track made only of them has probability 0. By default the probability is"
                                             " computed the way the legacy truth matching does (DetailedTrackTruthBuilder,"
                                             " TruthMatchRatio): measurements without truth particle keep their full weight and"
                                             " together compete for the best match as one pseudo particle; if it wins, the"
                                             " probability is their weighted fraction and there is no matching truth particle." };

m_truthSelectionTool

ToolHandle<IAthSelectionTool> ActsTrk::TrackTruthMatchingBaseAlg::m_truthSelectionTool {this, "TruthSelectionTool","AthTruthSelectionTool", "Truth selection tool (for efficiencies and resolutions)"}

protectedinherited

Definition at line 146 of file TrackTruthMatchingBaseAlg.h.

{this, "TruthSelectionTool","AthTruthSelectionTool", "Truth selection tool (for efficiencies and resolutions)"};

m_useAbsEtaForStat

bool ActsTrk::TrackTruthMatchingBaseAlg::m_useAbsEtaForStat = false

privateinherited

Definition at line 238 of file TrackTruthMatchingBaseAlg.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

m_weights

Gaudi::Property<std::vector<float> > ActsTrk::TrackTruthMatchingBaseAlg::m_weights

privateinherited

Initial value:

{this, "CountWeights", std::vector<float>(s_NMeasurementTypes,1.f), 
         "Weights applied to the counts per measurement type for weighted sums"
         " which are used to compute hit efficiencies and purities." }

Definition at line 155 of file TrackTruthMatchingBaseAlg.h.

        {this, "CountWeights", std::vector<float>(s_NMeasurementTypes,1.f), 
         "Weights applied to the counts per measurement type for weighted sums"
         " which are used to compute hit efficiencies and purities." };

m_weightsForProb

Gaudi::Property<std::vector<float> > ActsTrk::TrackTruthMatchingBaseAlg::m_weightsForProb

privateinherited

Initial value:

{this, "MatchWeights", std::vector<float>(s_NMeasurementTypes,1.f), 
         "Weights applied to the counts per measurement type for weighted sums"
                                  " which are used compute the match probability." }

Definition at line 151 of file TrackTruthMatchingBaseAlg.h.

        {this, "MatchWeights", std::vector<float>(s_NMeasurementTypes,1.f), 
         "Weights applied to the counts per measurement type for weighted sums"
                                  " which are used compute the match probability." };

s_NMeasurementTypes

unsigned int ActsTrk::TrackTruthMatchingBaseAlg::s_NMeasurementTypes = Acts::toUnderlying(xAOD::UncalibMeasType::nTypes)

staticconstexprprivateinherited

Definition at line 208 of file TrackTruthMatchingBaseAlg.h.

s_pdgIdMax

int ActsTrk::TrackTruthMatchingBaseAlg::s_pdgIdMax = 1000000000

staticconstexprprivateinherited

Definition at line 235 of file TrackTruthMatchingBaseAlg.h.

---

The documentation for this class was generated from the following files:

• TrackParticleTruthDecorationAlg.h
• TrackParticleTruthDecorationAlg.cxx