ActsTrk::TrackFindingValidationAlg Class Reference

#include <TrackFindingValidationAlg.h>

Inheritance diagram for ActsTrk::TrackFindingValidationAlg:

Collaboration diagram for ActsTrk::TrackFindingValidationAlg:

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.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
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
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.
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
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
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.

Private Types
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.
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::ReadHandleKey< TrackToTruthParticleAssociation >	m_trackToTruth {this, "TrackToTruthAssociationMap","", "Association map from tracks to generator particles." }
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.
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 = static_cast<unsigned int>(xAOD::UncalibMeasType::nTypes)
static constexpr int	s_pdgIdMax = 1000000000

Detailed Description

Definition at line 23 of file TrackFindingValidationAlg.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 243 of file TrackTruthMatchingBaseAlg.h.

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

ECategorisedStat

enum ActsTrk::TrackTruthMatchingBaseAlg::ECategorisedStat

privateinherited

Enumerator
kHitEfficiency
kHitPurity
kMatchProbability
kNCategorisedStat

Definition at line 250 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 233 of file TrackTruthMatchingBaseAlg.h.

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

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 75 of file AthCommonReentrantAlgorithm.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()

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::TrackFindingValidationAlg::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 23 of file TrackFindingValidationAlg.cxx.

  {
    const TruthParticleHitCounts &truth_particle_hit_counts = getTruthParticleHitCounts(ctx);
    SG::ReadHandle<TrackToTruthParticleAssociation> track_to_truth_handle = SG::makeHandle(m_trackToTruth, ctx);
    if (!track_to_truth_handle.isValid()) {
       ATH_MSG_ERROR("No track to truth particle association for key " << m_trackToTruth.key() );
       return StatusCode::FAILURE;
    }
 
    EventStat event_stat(truthSelectionTool(),
                         perEtaSize(),
                         perPdgIdSize(),
                         track_to_truth_handle->size());
 
    for(const HitCountsPerTrack &track_hit_counts : *track_to_truth_handle) {
       analyseTrackTruth(truth_particle_hit_counts,
                         track_hit_counts,
                         event_stat);
    }
    postProcessEventStat(truth_particle_hit_counts,
                         track_to_truth_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 & AthCommonReentrantAlgorithm< 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 94 of file AthCommonReentrantAlgorithm.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

finalize()

StatusCode ActsTrk::TrackFindingValidationAlg::finalize ( )

overridevirtual

Reimplemented from ActsTrk::TrackTruthMatchingBaseAlg.

Definition at line 17 of file TrackFindingValidationAlg.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::TrackFindingValidationAlg::initialize ( )

overridevirtual

Reimplemented from ActsTrk::TrackTruthMatchingBaseAlg.

Definition at line 10 of file TrackFindingValidationAlg.cxx.

  {
     StatusCode sc = TrackTruthMatchingBaseAlg::initialize();
     ATH_CHECK( m_trackToTruth.initialize() );
     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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, 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, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  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 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthCommonReentrantAlgorithm< 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.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

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

Definition at line 61 of file AthCommonReentrantAlgorithm.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.

TrackTruthMatchingBaseAlg()

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

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.

{ 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 358 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 359 of file TrackTruthMatchingBaseAlg.h.

{};

ATLAS_THREAD_SAFE [3/4]

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

mutableprivateinherited

Definition at line 360 of file TrackTruthMatchingBaseAlg.h.

ATLAS_THREAD_SAFE [4/4]

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

mutableprivateinherited

Definition at line 361 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.

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

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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.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.

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

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.

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

m_showRawCounts

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

privateinherited

Definition at line 192 of file TrackTruthMatchingBaseAlg.h.

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

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.

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

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.

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

m_trackToTruth

SG::ReadHandleKey<TrackToTruthParticleAssociation> ActsTrk::TrackFindingValidationAlg::m_trackToTruth {this, "TrackToTruthAssociationMap","", "Association map from tracks to generator particles." }

private

Definition at line 33 of file TrackFindingValidationAlg.h.

{this, "TrackToTruthAssociationMap","", "Association map from tracks to generator particles." };

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.

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

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.

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

m_useAbsEtaForStat

bool ActsTrk::TrackTruthMatchingBaseAlg::m_useAbsEtaForStat = false

privateinherited

Definition at line 260 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.

        {this, "CountWeights", {}, "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", {}, "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.

        {this, "MatchWeights", {}, "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 = static_cast<unsigned int>(xAOD::UncalibMeasType::nTypes)

staticconstexprprivateinherited

Definition at line 230 of file TrackTruthMatchingBaseAlg.h.

s_pdgIdMax

int ActsTrk::TrackTruthMatchingBaseAlg::s_pdgIdMax = 1000000000

staticconstexprprivateinherited

Definition at line 257 of file TrackTruthMatchingBaseAlg.h.

---

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

• TrackFindingValidationAlg.h
• TrackFindingValidationAlg.cxx