#include <TrackParticleTruthDecorationAlg.h>

Inheritance diagram for ActsTrk::TrackParticleTruthDecorationAlg:

Collaboration diagram for ActsTrk::TrackParticleTruthDecorationAlg:

Public Member Functions
virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

virtual StatusCode	execute (const EventContext &ctx) const override

	TrackTruthMatchingBaseAlg (const std::string &name, ISvcLocator *pSvcLocator)

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

virtual bool	filterPassed (const EventContext &ctx) const

virtual void	setFilterPassed (bool state, const EventContext &ctx) const

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Types
using	EventStat = EventStatBase< TrackFindingValidationDetailedStat >

Protected Member Functions
const TruthParticleHitCounts &	getTruthParticleHitCounts (const EventContext &ctx) const

const IAthSelectionTool &	truthSelectionTool () 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 More...

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. More...

Private Types
enum	FloatDecorations { kMatchingProbability, kHitPurity, kHitEfficiency, kNFloatDecorators }

enum	ECounter { NTracksTotal, NTruthWithCountsTotal, MissingTruthParticleHitCounts, NoAssociatedTruthParticle, NoSelectedTruthParticle, TruthParticleNoNoiseMismatch, kNCounter }

enum	ECategorisedCounter { kNTotalParticles, kNParticleWithAssociatedTrack, kNParticleWithMultipleAssociatedTracks, kNTotalTracks, kNCategorisedCounter }

enum	ECategorisedStat { kHitEfficiency, kHitPurity, kMatchProbability, kNCategorisedStat }

template<class Base >
using	Property = std::conditional< TrackFindingValidationDetailedStat, Gaudi::Property< Base >, DummyProperty< Base > >::type

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. More...

std::size_t	getPtEtaStatCategory (float pt, float eta) const
	Return the category based on the provided eta value. More...

std::size_t	getPtPdgIdStatCategory (float pt, int pdg_id) const
	Return the category based on the PDG ID. More...

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 > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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

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

std::vector< SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > >	m_linkDecor

std::vector< SG::WriteDecorHandleKey< xAOD::TrackParticleContainer > >	m_floatDecor

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

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

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

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

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

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

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

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

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. More...

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Static Private Attributes
constexpr static unsigned int	s_NMeasurementTypes = static_cast<unsigned int>(xAOD::UncalibMeasType::nTypes) - 1u

constexpr static int	s_pdgIdMax = 1000000000

Detailed Description

Definition at line 24 of file TrackParticleTruthDecorationAlg.h.

Member Typedef Documentation

◆ EventStat

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

protectedinherited

Definition at line 129 of file TrackTruthMatchingBaseAlg.h.

◆ Property

template<class Base >

using ActsTrk::TrackTruthMatchingBaseAlg::Property = std::conditional< TrackFindingValidationDetailedStat, Gaudi::Property<Base>, DummyProperty<Base> >::type

privateinherited

Definition at line 184 of file TrackTruthMatchingBaseAlg.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ ECategorisedCounter

enum ActsTrk::TrackTruthMatchingBaseAlg::ECategorisedCounter

privateinherited

Enumerator
kNTotalParticles
kNParticleWithAssociatedTrack
kNParticleWithMultipleAssociatedTracks
kNTotalTracks
kNCategorisedCounter

Definition at line 244 of file TrackTruthMatchingBaseAlg.h.

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

◆ ECategorisedStat

enum ActsTrk::TrackTruthMatchingBaseAlg::ECategorisedStat

privateinherited

Enumerator
kHitEfficiency
kHitPurity
kMatchProbability
kNCategorisedStat

Definition at line 251 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 234 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 41 of file TrackParticleTruthDecorationAlg.h.

41 { kMatchingProbability, kHitPurity, kHitEfficiency, kNFloatDecorators};

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 209 of file TrackTruthMatchingBaseAlg.cxx.

   {
        TruthMatchResult ret{};
        std::array<unsigned int,2> best_match_i{std::numeric_limits<unsigned int>::max(),std::numeric_limits<unsigned int>::max()};
        std::array<float,2> best_match_prob {};
  
        std::array<unsigned int,2> best_match_i_nonoise{std::numeric_limits<unsigned int>::max(),std::numeric_limits<unsigned int>::max()};
        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() );
        double noise_sum=noiseCorrection(noise_counts, m_weightsForProb.value() );
        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
        unsigned int truth_i=0;
        --truth_i;
        for (const std::pair<const xAOD::TruthParticle *, HitCounterArray > &
                hit_counts_for_associated_truth_particle : track_hit_counts.countsPerTruthParticle() ) {
           ++truth_i;
           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.) {
              ATH_MSG_ERROR("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;
           }
  
        }
        }
  
        if (best_match_i_nonoise[0] != best_match_i[0]) {
           ++event_stat.m_nTruthParticleNonoiseMismatches;
        }
        if (   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 = track_hit_counts.countsPerTruthParticle()[ best_match_i[0] ].first;
           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 (!track_hit_counts.countsPerTruthParticle().empty()) {
              ATH_MSG_ERROR("Failed to select best matching truth particle out of " << track_hit_counts.countsPerTruthParticle().size()
                            << ". This should not happen." );
           }
        }
        return ret;
     }

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ 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 403 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 777 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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > & 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

overridevirtual

Definition at line 40 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> &truth_association_key : m_trackToTruth) {
        SG::ReadHandle<TrackToTruthParticleAssociation> track_to_truth_handle = SG::makeHandle(truth_association_key, ctx);
        if (!track_to_truth_handle.isValid()) {
           ATH_MSG_ERROR("No track to truth particle association for key " << truth_association_key.key() );
           return StatusCode::FAILURE;
        }
        truth_association_map.insert(std::make_pair( track_to_truth_handle->sourceContainer(), track_to_truth_handle.cptr() ));
     }
  
     SG::ReadHandle<xAOD::TrackParticleContainer> track_particle_handle = SG::makeHandle(m_trkParticleName, ctx);
     if (!track_particle_handle.isValid()) {
        ATH_MSG_ERROR("No track particle container for key " << track_particle_handle.key() );
        return StatusCode::FAILURE;
     }
     std::vector< SG::WriteDecorHandle<xAOD::TrackParticleContainer,float > >
        float_decor( createDecorators<xAOD::TrackParticleContainer, float >(m_floatDecor, ctx) );
     SG::WriteDecorHandle<xAOD::TrackParticleContainer, ElementLink<xAOD::TruthParticleContainer> >
        link_decor(m_linkDecor.at(0), ctx);
  
     EventStat event_stat(truthSelectionTool(),
                          perEtaSize(),
                          perPdgIdSize(),
                          track_particle_handle->size());
  
     static const SG::AuxElement::ConstAccessor<ElementLink<ActsTrk::TrackContainer> > actsTrackLink("actsTrack");
  
     std::pair<const ActsTrk::TrackContainerBase *, const ActsTrk::TrackToTruthParticleAssociation *>
        the_track_truth_association{ nullptr, nullptr};
     ElementLink<xAOD::TruthParticleContainer> ref_truth_link;
     for(const xAOD::TrackParticle *track_particle : *track_particle_handle) {
        ElementLink<ActsTrk::TrackContainer> link_to_track = actsTrackLink(*track_particle);
        static_assert( std::is_same<ElementLink<ActsTrk::TrackContainer>::ElementConstReference,
                       std::optional<ActsTrk::TrackContainer::ConstTrackProxy> >::value);
        TruthMatchResult truth_match{} ;
  
        {
           std::optional<ActsTrk::TrackContainer::ConstTrackProxy> optional_track = *link_to_track;
           if (optional_track.has_value()) {
              const ActsTrk::TrackContainerBase *track_container = &(optional_track.value().container());
              if (track_container != the_track_truth_association.first && track_container ) {
                 std::unordered_map<const ActsTrk::TrackContainerBase *, const ActsTrk::TrackToTruthParticleAssociation *>::const_iterator
                    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;
                 }
              }
              if (the_track_truth_association.second) {
                 truth_match =  analyseTrackTruth(truth_particle_hit_counts,
                                                  (*the_track_truth_association.second).at(optional_track.value().index()),
                                                  event_stat);
  
                 const xAOD::TruthParticle *truth_particle = truth_match.m_truthParticle;
  
                 // decorate track particle with link to truth particle, matching probability etc.
                 if (truth_particle) {
                    if (!ref_truth_link.isValid()) {
                       const xAOD::TruthParticleContainer *truth_particle_container
                          = dynamic_cast<const xAOD::TruthParticleContainer *>(truth_particle->container());
                       if (!truth_particle_container) {
                          ATH_MSG_ERROR("Valid truth particle not part of a xAOD::TruthParticleContainer");
                       }
                       else {
                          ref_truth_link=  ElementLink<xAOD::TruthParticleContainer>(*truth_particle_container,0u,ctx);
                       }
                    }
                    assert( truth_particle->container() == ref_truth_link.getStorableObjectPointer() );
                    link_decor(*track_particle) = ElementLink<xAOD::TruthParticleContainer>(ref_truth_link, truth_particle->index());
                 }
                 else {
                    link_decor(*track_particle) = ElementLink<xAOD::TruthParticleContainer>();
                 }
              }
           }
        }
        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;
     }
     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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.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 Algorithm::extraOutputDeps();
 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

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

◆ finalize()

StatusCode ActsTrk::TrackParticleTruthDecorationAlg::finalize ( )

overridevirtual

Reimplemented from ActsTrk::TrackTruthMatchingBaseAlg.

Definition at line 34 of file TrackParticleTruthDecorationAlg.cxx.

   {
      StatusCode sc = TrackTruthMatchingBaseAlg::finalize();
      return sc;
   }

◆ 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 368 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 379 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 60 of file TrackTruthMatchingBaseAlg.h.

                                                                                             {
         SG::ReadHandle<TruthParticleHitCounts> truth_particle_hit_counts_handle = SG::makeHandle(m_truthHitCounts, ctx);
         if (!truth_particle_hit_counts_handle.isValid()) {
            ATH_MSG_ERROR("No truth particle hit count map for key " << m_truthHitCounts.key() );
            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 16 of file TrackParticleTruthDecorationAlg.cxx.

   {
      StatusCode sc = TrackTruthMatchingBaseAlg::initialize();
      ATH_CHECK( m_trackToTruth.initialize() );
      ATH_CHECK( m_trkParticleName.initialize() );
      std::vector<std::string> float_decor_names(kNFloatDecorators);
      float_decor_names[kMatchingProbability]="truthMatchProbability";
      float_decor_names[kHitPurity]="truthHitPurity";
      float_decor_names[kHitEfficiency]="truthHitEfficiency";
      createDecoratorKeys(*this,m_trkParticleName,"" /*prefix ? */, float_decor_names,m_floatDecor);
      assert( m_floatDecor.size() == kNFloatDecorators);
      std::vector<std::string> link_decor_names;
      link_decor_names.push_back("truthParticleLink");
      createDecoratorKeys(*this,m_trkParticleName,"" /*prefix ? */, link_decor_names,m_linkDecor);
      assert( m_linkDecor.size() == 1);
      return sc;
   }

◆ initStatTables()

void ActsTrk::TrackTruthMatchingBaseAlg::initStatTables ( )

privateinherited

Definition at line 417 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()

bool AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

 {
   // Reentrant algorithms are clonable.
   return true;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 808 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 71 of file TrackTruthMatchingBaseAlg.h.

                                    {
         return m_detailedStat.perEtaSize();
      }

◆ perPdgIdSize()

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

inlineprotectedinherited

Definition at line 74 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 331 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 570 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 );
         for(unsigned int row_i=(print_sub_categories ? 0 : n_rows-1); row_i<n_rows; ++row_i) {
            {
               std::vector<std::string> stat_labels { std::string("Hit Efficiency") };
               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)+" ")
                          .precision(std::vector<unsigned int>{3})
                     << std::endl;
            }
            {
               std::vector<std::string> stat_labels { std::string("Hit Purity") };
               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)+" ")
                           .precision(std::vector<unsigned int>{3})
                     << std::endl;
            }
            {
               std::vector<std::string> stat_labels { std::string("Match probability") };
               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)+" ")
                           .precision(std::vector<unsigned int>{3})
                     << std::endl;
            }
            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)+" ")
                     << std::endl;
            }
  
            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 { std::string("reco efficiency"),
                  std::string("stat. uncertainty") };
               msg() << makeTable( eff, 0u, eff.begin()->size(),0u,1u, col_category_labels, eff_labels, top_left)
                           .labelPrefix(row_category_labels.at(row_i)+" ")
                           .precision(std::vector<unsigned int>{3,3})
                     << std::endl;
            }
         }
      }
   }

◆ 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 717 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 548 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 380 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 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed	(	bool	state,
		const EventContext &	ctx
	)		const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthReentrantAlgorithm::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.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

 {
   return Gaudi::Algorithm::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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 InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

                                                 {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::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.

◆ TrackTruthMatchingBaseAlg()

ActsTrk::TrackTruthMatchingBaseAlg::TrackTruthMatchingBaseAlg

Definition at line 53 of file TrackTruthMatchingBaseAlg.cxx.

       : AthReentrantAlgorithm(name, pSvcLocator)
   {
   }

◆ truthSelectionTool()

const IAthSelectionTool& ActsTrk::TrackTruthMatchingBaseAlg::truthSelectionTool ( ) const

inlineprotectedinherited

Definition at line 69 of file TrackTruthMatchingBaseAlg.h.

69 { return *m_truthSelectionTool; }

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     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 798 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]

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

mutableprivateinherited

Definition at line 359 of file TrackTruthMatchingBaseAlg.h.

◆ ATLAS_THREAD_SAFE [2/4]

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

mutableprivateinherited

Definition at line 360 of file TrackTruthMatchingBaseAlg.h.

◆ ATLAS_THREAD_SAFE [3/4]

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

mutableprivateinherited

Definition at line 361 of file TrackTruthMatchingBaseAlg.h.

◆ ATLAS_THREAD_SAFE [4/4]

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

mutableprivateinherited

Definition at line 362 of file TrackTruthMatchingBaseAlg.h.

◆ m_computeTrackRecoEfficiency

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

privateinherited

Definition at line 196 of file TrackTruthMatchingBaseAlg.h.

◆ m_debugCounter

DebugCounter<TrackFindingValidationDebugHists> ActsTrk::TrackTruthMatchingBaseAlg::m_debugCounter

privateinherited

Definition at line 227 of file TrackTruthMatchingBaseAlg.h.

◆ m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 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 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_floatDecor

std::vector<SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> > ActsTrk::TrackParticleTruthDecorationAlg::m_floatDecor

private

Definition at line 43 of file TrackParticleTruthDecorationAlg.h.

◆ m_linkDecor

std::vector<SG::WriteDecorHandleKey<xAOD::TrackParticleContainer> > ActsTrk::TrackParticleTruthDecorationAlg::m_linkDecor

private

Definition at line 42 of file TrackParticleTruthDecorationAlg.h.

◆ m_pdgIdCategorisation

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

privateinherited

Definition at line 190 of file TrackTruthMatchingBaseAlg.h.

◆ m_printDetails

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

privateinherited

Definition at line 194 of file TrackTruthMatchingBaseAlg.h.

◆ m_showRawCounts

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

privateinherited

Definition at line 192 of file TrackTruthMatchingBaseAlg.h.

◆ m_statEtaBins

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 186 of file TrackTruthMatchingBaseAlg.h.

◆ m_statPtBins

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 188 of file TrackTruthMatchingBaseAlg.h.

◆ 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." }

Definition at line 34 of file TrackParticleTruthDecorationAlg.h.

◆ m_trkParticleName

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

private

Definition at line 38 of file TrackParticleTruthDecorationAlg.h.

◆ m_truthHitCounts

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

privateinherited

Definition at line 152 of file TrackTruthMatchingBaseAlg.h.

◆ m_truthSelectionTool

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

privateinherited

Definition at line 199 of file TrackTruthMatchingBaseAlg.h.

◆ m_useAbsEtaForStat

bool ActsTrk::TrackTruthMatchingBaseAlg::m_useAbsEtaForStat = false

privateinherited

Definition at line 261 of file TrackTruthMatchingBaseAlg.h.

◆ m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_weights

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

privateinherited

Initial value:

{this, "CountWeights", {}, "Weights applied to the counts per measurement type for weighted sums"

" which are used to compute hit efficiencies and purities." }

Definition at line 158 of file TrackTruthMatchingBaseAlg.h.

◆ m_weightsForProb

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

privateinherited

Initial value:

{this, "MatchWeights", {}, "Weights applied to the counts per measurement type for weighted sums"

" which are used compute the match probability." }

Definition at line 155 of file TrackTruthMatchingBaseAlg.h.

◆ s_NMeasurementTypes

constexpr static unsigned int ActsTrk::TrackTruthMatchingBaseAlg::s_NMeasurementTypes = static_cast<unsigned int>(xAOD::UncalibMeasType::nTypes) - 1u

staticconstexprprivateinherited

Definition at line 231 of file TrackTruthMatchingBaseAlg.h.

◆ s_pdgIdMax

constexpr static int ActsTrk::TrackTruthMatchingBaseAlg::s_pdgIdMax = 1000000000

staticconstexprprivateinherited

Definition at line 258 of file TrackTruthMatchingBaseAlg.h.

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

Public Member Functions

Protected Types

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ EventStat

◆ Property

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ ECategorisedCounter

◆ ECategorisedStat

◆ ECounter

◆ FloatDecorations

Member Function Documentation

◆ analyseTrackTruth()

◆ cardinality()

◆ checkBinOrder()

◆ checkMatchWeights()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ finalize()

◆ getPtEtaStatCategory()

◆ getPtPdgIdStatCategory()

◆ getTruthParticleHitCounts()

◆ initialize()

◆ initStatTables()

◆ inputHandles()

◆ isClonable()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ noiseCorrection()

◆ outputHandles()

◆ perEtaSize()

◆ perPdgIdSize()

◆ postProcessEventStat()

◆ printCategories()

◆ printData2D()

◆ printStatTables()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ TrackTruthMatchingBaseAlg()

◆ truthSelectionTool()

◆ updateVHKA()

◆ weightedCountSum()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/4]

◆ ATLAS_THREAD_SAFE [2/4]

◆ ATLAS_THREAD_SAFE [3/4]

◆ ATLAS_THREAD_SAFE [4/4]

◆ m_computeTrackRecoEfficiency

◆ m_debugCounter

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_floatDecor