ActsTrk::TrackFindingBaseAlg Class Reference

#include <TrackFindingBaseAlg.h>

Inheritance diagram for ActsTrk::TrackFindingBaseAlg:

Classes
struct	MeasurementSelectorConfig
struct	DetectorContextHolder
struct	TrackFindingDefaultOptions
struct	BranchState
struct	CKF_pimpl

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

Protected Types
enum	EStat : std::size_t {   kNTotalSeeds , kNoTrackParam , kNUsedSeeds , kNoTrack ,   kNDuplicateSeeds , kNNoEstimatedParams , kNOutputTracks , kNSeedRefitFailure ,   kNRejectedRefinedSeeds , kNSelectedTracks , kNStoppedTracksMaxHoles , kMultipleBranches ,   kNoSecond , kNStoppedTracksMinPt , kNStoppedTracksMaxEta , kNTotalSharedHits ,   kNForcedSeedMeasurements , kNResolvedTracks , kNStat }
using	TrackFinderOptions = Acts::CombinatorialKalmanFilterOptions<detail::RecoTrackContainer>
using	EventStats = std::vector<std::array<unsigned int, kNStat>>
using	TrkProxy = detail::RecoTrackContainer::TrackProxy
using	BranchStopperResult = Acts::CombinatorialKalmanFilterBranchStopperResult

Protected Member Functions
CKF_pimpl &	trackFinder ()
const CKF_pimpl &	trackFinder () const
StatusCode	initializeMeasurementSelector ()
std::unique_ptr< ActsTrk::IMeasurementSelector >	setMeasurementSelector (const EventContext &ctx, const detail::TrackFindingMeasurements &measurements, TrackFinderOptions &options) const
	Setup and attach measurement selector to KF options.
TrackFindingDefaultOptions	getDefaultOptions (const EventContext &ctx, const DetectorContextHolder &detContext, const detail::TrackFindingMeasurements &measurements, const Acts::PerigeeSurface *pSurface) const
	Get CKF options for first and second pass + pointer to MeasurementSelector.
template<class HandleArrayKeyType, class ContainerType>
StatusCode	getContainersFromKeys (const EventContext &ctx, HandleArrayKeyType &handleKeyArray, std::vector< const ContainerType * > &outputContainers, std::size_t &sum) const
	Take the array of handle keys and for each key retrieve containers, then append them to the output vector.
const Acts::TrackSelector::Config &	getCuts (double eta) const
	Retrieves track selector configuration for given eta value.
std::vector< typename detail::RecoTrackContainer::TrackProxy >	doTwoWayTrackFinding (const detail::RecoTrackStateContainerProxy &firstMeasurement, const TrkProxy &trackProxy, detail::RecoTrackContainer &tracksContainerTemp, const TrackFinderOptions &options) const
	Perform two-way track finding.
BranchStopperResult	stopBranch (const detail::RecoTrackContainer::TrackProxy &track, const detail::RecoTrackContainer::TrackStateProxy &trackState, const Acts::TrackSelector::EtaBinnedConfig &trackSelectorCfg, const Acts::GeometryContext &tgContext, const detail::MeasurementIndex &measurementIndex, const std::size_t typeIndex, EventStats::value_type &event_stat_category_i) const
	Branch stopper.
void	checkCounts (const detail::RecoTrackContainer::TrackProxy &track) const
std::array< bool, 3 >	selectCounts (const detail::RecoTrackContainer::TrackProxy &track, double eta) const
bool	selectCountsFinal (const detail::RecoTrackContainer::TrackProxy &track) const
const Acts::Logger &	logger () const
	Private access to the logger.
void	initStatTables ()
void	copyStats (const EventStats &event_stat) const
void	printStatTables () const
std::size_t	nSeedCollections () const
std::size_t	seedCollectionStride () const
std::size_t	getStatCategory (std::size_t seed_collection, float eta) const
std::size_t	computeStatSum (std::size_t seed_collection, EStat counter_i, const EventStats &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.

Static Protected Member Functions
static xAOD::UncalibMeasType	measurementType (const detail::RecoTrackContainer::TrackStateProxy &trackState)
static void	addCountsAndProperties (detail::RecoTrackContainer &tracksContainer, bool add_counts)
static void	initCounts (const detail::RecoTrackContainer::TrackProxy &track)
static void	updateCounts (const detail::RecoTrackContainer::TrackProxy &track, Acts::ConstTrackStateTypeMap typeFlags, xAOD::UncalibMeasType detType)

Protected Attributes
struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig	m_measurementSelectorConfig
std::unique_ptr< CKF_pimpl >	m_trackFinder
ToolHandle< GenericMonitoringTool >	m_monTool {this, "MonTool", "", "Monitoring tool"}
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
ToolHandle< ActsTrk::TrackStatePrinterTool >	m_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}
ToolHandle< ActsTrk::IPixelOnTrackCalibratorTool< detail::RecoTrackStateContainer > >	m_pixelCalibTool {this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"}
ToolHandle< ActsTrk::IStripOnTrackCalibratorTool< detail::RecoTrackStateContainer > >	m_stripCalibTool {this, "StripCalibrator", "", "Opt. strip measurement calibrator"}
ToolHandle< ActsTrk::IHGTDOnTrackCalibratorTool< detail::RecoTrackStateContainer > >	m_hgtdCalibTool {this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"}
SG::WriteHandleKey< ActsTrk::TrackContainer >	m_trackContainerKey {this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"}
ActsTrk::MutableTrackContainerHandlesHelper	m_tracksBackendHandlesHelper {this}
ContextUtility	m_ctxProvider {this}
	Utility to fetch the geometry, magnetic field and calibration context in the event.
Gaudi::Property< unsigned int >	m_maxPropagationStep {this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"}
Gaudi::Property< std::vector< double > >	m_etaBins {this, "etaBins", {}, "bins in |eta| to specify variable selections"}
Gaudi::Property< std::vector< double > >	m_chi2CutOff {this, "chi2CutOff", {}, "MeasurementSelector: maximum local chi2 contribution"}
Gaudi::Property< std::vector< double > >	m_chi2OutlierCutOff {this, "chi2OutlierCutOff", {}, "MeasurementSelector: maximum local chi2 contribution for outlier"}
Gaudi::Property< std::vector< size_t > >	m_numMeasurementsCutOff {this, "numMeasurementsCutOff", {}, "MeasurementSelector: maximum number of associated measurements on a single surface"}
Gaudi::Property< double >	m_edgeHoleBorderWidth {this,"EdgeHoleBorderWidth", 0. ,"Width of the border of surfaces (mm) within which holes are not counted as holes."}
Gaudi::Property< std::vector< std::size_t > >	m_ptMinMeasurements {this, "ptMinMeasurements", {}, "if specified for the given seed collection, applies ptMin cut in branch stopper once ptMinMinMeasurements have been encountered"}
Gaudi::Property< std::vector< std::size_t > >	m_absEtaMaxMeasurements {this, "absEtaMaxMeasurements", {}, "if specified for the given seed collection, applies absEtaMax cut in branch stopper once absEtaMaxMeasurements have been encountered"}
Gaudi::Property< bool >	m_doBranchStopper {this, "doBranchStopper", true, "use branch stopper"}
Gaudi::Property< bool >	m_doTwoWay {this, "doTwoWay", true, "run CKF twice, first with forward propagation with smoothing, then with backward propagation"}
Gaudi::Property< bool >	m_recordMaterialStates {this, "recordMaterialStates", false, "record track states on surfaces which have material but no measurement; keeping them off is faster, but they have to be on for the multi-component stepper and for anything downstream which needs the full track state sequence"}
Gaudi::Property< bool >	m_inflateCovarianceTwoWay {this, "inflateCovarianceTwoWay", false, "inflate covariance matrix at the beginning of two-way track finding"}
Gaudi::Property< double >	m_twoWayinflateCovarianceFactor {this, "twoWayinflateCovarianceFactor", 1.0, "factor to multiply the initial covariance matrix at the beginning of two-way track finding"}
Gaudi::Property< double >	m_branchStopperPtMinFactor {this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"}
Gaudi::Property< double >	m_seedRefitPtMinFactor {this, "seedRefitPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the seed refit"}
Gaudi::Property< double >	m_branchStopperAbsEtaMaxExtra {this, "branchStopperAbsEtaMaxExtra", 0.0, "increase absEtaMax cut when used in the branch stopper"}
Gaudi::Property< double >	m_branchStopperMeasCutReduce {this, "branchStopperMeasCutReduce", 2, "how much to reduce the minMeas requirement for the branch stopper"}
Gaudi::Property< double >	m_branchStopperAbsEtaMeasCut {this, "branchStopperAbsEtaMeasCut", 1.2, "the minimum |eta| to apply the reduction to the minMeas requirement for the branch stopper"}
Gaudi::Property< std::vector< double > >	m_phiMin {this, "phiMin", {}, "TrackSelector: phiMin"}
Gaudi::Property< std::vector< double > >	m_phiMax {this, "phiMax", {}, "TrackSelector: phiMax"}
Gaudi::Property< std::vector< double > >	m_etaMin {this, "etaMin", {}, "TrackSelector: etaMin"}
Gaudi::Property< std::vector< double > >	m_etaMax {this, "etaMax", {}, "TrackSelector: etaMax"}
Gaudi::Property< double >	m_absEtaMin {this, "absEtaMin", 0.0, "TrackSelector: absEtaMin"}
Gaudi::Property< double >	m_absEtaMax {this, "absEtaMax", std::numeric_limits<double>::max(), "TrackSelector: absEtaMax"}
Gaudi::Property< std::vector< double > >	m_ptMin {this, "ptMin", {}, "TrackSelector: ptMin"}
Gaudi::Property< std::vector< double > >	m_ptMax {this, "ptMax", {}, "TrackSelector: ptMax"}
Gaudi::Property< std::vector< double > >	m_d0Min {this, "d0Min", {}, "TrackSelector: d0Min"}
Gaudi::Property< std::vector< double > >	m_d0Max {this, "d0Max", {}, "TrackSelector: d0Max"}
Gaudi::Property< std::vector< double > >	m_z0Min {this, "z0Min", {}, "TrackSelector: z0Min"}
Gaudi::Property< std::vector< double > >	m_z0Max {this, "z0Max", {}, "TrackSelector: z0Max"}
Gaudi::Property< std::vector< std::size_t > >	m_minMeasurements {this, "minMeasurements", {}, "TrackSelector: minMeasurements"}
Gaudi::Property< std::vector< std::size_t > >	m_maxHoles {this, "maxHoles", {}, "TrackSelector: maxHoles"}
Gaudi::Property< std::vector< std::size_t > >	m_maxOutliers {this, "maxOutliers", {}, "TrackSelector: maxOutliers"}
Gaudi::Property< std::vector< std::size_t > >	m_maxSharedHits {this, "maxSharedHits", {}, "TrackSelector: maxSharedHits"}
Gaudi::Property< std::vector< double > >	m_maxChi2 {this, "maxChi2", {}, "TrackSelector: maxChi2"}
Gaudi::Property< bool >	m_addCounts {this, "addCounts", true, "keep separate pixel, strip and hgtd counts and apply the following cuts"}
Gaudi::Property< bool >	m_checkCounts {this, "checkCounts", false, "check consistency among track state counts"}
Gaudi::Property< std::vector< std::size_t > >	m_minPixelHits {this, "minPixelHits", {}, "minimum number of pixel hits"}
Gaudi::Property< std::vector< std::size_t > >	m_minStripHits {this, "minStripHits", {}, "minimum number of strip hits"}
Gaudi::Property< std::vector< std::size_t > >	m_minHgtdHits {this, "minHgtdHits", {}, "minimum number of hgtd hits"}
Gaudi::Property< std::vector< std::size_t > >	m_maxPixelHoles {this, "maxPixelHoles", {}, "maximum number of pixel holes"}
Gaudi::Property< std::vector< std::size_t > >	m_maxStripHoles {this, "maxStripHoles", {}, "maximum number of strip holes"}
Gaudi::Property< std::vector< std::size_t > >	m_maxHgtdHoles {this, "maxHgtdHoles", {}, "maximum number of hgtd holes"}
Gaudi::Property< std::vector< std::size_t > >	m_maxPixelOutliers {this, "maxPixelOutliers", {}, "maximum number of pixel outliers"}
Gaudi::Property< std::vector< std::size_t > >	m_maxStripOutliers {this, "maxStripOutliers", {}, "maximum number of strip outliers"}
Gaudi::Property< std::vector< std::size_t > >	m_maxHgtdOutliers {this, "maxHgtdOutliers", {}, "maximum number of hgtd outliers"}
Gaudi::Property< std::vector< std::uint32_t > >	m_endOfWorldVolumeIds {this, "EndOfTheWorldVolumeIds", {}, ""}
Gaudi::Property< std::vector< float > >	m_statEtaBins {this, "StatisticEtaBins", {-4, -2.6, -2, 0, 2., 2.6, 4}, "Gather statistics separately for these bins."}
Gaudi::Property< std::vector< std::string > >	m_seedLabels {this, "SeedLabels", {}, "One label per seed key used in outputs"}
Gaudi::Property< bool >	m_dumpAllStatEtaBins {this, "DumpEtaBinsForAll", false, "Dump eta bins of all statistics counter."}
std::unique_ptr< const Acts::Logger >	m_logger
	logging instance
bool	m_useAbsEtaForStat = false
bool	m_showResolvedStats = false
std::mutex m_mutex	ATLAS_THREAD_SAFE
std::vector< std::array< std::size_t, kNStat > > m_stat	ATLAS_THREAD_SAFE {}

Static Protected Attributes
static constexpr BranchState	s_branchState {}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
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

Detailed Description

Definition at line 42 of file TrackFindingBaseAlg.h.

Member Typedef Documentation

BranchStopperResult

using ActsTrk::TrackFindingBaseAlg::BranchStopperResult = Acts::CombinatorialKalmanFilterBranchStopperResult

protected

Definition at line 259 of file TrackFindingBaseAlg.h.

EventStats

using ActsTrk::TrackFindingBaseAlg::EventStats = std::vector<std::array<unsigned int, kNStat>>

protected

Definition at line 179 of file TrackFindingBaseAlg.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TrackFinderOptions

using ActsTrk::TrackFindingBaseAlg::TrackFinderOptions = Acts::CombinatorialKalmanFilterOptions<detail::RecoTrackContainer>

protected

Definition at line 52 of file TrackFindingBaseAlg.h.

TrkProxy

using ActsTrk::TrackFindingBaseAlg::TrkProxy = detail::RecoTrackContainer::TrackProxy

protected

Definition at line 234 of file TrackFindingBaseAlg.h.

Member Enumeration Documentation

EStat

enum ActsTrk::TrackFindingBaseAlg::EStat : std::size_t

protected

Enumerator
kNTotalSeeds
kNoTrackParam
kNUsedSeeds
kNoTrack
kNDuplicateSeeds
kNNoEstimatedParams
kNOutputTracks
kNSeedRefitFailure
kNRejectedRefinedSeeds
kNSelectedTracks
kNStoppedTracksMaxHoles
kMultipleBranches
kNoSecond
kNStoppedTracksMinPt
kNStoppedTracksMaxEta
kNTotalSharedHits
kNForcedSeedMeasurements
kNResolvedTracks
kNStat

Definition at line 156 of file TrackFindingBaseAlg.h.

    {
      kNTotalSeeds,
      kNoTrackParam,
      kNUsedSeeds,
      kNoTrack,
      kNDuplicateSeeds,
      kNNoEstimatedParams,
      kNOutputTracks,
      kNSeedRefitFailure,
      kNRejectedRefinedSeeds,
      kNSelectedTracks,
      kNStoppedTracksMaxHoles,
      kMultipleBranches,
      kNoSecond,
      kNStoppedTracksMinPt,
      kNStoppedTracksMaxEta,
      kNTotalSharedHits,
      kNForcedSeedMeasurements,
      kNResolvedTracks,
      kNStat
    };

Constructor & Destructor Documentation

TrackFindingBaseAlg()

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

Definition at line 24 of file TrackFindingBaseAlg.cxx.

: AthReentrantAlgorithm(name, pSvcLocator) {}

~TrackFindingBaseAlg()

ActsTrk::TrackFindingBaseAlg::~TrackFindingBaseAlg ( )

default

Member Function Documentation

addCountsAndProperties()

void ActsTrk::TrackFindingBaseAlg::addCountsAndProperties ( detail::RecoTrackContainer & tracksContainer, bool add_counts )

staticprotected

Definition at line 410 of file TrackFindingBaseAlg.cxx.

  {
    if (addCounts) {
       tracksContainer.addColumn<unsigned int>("nPixelHits");
       tracksContainer.addColumn<unsigned int>("nStripHits");
       tracksContainer.addColumn<unsigned int>("nHgtdHits");
       tracksContainer.addColumn<unsigned int>("nPixelHoles");
       tracksContainer.addColumn<unsigned int>("nStripHoles");
       tracksContainer.addColumn<unsigned int>("nHgtdHoles");
       tracksContainer.addColumn<unsigned int>("nPixelOutliers");
       tracksContainer.addColumn<unsigned int>("nStripOutliers");
       tracksContainer.addColumn<unsigned int>("nHgtdOutliers");
    }
    ActsTrk::TrackContainerUtils::addFitterTypeProperty(tracksContainer);
  }

checkCounts()

void ActsTrk::TrackFindingBaseAlg::checkCounts ( const detail::RecoTrackContainer::TrackProxy & track ) const

protected

Definition at line 469 of file TrackFindingBaseAlg.cxx.

                                                                                             {
    // This check will fail if there are other types (HGTD, MS?) of hits, holes, or outliers.
    // The check can be removed when it is no longer appropriate.
    if (track.nMeasurements() != s_branchState.nPixelHits(track) + s_branchState.nStripHits(track) + s_branchState.nHgtdHits(track))
      ATH_MSG_WARNING("mismatched hit count: total (" << track.nMeasurements()
                      << ") != pixel (" << s_branchState.nPixelHits(track)
                      << ") + strip (" << s_branchState.nStripHits(track)
                      << ") + hgtd (" << s_branchState.nHgtdHits(track)
                      << ")");
    if (track.nHoles() != s_branchState.nPixelHoles(track) + s_branchState.nStripHoles(track) + s_branchState.nHgtdHoles(track))
      ATH_MSG_WARNING("mismatched hole count: total (" << track.nHoles()
                      << ") < pixel (" << s_branchState.nPixelHoles(track)
                      << ") + strip (" << s_branchState.nStripHoles(track)
                      << ") + hgtd (" << s_branchState.nHgtdHoles(track)
                      << ")");
    if (track.nOutliers() != s_branchState.nPixelOutliers(track) + s_branchState.nStripOutliers(track) + s_branchState.nHgtdOutliers(track))
      ATH_MSG_WARNING("mismatched outlier count: total (" << track.nOutliers()
                      << ") != pixel (" << s_branchState.nPixelOutliers(track)
                      << ") + strip (" << s_branchState.nStripOutliers(track)
                      << ") + hgtd (" << s_branchState.nHgtdOutliers(track)
                      << ")");
  };

computeStatSum()

std::size_t ActsTrk::TrackFindingBaseAlg::computeStatSum ( std::size_t seed_collection, EStat counter_i, const EventStats & stat ) const

protected

Definition at line 779 of file TrackFindingBaseAlg.cxx.

                                                                                                                        {
    std::size_t out = 0u;
    for (std::size_t category_i = seed_collection * seedCollectionStride();
         category_i < (seed_collection + 1) * seedCollectionStride();
         ++category_i)
    {
      assert(category_i < stat.size());
      out += stat[category_i][counter_i];
    }
    return out;
  }

copyStats()

void ActsTrk::TrackFindingBaseAlg::copyStats ( const EventStats & event_stat ) const

protected

Definition at line 565 of file TrackFindingBaseAlg.cxx.

                                                                        {
    std::lock_guard<std::mutex> lock(m_mutex);
    std::size_t category_i = 0;
    for (const std::array<unsigned int, kNStat> &src_stat : event_stat)
    {
      std::array<std::size_t, kNStat> &dest_stat = m_stat[category_i++];
      for (std::size_t i = 0; i < src_stat.size(); ++i)
      {
        assert(i < dest_stat.size());
        dest_stat[i] += src_stat[i];
      }
    }
  }

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; }

doTwoWayTrackFinding()

std::vector< typename detail::RecoTrackContainer::TrackProxy > ActsTrk::TrackFindingBaseAlg::doTwoWayTrackFinding ( const detail::RecoTrackStateContainerProxy & firstMeasurement, const TrkProxy & trackProxy, detail::RecoTrackContainer & tracksContainerTemp, const TrackFinderOptions & options ) const

protected

Perform two-way track finding.

Parameters

addTrack	Function or lambda which adds newly found track to container
trackProxy	Track proxy object
tracksContainerTemp	Track proxy container
options	Fit options
tgContext	Geometry context
reverseSearch	Flag for searching in reverse direction
seedType	Seed type (only used for warnings/debug printouts)
iseed	Seed number (only used for warnings/debug printouts)
itrack	Track number (only used for warnings/debug printouts)

Returns

Number of found tracks

Definition at line 242 of file TrackFindingBaseAlg.cxx.

                                                                                     {
    if (not m_doTwoWay) return {};
 
    // Create initial parameters for the propagation
    Acts::BoundTrackParameters secondInitialParameters = trackProxy.createParametersFromState(detail::RecoConstTrackStateContainerProxy{firstMeasurement});
    if (!secondInitialParameters.referenceSurface().insideBounds(secondInitialParameters.localPosition())) {  // #3751
      return {};
    }
 
    // First, inflate the covariance matrix if configured
    if (m_inflateCovarianceTwoWay) {
      ATH_MSG_DEBUG("Inflating covariance matrix for second track finding with factor = " << m_twoWayinflateCovarianceFactor.value());
      ATH_MSG_VERBOSE("Original parameters before inflation: \n" << secondInitialParameters);
 
      auto inflatedCovariance = secondInitialParameters.covariance().value();
      inflatedCovariance *= m_twoWayinflateCovarianceFactor;
 
      const auto& origSurface = secondInitialParameters.referenceSurface();
      auto surfacePtr = const_cast<Acts::Surface&>(origSurface).shared_from_this();
 
      Acts::BoundTrackParameters newParams(
          std::static_pointer_cast<const Acts::Surface>(std::move(surfacePtr)),
          secondInitialParameters.parameters(), 
          std::make_optional(inflatedCovariance),
          secondInitialParameters.particleHypothesis());
      secondInitialParameters = std::move(newParams);
      
      ATH_MSG_VERBOSE("Inflated covariance matrix : \n" << secondInitialParameters.covariance().value());
    }
 
    auto rootBranch = tracksContainerTemp.makeTrack();
    rootBranch.copyFromWithoutStates(trackProxy);  // #3534
 
    // perform track finding
    auto secondResult =
      trackFinder().ckf.findTracks(secondInitialParameters, options, tracksContainerTemp, rootBranch);
    if (not secondResult.ok()) {
      return {};
    }
    return secondResult.value();
  }

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

overridevirtual

Reimplemented in ActsTrk::HGTDTrackExtensionAlg, and ActsTrk::TrackFindingAlg.

Definition at line 170 of file TrackFindingBaseAlg.cxx.

                                                                    {
    ATH_MSG_FATAL("execute() method from the base class was called! Implement proper execute() method in the derived class!");
 
    return StatusCode::FAILURE;
  }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

extraOutputDeps()

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

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

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

filterPassed()

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

inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

finalize()

StatusCode ActsTrk::TrackFindingBaseAlg::finalize ( )

overridevirtual

Reimplemented in ActsTrk::TrackFindingAlg.

Definition at line 176 of file TrackFindingBaseAlg.cxx.

                                           {
    printStatTables();
 
    return StatusCode::SUCCESS;
  }

getContainersFromKeys()

template<class HandleArrayKeyType, class ContainerType>

StatusCode ActsTrk::TrackFindingBaseAlg::getContainersFromKeys ( const EventContext & ctx, HandleArrayKeyType & handleKeyArray, std::vector< const ContainerType * > & outputContainers, std::size_t & sum ) const

protected

Take the array of handle keys and for each key retrieve containers, then append them to the output vector.

Template Parameters

HandleArrayKeyType	Type of the list of handle keys
ContainerType	Type of the output container

Parameters

ctx	Event context
handleKeyArray	List of handle keys
outputContainers	Vector of output containers
sum	Number of total elements in all retrieved containers

Returns

Status code

getCuts()

const Acts::TrackSelector::Config & ActsTrk::TrackFindingBaseAlg::getCuts ( double eta ) const

protected

Retrieves track selector configuration for given eta value.

Parameters

eta	track candidate eta value

Definition at line 233 of file TrackFindingBaseAlg.cxx.

                                                                               {
    const auto &trackSelectorCfg = trackFinder().trackSelector.config();
    // return the last bin for |eta|>=4 or nan
    return (!(std::abs(eta) < trackSelectorCfg.absEtaEdges.back())) ? trackSelectorCfg.cutSets.back()
           : (std::abs(eta) < trackSelectorCfg.absEtaEdges.front()) ? trackSelectorCfg.cutSets.front()
                                                                    : trackSelectorCfg.getCuts(eta);
  };

getDefaultOptions()

TrackFindingBaseAlg::TrackFindingDefaultOptions ActsTrk::TrackFindingBaseAlg::getDefaultOptions ( const EventContext & ctx, const DetectorContextHolder & detContext, const detail::TrackFindingMeasurements & measurements, const Acts::PerigeeSurface * pSurface ) const

protected

Get CKF options for first and second pass + pointer to MeasurementSelector.

Parameters

detContext	Object holding detector-related context
measurements	<easurements container used in MeasurementSelector
pSurface	Raw pointer to perigee surface

Definition at line 203 of file TrackFindingBaseAlg.cxx.

                                                {
    Acts::PropagatorPlainOptions plainOptions{detContext.geometry, detContext.magField};
    plainOptions.maxSteps = m_maxPropagationStep;
    plainOptions.direction = Acts::Direction::Forward();
    plainOptions.endOfWorldVolumeIds = m_endOfWorldVolumeIds;
 
    // Set the CombinatorialKalmanFilter options
    TrackFinderOptions options(detContext.geometry, detContext.magField, detContext.calib,
                               trackFinder().ckfExtensions, plainOptions, pSurface);
    options.recordMaterialStates = m_recordMaterialStates;
 
    std::unique_ptr<ActsTrk::IMeasurementSelector> measurementSelector = setMeasurementSelector(ctx, measurements, options);
 
    Acts::PropagatorPlainOptions plainSecondOptions{detContext.geometry, detContext.magField};
    plainSecondOptions.maxSteps = m_maxPropagationStep;
    plainSecondOptions.direction = plainOptions.direction.invert();
 
    TrackFinderOptions secondOptions(detContext.geometry, detContext.magField, detContext.calib,
                                     options.extensions, plainSecondOptions, pSurface);
    secondOptions.targetSurface = pSurface;
    secondOptions.skipPrePropagationUpdate = true;
    secondOptions.recordMaterialStates = m_recordMaterialStates;
 
    return {std::move(options), std::move(secondOptions), std::move(measurementSelector)};
  };

getStatCategory()

std::size_t ActsTrk::TrackFindingBaseAlg::getStatCategory ( std::size_t seed_collection, float eta ) const

protected

Definition at line 770 of file TrackFindingBaseAlg.cxx.

                                                                                           {
    std::vector<float>::const_iterator bin_iter = std::upper_bound(m_statEtaBins.begin(),
                                                                   m_statEtaBins.end(),
                                                                   m_useAbsEtaForStat ? std::abs(eta) : eta);
    std::size_t category_i = seed_collection * seedCollectionStride() + static_cast<std::size_t>(bin_iter - m_statEtaBins.begin());
    assert(category_i < m_stat.size());
    return category_i;
  }

initCounts()

void ActsTrk::TrackFindingBaseAlg::initCounts ( const detail::RecoTrackContainer::TrackProxy & track )

staticprotected

Definition at line 426 of file TrackFindingBaseAlg.cxx.

  {
    s_branchState.nPixelHits(track) = 0;
    s_branchState.nStripHits(track) = 0;
    s_branchState.nHgtdHits(track) = 0;
    s_branchState.nPixelHoles(track) = 0;
    s_branchState.nStripHoles(track) = 0;
    s_branchState.nHgtdHoles(track) = 0;
    s_branchState.nPixelOutliers(track) = 0;
    s_branchState.nStripOutliers(track) = 0;
    s_branchState.nHgtdOutliers(track) = 0;
  }

initialize()

StatusCode ActsTrk::TrackFindingBaseAlg::initialize ( )

overridevirtual

Reimplemented in ActsTrk::HGTDTrackExtensionAlg, and ActsTrk::TrackFindingAlg.

Definition at line 28 of file TrackFindingBaseAlg.cxx.

                                             {
    ATH_MSG_DEBUG("Properties Summary:");
    ATH_MSG_DEBUG("   " << m_maxPropagationStep);
    ATH_MSG_DEBUG("   " << m_etaBins);
    ATH_MSG_DEBUG("   " << m_chi2CutOff);
    ATH_MSG_DEBUG("   " << m_chi2OutlierCutOff);
    ATH_MSG_DEBUG("   " << m_numMeasurementsCutOff);
    ATH_MSG_DEBUG("   " << m_ptMinMeasurements);
    ATH_MSG_DEBUG("   " << m_absEtaMaxMeasurements);
    ATH_MSG_DEBUG("   " << m_doBranchStopper);
    ATH_MSG_DEBUG("   " << m_addCounts);
    ATH_MSG_DEBUG("   " << m_checkCounts);
    ATH_MSG_DEBUG("   " << m_doTwoWay);
    ATH_MSG_DEBUG("   " << m_phiMin);
    ATH_MSG_DEBUG("   " << m_phiMax);
    ATH_MSG_DEBUG("   " << m_etaMin);
    ATH_MSG_DEBUG("   " << m_etaMax);
    ATH_MSG_DEBUG("   " << m_absEtaMin);
    ATH_MSG_DEBUG("   " << m_absEtaMax);
    ATH_MSG_DEBUG("   " << m_ptMin);
    ATH_MSG_DEBUG("   " << m_ptMax);
    ATH_MSG_DEBUG("   " << m_d0Min);
    ATH_MSG_DEBUG("   " << m_d0Max);
    ATH_MSG_DEBUG("   " << m_z0Min);
    ATH_MSG_DEBUG("   " << m_z0Max);
    ATH_MSG_DEBUG("   " << m_minMeasurements);
    ATH_MSG_DEBUG("   " << m_minPixelHits);
    ATH_MSG_DEBUG("   " << m_minStripHits);
    ATH_MSG_DEBUG("   " << m_maxHoles);
    ATH_MSG_DEBUG("   " << m_maxPixelHoles);
    ATH_MSG_DEBUG("   " << m_maxStripHoles);
    ATH_MSG_DEBUG("   " << m_maxOutliers);
    ATH_MSG_DEBUG("   " << m_maxPixelOutliers);
    ATH_MSG_DEBUG("   " << m_maxStripOutliers);
    ATH_MSG_DEBUG("   " << m_maxSharedHits);
    ATH_MSG_DEBUG("   " << m_maxChi2);
    ATH_MSG_DEBUG("   " << m_branchStopperPtMinFactor);
    ATH_MSG_DEBUG("   " << m_seedRefitPtMinFactor);
    ATH_MSG_DEBUG("   " << m_branchStopperAbsEtaMaxExtra);
    ATH_MSG_DEBUG("   " << m_branchStopperMeasCutReduce);
    ATH_MSG_DEBUG("   " << m_branchStopperAbsEtaMeasCut);
    ATH_MSG_DEBUG("   " << m_endOfWorldVolumeIds);
 
    m_logger = makeActsAthenaLogger(this, "Acts");
 
    // Read and Write handles
    ATH_CHECK(m_trackContainerKey.initialize());
    ATH_CHECK(m_tracksBackendHandlesHelper.initialize(ActsTrk::prefixFromTrackContainerName(m_trackContainerKey.key())));
 
    ATH_CHECK(m_monTool.retrieve(EnableTool{not m_monTool.empty()}));
    ATH_CHECK(m_trackingGeometrySvc.retrieve());
    ATH_CHECK(m_ctxProvider.initialize());
    ATH_CHECK(m_trackStatePrinter.retrieve(EnableTool{not m_trackStatePrinter.empty()}));
    ATH_CHECK(m_pixelCalibTool.retrieve(EnableTool{not m_pixelCalibTool.empty()}));
    ATH_CHECK(m_stripCalibTool.retrieve(EnableTool{not m_stripCalibTool.empty()}));
    ATH_CHECK(m_hgtdCalibTool.retrieve(EnableTool{not m_hgtdCalibTool.empty()}));
 
    auto magneticField = std::make_unique<ATLASMagneticFieldWrapper>();
    auto trackingGeometry = m_trackingGeometrySvc->trackingGeometry();
 
    detail::Stepper stepper(std::move(magneticField));
    detail::Navigator::Config config{std::move(trackingGeometry)};
    config.resolvePassive = false;
    config.resolveMaterial = true;
    config.resolveSensitive = true;
    detail::Navigator navigator(std::move(config), logger().cloneWithSuffix("Navigator"));
    detail::Propagator propagator(std::move(stepper), std::move(navigator), logger().cloneWithSuffix("Prop"));
 
    // Using the CKF propagator as extrapolator
    detail::Extrapolator extrapolator = propagator;
 
    // m_etaBins (from flags.Tracking.ActiveConfig.etaBins) includes a dummy first and last bin, which we ignore
    std::vector<double> absEtaEdges;
    if (m_etaBins.size() <= 2)
    {
      absEtaEdges.reserve(2ul);
      absEtaEdges.push_back(0.0);
      absEtaEdges.push_back(std::numeric_limits<double>::infinity());
    }
    else
    {
      absEtaEdges.reserve(m_etaBins.size());
      absEtaEdges.push_back(m_absEtaMin);
      absEtaEdges.insert(absEtaEdges.end(), m_etaBins.begin() + 1, m_etaBins.end() - 1);
      absEtaEdges.push_back(m_absEtaMax);
    }
 
    auto setCut = [](auto &cfgVal, const auto &cuts, size_t ind) -> void
    {
      if (cuts.empty())
        return;
      cfgVal = (ind < cuts.size()) ? cuts[ind] : cuts[cuts.size() - 1];
    };
 
    Acts::TrackSelector::EtaBinnedConfig trackSelectorCfg{std::move(absEtaEdges)};
    if (m_etaBins.size() <= 2)
    {
      assert(trackSelectorCfg.cutSets.size() == 1);
      trackSelectorCfg.cutSets[0].absEtaMin = m_absEtaMin;
      trackSelectorCfg.cutSets[0].absEtaMax = m_absEtaMax;
    }
    size_t cutIndex = 0;
    for (auto &cfg : trackSelectorCfg.cutSets)
    {
      setCut(cfg.phiMin, m_phiMin, cutIndex);
      setCut(cfg.phiMax, m_phiMax, cutIndex);
      setCut(cfg.etaMin, m_etaMin, cutIndex);
      setCut(cfg.etaMax, m_etaMax, cutIndex);
      setCut(cfg.ptMin, m_ptMin, cutIndex);
      setCut(cfg.ptMax, m_ptMax, cutIndex);
      setCut(cfg.loc0Min, m_d0Min, cutIndex);
      setCut(cfg.loc0Max, m_d0Max, cutIndex);
      setCut(cfg.loc1Min, m_z0Min, cutIndex);
      setCut(cfg.loc1Max, m_z0Max, cutIndex);
      setCut(cfg.minMeasurements, m_minMeasurements, cutIndex);
      setCut(cfg.maxHoles, m_maxHoles, cutIndex);
      setCut(cfg.maxOutliers, m_maxOutliers, cutIndex);
      setCut(cfg.maxSharedHits, m_maxSharedHits, cutIndex);
      setCut(cfg.maxChi2, m_maxChi2, cutIndex);
      ++cutIndex;
    }
 
    ATH_MSG_DEBUG(trackSelectorCfg);
 
    // initializer measurement selector and connect it to the delegates of the track finder optins
    ATH_CHECK(initializeMeasurementSelector());
 
    detail::CKF_config ckfConfig{
        std::move(extrapolator),
        detail::CKF{std::move(propagator), logger().cloneWithSuffix("CKF")},
        {},
        Acts::TrackSelector{trackSelectorCfg}};
 
    m_trackFinder = std::make_unique<CKF_pimpl>(std::move(ckfConfig));
 
    trackFinder().ckfExtensions.updater.connect<&ActsTrk::detail::FitterHelperFunctions::gainMatrixUpdate<detail::RecoTrackStateContainer>>();
 
    initStatTables();
 
    return StatusCode::SUCCESS;
  }

initializeMeasurementSelector()

StatusCode ActsTrk::TrackFindingBaseAlg::initializeMeasurementSelector ( )

protected

Definition at line 518 of file TrackFindingBaseAlg.cxx.

                                                                {
    std::vector<std::pair<float, float> > &chi2CutOffOutlier = m_measurementSelectorConfig.m_chi2CutOffOutlier;
    chi2CutOffOutlier .reserve( m_chi2CutOff.size() );
    if (!m_chi2OutlierCutOff.empty()) {
       if (m_chi2CutOff.size() !=  m_chi2OutlierCutOff.size()) {
          ATH_MSG_ERROR("Outlier chi2 cut off provided but number of elements does not agree with"
                        " chi2 cut off for measurements which however is required: "
                        << m_chi2CutOff.size() << " != " <<  m_chi2OutlierCutOff.size());
          return StatusCode::FAILURE;
       }
    }
    unsigned int idx=0;
    for (const auto &elm : m_chi2CutOff) {
       chi2CutOffOutlier.push_back( std::make_pair(static_cast<float>(elm),
                                                   idx < m_chi2OutlierCutOff.size()
                                                   ? static_cast<float>(m_chi2OutlierCutOff[idx])
                                                   : std::numeric_limits<float>::max()) );
       ++idx;
    }
    if (m_etaBins.size() > 2) {
      std::vector<float> &etaBinsf = m_measurementSelectorConfig.m_etaBins;
      etaBinsf.assign(m_etaBins.begin() + 1, m_etaBins.end() - 1);
    }
 
    return /*m_measurementSelector ?*/ StatusCode::SUCCESS /*: StatusCode::FAILURE*/;
  }

initStatTables()

void ActsTrk::TrackFindingBaseAlg::initStatTables ( )

protected

Definition at line 547 of file TrackFindingBaseAlg.cxx.

                                           {
    if (!m_statEtaBins.empty())
    {
      m_useAbsEtaForStat = (m_statEtaBins[0] > 0.);
      float last_eta = m_statEtaBins[0];
      for (float eta : m_statEtaBins)
      {
        if (eta < last_eta)
        {
          ATH_MSG_FATAL("Eta bins for statistics counter not in ascending order.");
        }
        last_eta = eta;
      }
    }
    m_stat.resize(nSeedCollections() * seedCollectionStride());
  }

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

isClonable()

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

inlineoverridevirtualinherited

Specify if the algorithm is clonable.

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

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

Definition at line 68 of file AthCommonAlgorithm.h.

                                           {
    return true;
  }

logger()

const Acts::Logger & ActsTrk::TrackFindingBaseAlg::logger ( ) const

inlineprotected

Private access to the logger.

Definition at line 306 of file TrackFindingBaseAlg.h.

    {
      return *m_logger;
    }

measurementType()

xAOD::UncalibMeasType ActsTrk::TrackFindingBaseAlg::measurementType ( const detail::RecoTrackContainer::TrackStateProxy & trackState )

staticprotected

Definition at line 287 of file TrackFindingBaseAlg.cxx.

                                                                                                                     {
    if (trackState.hasReferenceSurface()) {
      if (const auto *actsDetElem = dynamic_cast<const ISurfacePlacement*>(trackState.referenceSurface().surfacePlacement())) {
        switch (actsDetElem->detectorType()) {
        case DetectorType::Pixel:
          return xAOD::UncalibMeasType::PixelClusterType;
        case DetectorType::Sct:
          return xAOD::UncalibMeasType::StripClusterType;
        case DetectorType::Hgtd:
          return xAOD::UncalibMeasType::HGTDClusterType;
        default:
          break;
        }
      }
    }
    return xAOD::UncalibMeasType::Other;
  }

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);
  }

nSeedCollections()

std::size_t ActsTrk::TrackFindingBaseAlg::nSeedCollections ( ) const

inlineprotected

Definition at line 319 of file TrackFindingBaseAlg.h.

                                       {
      return m_seedLabels.size();
    }

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.

printStatTables()

void ActsTrk::TrackFindingBaseAlg::printStatTables ( ) const

protected

Definition at line 580 of file TrackFindingBaseAlg.cxx.

                                                  {
    if (msgLvl(MSG::INFO))
    {
      std::vector<std::string> stat_labels =
          TableUtils::makeLabelVector(kNStat,
                                      {
                                          std::make_pair(kNTotalSeeds, "Input seeds"),
                                          std::make_pair(kNoTrackParam, "No track parameters"),
                                          std::make_pair(kNUsedSeeds, "Used   seeds"),
                                          std::make_pair(kNoTrack, "Cannot find track"),
                                          std::make_pair(kNDuplicateSeeds, "Duplicate seeds"),
                                          std::make_pair(kNNoEstimatedParams, "Initial param estimation failed"),
                                          std::make_pair(kNRejectedRefinedSeeds, "Rejected refined parameters"),
                                          std::make_pair(kNSeedRefitFailure, "Seed refit Kalman fit failure"),
                                          std::make_pair(kNOutputTracks, "CKF tracks"),
                                          std::make_pair(kNSelectedTracks, "selected tracks"),
                                          std::make_pair(kNResolvedTracks, "resolved tracks"),
                                          std::make_pair(kNStoppedTracksMaxHoles, "Stopped tracks reaching max holes"),
                                          std::make_pair(kMultipleBranches, "Seeds with more than one branch"),
                                          std::make_pair(kNoSecond, "Tracks failing second CKF"),
                                          std::make_pair(kNStoppedTracksMinPt, "Stopped tracks below pT cut"),
                                          std::make_pair(kNStoppedTracksMaxEta, "Stopped tracks above max eta"),
                                          std::make_pair(kNTotalSharedHits, "Total shared hits"),
                                          std::make_pair(kNForcedSeedMeasurements, "Total forced measurements")
                                      });
      assert(stat_labels.size() == kNStat);
      std::vector<std::string> categories;
      categories.reserve(m_seedLabels.size() + 1);
      categories.insert(categories.end(), m_seedLabels.begin(), m_seedLabels.end());
      categories.push_back("ALL");
 
      std::vector<std::string> eta_labels;
      eta_labels.reserve(m_statEtaBins.size() + 2);
      for (std::size_t eta_bin_i = 0; eta_bin_i < m_statEtaBins.size() + 2; ++eta_bin_i)
      {
        eta_labels.push_back(TableUtils::makeEtaBinLabel(m_statEtaBins, eta_bin_i, m_useAbsEtaForStat));
      }
 
      // vector used as 3D array stat[ eta_bin ][ stat_i ][ seed_type]
      // stat_i = [0, kNStat)
      // eta_bin = [0, m_statEtaBins.size()+2 ); eta_bin == m_statEtaBinsSize()+1 means sum of all etaBins
      // seed_type = [0, nSeedCollections()+1)  seed_type == nSeedCollections() means sum of all seed collections
      std::vector<std::size_t> stat =
          TableUtils::createCounterArrayWithProjections<std::size_t>(nSeedCollections(),
                                                                     m_statEtaBins.size() + 1,
                                                                     m_stat);
 
      // the extra columns and rows for the projections are addeded internally:
      std::size_t stat_stride =
          TableUtils::counterStride(nSeedCollections(),
                                    m_statEtaBins.size() + 1,
                                    kNStat);
      std::size_t eta_stride =
          TableUtils::subCategoryStride(nSeedCollections(),
                                        m_statEtaBins.size() + 1,
                                        kNStat);
      std::stringstream table_out;
 
      if (m_dumpAllStatEtaBins.value())
      {
        // dump for each counter a table with one row per eta bin
        std::size_t max_label_width = TableUtils::maxLabelWidth(stat_labels) + TableUtils::maxLabelWidth(eta_labels);
        for (std::size_t stat_i = 0; stat_i < kNStat; ++stat_i)
        {
          std::size_t dest_idx_offset = stat_i * stat_stride;
          table_out << makeTable(stat, dest_idx_offset, eta_stride,
                                 eta_labels,
                                 categories)
                           .columnWidth(10)
                           // only dump the footer for the last eta bin i.e. total
                           .dumpHeader(stat_i == 0)
                           .dumpFooter(stat_i + 1 == kNStat)
                           .separateLastRow(true) // separate the sum of all eta bins
                           .minLabelWidth(max_label_width)
                           .labelPrefix(stat_labels.at(stat_i));
        }
      }
      else
      {
        // dump one table with one row per counter showing the total eta range
        for (std::size_t eta_bin_i = (m_dumpAllStatEtaBins.value() ? 0 : m_statEtaBins.size() + 1);
             eta_bin_i < m_statEtaBins.size() + 2;
             ++eta_bin_i)
        {
          std::size_t dest_idx_offset = eta_bin_i * eta_stride;
          table_out << makeTable(stat, dest_idx_offset, stat_stride,
                                 stat_labels,
                                 categories,
                                 eta_labels.at(eta_bin_i))
                           .columnWidth(10)
                           // only dump the footer for the last eta bin i.e. total
                           .dumpFooter(!m_dumpAllStatEtaBins.value() || eta_bin_i == m_statEtaBins.size() + 1);
        }
      }
      ATH_MSG_INFO("statistics:\n"
                   << table_out.str());
      table_out.str("");
 
      // define retios first element numerator, second element denominator
      // each element contains a vector of counter and a multiplier e.g. +- 1
      // ratios are computed as  (sum_i stat[stat_i] *  multiplier_i ) / (sum_j stat[stat_j] *  multiplier_j )
      auto [ratio_labels, ratio_def] =
          TableUtils::splitRatioDefinitionsAndLabels({TableUtils::makeRatioDefinition("failed / seeds ",
                                                                                      std::vector<TableUtils::SummandDefinition>{
                                                                                          TableUtils::defineSummand(kNTotalSeeds, 1),
                                                                                          TableUtils::defineSummand(kNUsedSeeds, -1),
                                                                                          TableUtils::defineSummand(kNDuplicateSeeds, -1),
                                                                                          // no track counted  as used but want to include it as failed
                                                                                          TableUtils::defineSummand(kNoTrack, 1),
                                                                                      }, // failed seeds i.e. seeds which are not duplicates but did not produce a track
                                                                                      std::vector<TableUtils::SummandDefinition>{TableUtils::defineSummand(kNTotalSeeds, 1)}),
                                                      TableUtils::defineSimpleRatio("duplication / seeds", kNDuplicateSeeds, kNTotalSeeds),
                                                      TableUtils::defineSimpleRatio("Rejected refined params / seeds", kNRejectedRefinedSeeds, kNTotalSeeds),
                                                      TableUtils::defineSimpleRatio("selected / CKF tracks", kNSelectedTracks, kNOutputTracks),
                                                      TableUtils::defineSimpleRatio("selected tracks / used seeds", kNSelectedTracks, kNUsedSeeds),
                                                      TableUtils::defineSimpleRatio("resolved / selected tracks", kNResolvedTracks, kNSelectedTracks),
                                                      TableUtils::defineSimpleRatio("resolved tracks / used seeds", kNResolvedTracks, kNUsedSeeds),
                                                      TableUtils::defineSimpleRatio("branched tracks / used seeds", kMultipleBranches, kNUsedSeeds),
                                                      TableUtils::defineSimpleRatio("no 2nd CKF / CKF tracks", kNoSecond, kNOutputTracks),
                                                      TableUtils::defineSimpleRatio("shared hits / CKF tracks", kNTotalSharedHits, kNOutputTracks),
                                                      TableUtils::defineSimpleRatio("forced measurements / used seeds", kNForcedSeedMeasurements, kNUsedSeeds)});
 
      std::vector<float> ratio = TableUtils::computeRatios(ratio_def,
                                                           nSeedCollections() + 1,
                                                           m_statEtaBins.size() + 2,
                                                           stat);
 
      // the extra columns and rows for the projections are _not_ added internally
      std::size_t ratio_stride = TableUtils::ratioStride(nSeedCollections() + 1,
                                                         m_statEtaBins.size() + 2,
                                                         ratio_def);
      std::size_t ratio_eta_stride = TableUtils::subCategoryStride(nSeedCollections() + 1,
                                                                   m_statEtaBins.size() + 2,
                                                                   ratio_def);
 
      std::size_t max_label_width = TableUtils::maxLabelWidth(ratio_labels) + TableUtils::maxLabelWidth(eta_labels);
      if (m_dumpAllStatEtaBins.value())
      {
        // show for each ratio a table with one row per eta bin
        for (std::size_t ratio_i = 0; ratio_i < ratio_labels.size(); ++ratio_i)
        {
          table_out << makeTable(ratio,
                                 ratio_i * ratio_stride,
                                 ratio_eta_stride,
                                 eta_labels,
                                 categories)
                           .columnWidth(10)
                           // only dump the footer for the last eta bin i.e. total
                           .dumpHeader(ratio_i == 0)
                           .dumpFooter(ratio_i + 1 == ratio_labels.size())
                           .separateLastRow(true) // separate the sum of las
                           .minLabelWidth(max_label_width)
                           .labelPrefix(ratio_labels.at(ratio_i));
        }
      }
      else
      {
        // dump one table with one row per ratio showing  the total eta range
        table_out << makeTable(ratio,
                               (m_statEtaBins.size() + 1) * ratio_eta_stride + 0 * ratio_stride,
                               ratio_stride,
                               ratio_labels,
                               categories)
                         .columnWidth(10)
                         // only dump the footer for the last eta bin i.e. total
                         .minLabelWidth(max_label_width)
                         .dumpFooter(false);
 
        // also dump a table for final tracks over used seeds (ratio_i==6 or 4) showing one row per eta bin
        eta_labels.erase(eta_labels.end() - 1); // drop last line of table which shows again all eta bins summed.
        std::size_t ratio_i = m_showResolvedStats ? 6 : 4;
        table_out << makeTable(ratio,
                               ratio_i * ratio_stride,
                               ratio_eta_stride,
                               eta_labels,
                               categories)
                         .columnWidth(10)
                         .dumpHeader(false)
                         // only dump the footer for the last eta bin i.e. total
                         .dumpFooter(!m_dumpAllStatEtaBins.value() || ratio_i + 1 == ratio_labels.size())
                         .separateLastRow(false)
                         .minLabelWidth(max_label_width)
                         .labelPrefix(ratio_labels.at(ratio_i));
      }
 
      ATH_MSG_INFO("Ratios:\n"
                   << table_out.str());
    }
  }

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();
  }

seedCollectionStride()

std::size_t ActsTrk::TrackFindingBaseAlg::seedCollectionStride ( ) const

inlineprotected

Definition at line 322 of file TrackFindingBaseAlg.h.

                                           {
      return m_statEtaBins.size() + 1;
    }

selectCounts()

std::array< bool, 3 > ActsTrk::TrackFindingBaseAlg::selectCounts ( const detail::RecoTrackContainer::TrackProxy & track, double eta ) const

protected

Definition at line 492 of file TrackFindingBaseAlg.cxx.

                                                                                                                       {
    bool enoughMeasurements = true, tooManyHoles = false, tooManyOutliers = false;
    const auto &trackSelectorCfg = trackFinder().trackSelector.config();
    std::size_t etaBin = (std::abs(eta) < trackSelectorCfg.absEtaEdges.front())   ? 0
                         : (std::abs(eta) >= trackSelectorCfg.absEtaEdges.back()) ? trackSelectorCfg.absEtaEdges.size() - 1
                                                                                  : trackSelectorCfg.binIndex(eta);
    auto cutMin = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
      return !cutSet.empty() && (val < (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
    };
    auto cutMax = [etaBin](std::size_t val, const std::vector<std::size_t> &cutSet) {
      return !cutSet.empty() && (val > (etaBin < cutSet.size() ? cutSet[etaBin] : cutSet.back()));
    };
 
    enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nPixelHits(track), m_minPixelHits);
    enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nStripHits(track), m_minStripHits);
    enoughMeasurements = enoughMeasurements && !cutMin(s_branchState.nHgtdHits(track), m_minHgtdHits);
    tooManyHoles = tooManyHoles || cutMax(s_branchState.nPixelHoles(track), m_maxPixelHoles);
    tooManyHoles = tooManyHoles || cutMax(s_branchState.nStripHoles(track), m_maxStripHoles);
    tooManyHoles = tooManyHoles || cutMax(s_branchState.nHgtdHoles(track), m_maxHgtdHoles);
    tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nPixelOutliers(track), m_maxPixelOutliers);
    tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nStripOutliers(track), m_maxStripOutliers);
    tooManyOutliers = tooManyOutliers || cutMax(s_branchState.nHgtdOutliers(track), m_maxHgtdOutliers);
 
    return {enoughMeasurements, tooManyHoles, tooManyOutliers};
  }

selectCountsFinal()

bool ActsTrk::TrackFindingBaseAlg::selectCountsFinal ( const detail::RecoTrackContainer::TrackProxy & track ) const

protected

Definition at line 791 of file TrackFindingBaseAlg.cxx.

                                                                                                   {
    if (not m_addCounts) return true;
    double eta = -std::log(std::tan(0.5 * track.theta()));
    auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] = selectCounts(track, eta);
    return enoughMeasurementsPS && !tooManyHolesPS && !tooManyOutliersPS;
  }

setFilterPassed()

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

inlinevirtualinherited

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

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

setMeasurementSelector()

std::unique_ptr< ActsTrk::IMeasurementSelector > ActsTrk::TrackFindingBaseAlg::setMeasurementSelector ( const EventContext & ctx, const detail::TrackFindingMeasurements & measurements, TrackFinderOptions & options ) const

nodiscardprotected

Setup and attach measurement selector to KF options.

Parameters

ctx	the current event context
measurements	measurements container used in MeasurementSelector
options	Kalman filter options

Returns

unique_ptr to MeasurementSelector

Definition at line 182 of file TrackFindingBaseAlg.cxx.

                                         {
 
    std::unique_ptr<ActsTrk::IMeasurementSelector> measurementSelector = ActsTrk::detail::getMeasurementSelector(
        ctx,
        m_pixelCalibTool.isEnabled() ? &(*m_pixelCalibTool) : nullptr,
        m_stripCalibTool.isEnabled() ? &(*m_stripCalibTool) : nullptr,
        m_hgtdCalibTool.isEnabled() ? &(*m_hgtdCalibTool) : nullptr,
        measurements.measurementRanges(),
        m_measurementSelectorConfig.m_etaBins,
        m_measurementSelectorConfig.m_chi2CutOffOutlier,
        m_numMeasurementsCutOff.value(),
        m_edgeHoleBorderWidth.value());
 
    measurementSelector->connect(&options.extensions.createTrackStates);
 
    return measurementSelector;
  }

stopBranch()

TrackFindingBaseAlg::BranchStopperResult ActsTrk::TrackFindingBaseAlg::stopBranch ( const detail::RecoTrackContainer::TrackProxy & track, const detail::RecoTrackContainer::TrackStateProxy & trackState, const Acts::TrackSelector::EtaBinnedConfig & trackSelectorCfg, const Acts::GeometryContext & tgContext, const detail::MeasurementIndex & measurementIndex, const std::size_t typeIndex, EventStats::value_type & event_stat_category_i ) const

protected

Branch stopper.

Parameters

track	Track proxy object
trackState	Track state proxy object
trackSelectorCfg	Track selector configuration
tgContext	Geometry context
measurementIndex	Measurement index
typeIndex	Type index
event_stat_category_i	Event statistics for current category

Returns

BranchStopperResult

Definition at line 305 of file TrackFindingBaseAlg.cxx.

                                                         {
    if (m_addCounts) {
      updateCounts(track, trackState.typeFlags(),
                   measurementType(trackState));
      if (m_checkCounts) {
        checkCounts(track);
      }
    }
 
    if (m_trackStatePrinter.isSet()) {
      m_trackStatePrinter->printTrackState(tgContext, trackState,
                                           measurementIndex, true);
    }
 
    if (!m_doBranchStopper) {
      return BranchStopperResult::Continue;
    }
 
    const auto &parameters = trackState.hasFiltered() ? trackState.filtered()
                                                      : trackState.predicted();
    double eta = -std::log(std::tan(0.5 * parameters[Acts::eBoundTheta]));
    const auto &cutSet = getCuts(eta);
 
    if (typeIndex < m_ptMinMeasurements.size() &&
        !(track.nMeasurements() < m_ptMinMeasurements[typeIndex])) {
      double pT = std::sin(parameters[Acts::eBoundTheta]) /
                  parameters[Acts::eBoundQOverP];
      if (std::abs(pT) < cutSet.ptMin * m_branchStopperPtMinFactor) {
        ++event_stat_category_i[kNStoppedTracksMinPt];
        ATH_MSG_DEBUG("CkfBranchStopper: drop branch with q*pT="
                      << pT << " after " << track.nMeasurements()
                      << " measurements");
        return BranchStopperResult::StopAndDrop;
      }
    }
 
    if (typeIndex < m_absEtaMaxMeasurements.size() &&
        !(track.nMeasurements() < m_absEtaMaxMeasurements[typeIndex]) &&
        !(std::abs(eta) < trackSelectorCfg.absEtaEdges.back() +
                              m_branchStopperAbsEtaMaxExtra)) {
      ++event_stat_category_i[kNStoppedTracksMaxEta];
      ATH_MSG_DEBUG("CkfBranchStopper: drop branch with eta="
                    << eta << " after " << track.nMeasurements()
                    << " measurements");
      return BranchStopperResult::StopAndDrop;
    }
 
 
    // In the pixel endcap regions relax the requirement for minMeasurements before cutting the branch off
    auto minMeasurementsBranchStop = std::abs(eta) > m_branchStopperAbsEtaMeasCut ? cutSet.minMeasurements - m_branchStopperMeasCutReduce : cutSet.minMeasurements;
    bool enoughMeasurements = (track.nMeasurements() >= minMeasurementsBranchStop);
    bool tooManyHoles = (track.nHoles() > cutSet.maxHoles);
    bool tooManyOutliers = (track.nOutliers() > cutSet.maxOutliers);
 
    if (m_addCounts) {
      auto [enoughMeasurementsPS, tooManyHolesPS, tooManyOutliersPS] =
          selectCounts(track, eta);
      enoughMeasurements = enoughMeasurements && enoughMeasurementsPS;
      tooManyHoles = tooManyHoles || tooManyHolesPS;
      tooManyOutliers = tooManyOutliers || tooManyOutliersPS;
    }
 
    if (!(tooManyHoles || tooManyOutliers)) {
      return BranchStopperResult::Continue;
    }
 
    if (!enoughMeasurements) {
      ++event_stat_category_i[kNStoppedTracksMaxHoles];
    }
 
    if (m_addCounts) {
      ATH_MSG_DEBUG("CkfBranchStopper: stop and "
                    << (enoughMeasurements ? "keep" : "drop")
                    << " branch with nHoles=" << track.nHoles() << " ("
                    << s_branchState.nPixelHoles(track) << " pixel+"
                    << s_branchState.nStripHoles(track) << " strip+"
                    << s_branchState.nHgtdHoles(track)
                    << " hgtd), nOutliers=" << track.nOutliers() << " ("
                    << s_branchState.nPixelOutliers(track) << "+"
                    << s_branchState.nStripOutliers(track) << "+"
                    << s_branchState.nHgtdOutliers(track)
                    << "), nMeasurements=" << track.nMeasurements() << " ("
                    << s_branchState.nPixelHits(track) << "+"
                    << s_branchState.nStripHits(track) << "+"
                    << s_branchState.nHgtdHits(track) << ")");
    } else {
      ATH_MSG_DEBUG("CkfBranchStopper: stop and "
                    << (enoughMeasurements ? "keep" : "drop")
                    << " branch with nHoles=" << track.nHoles()
                    << ", nOutliers=" << track.nOutliers()
                    << ", nMeasurements=" << track.nMeasurements());
    }
 
    return enoughMeasurements ? BranchStopperResult::StopAndKeep
                              : BranchStopperResult::StopAndDrop;
  }

sysExecute()

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

overridevirtualinherited

Execute an algorithm.

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

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

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

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

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

Definition at line 60 of file AthCommonAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

trackFinder() [1/2]

TrackFindingBaseAlg::CKF_pimpl & ActsTrk::TrackFindingBaseAlg::trackFinder ( )

protected

Definition at line 21 of file TrackFindingBaseAlg.cxx.

{ return *m_trackFinder; }

trackFinder() [2/2]

const TrackFindingBaseAlg::CKF_pimpl & ActsTrk::TrackFindingBaseAlg::trackFinder ( ) const

protected

Definition at line 22 of file TrackFindingBaseAlg.cxx.

{ return *m_trackFinder; }

updateCounts()

void ActsTrk::TrackFindingBaseAlg::updateCounts ( const detail::RecoTrackContainer::TrackProxy & track, Acts::ConstTrackStateTypeMap typeFlags, xAOD::UncalibMeasType detType )

staticprotected

Definition at line 439 of file TrackFindingBaseAlg.cxx.

                                                                         {
    if (detType == xAOD::UncalibMeasType::PixelClusterType) {
      if (typeFlags.isHole()) {
        s_branchState.nPixelHoles(track)++;
      } else if (typeFlags.isOutlier()) {
        s_branchState.nPixelOutliers(track)++;
      } else if (typeFlags.isMeasurement()) {
        s_branchState.nPixelHits(track)++;
      }
    } else if (detType == xAOD::UncalibMeasType::StripClusterType) {
      if (typeFlags.isHole()) {
        s_branchState.nStripHoles(track)++;
      } else if (typeFlags.isOutlier()) {
        s_branchState.nStripOutliers(track)++;
      } else if (typeFlags.isMeasurement()) {
        s_branchState.nStripHits(track)++;
      }
    } else if (detType == xAOD::UncalibMeasType::HGTDClusterType) {
      if (typeFlags.isHole()) {
        s_branchState.nHgtdHoles(track)++;
      } else if (typeFlags.isOutlier()) {
        s_branchState.nHgtdOutliers(track)++;
      } else if (typeFlags.isMeasurement()) {
        s_branchState.nHgtdHits(track)++;
      }
    }
  }

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);
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

std::vector<std::array<std::size_t, kNStat> > m_stat ActsTrk::TrackFindingBaseAlg::ATLAS_THREAD_SAFE {}

mutableprotected

Definition at line 331 of file TrackFindingBaseAlg.h.

{};

ATLAS_THREAD_SAFE [2/2]

std::mutex m_mutex ActsTrk::TrackFindingBaseAlg::ATLAS_THREAD_SAFE

mutableprotected

Definition at line 330 of file TrackFindingBaseAlg.h.

m_absEtaMax

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_absEtaMax {this, "absEtaMax", std::numeric_limits<double>::max(), "TrackSelector: absEtaMax"}

protected

Definition at line 123 of file TrackFindingBaseAlg.h.

{this, "absEtaMax", std::numeric_limits<double>::max(), "TrackSelector: absEtaMax"};

m_absEtaMaxMeasurements

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_absEtaMaxMeasurements {this, "absEtaMaxMeasurements", {}, "if specified for the given seed collection, applies absEtaMax cut in branch stopper once absEtaMaxMeasurements have been encountered"}

protected

Definition at line 104 of file TrackFindingBaseAlg.h.

{this, "absEtaMaxMeasurements", {}, "if specified for the given seed collection, applies absEtaMax cut in branch stopper once absEtaMaxMeasurements have been encountered"};

m_absEtaMin

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_absEtaMin {this, "absEtaMin", 0.0, "TrackSelector: absEtaMin"}

protected

Definition at line 122 of file TrackFindingBaseAlg.h.

{this, "absEtaMin", 0.0, "TrackSelector: absEtaMin"};

m_addCounts

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_addCounts {this, "addCounts", true, "keep separate pixel, strip and hgtd counts and apply the following cuts"}

protected

Definition at line 137 of file TrackFindingBaseAlg.h.

{this, "addCounts", true, "keep separate pixel, strip and hgtd counts and apply the following cuts"};

m_branchStopperAbsEtaMaxExtra

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMaxExtra {this, "branchStopperAbsEtaMaxExtra", 0.0, "increase absEtaMax cut when used in the branch stopper"}

protected

Definition at line 112 of file TrackFindingBaseAlg.h.

{this, "branchStopperAbsEtaMaxExtra", 0.0, "increase absEtaMax cut when used in the branch stopper"};

m_branchStopperAbsEtaMeasCut

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_branchStopperAbsEtaMeasCut {this, "branchStopperAbsEtaMeasCut", 1.2, "the minimum |eta| to apply the reduction to the minMeas requirement for the branch stopper"}

protected

Definition at line 114 of file TrackFindingBaseAlg.h.

{this, "branchStopperAbsEtaMeasCut", 1.2, "the minimum |eta| to apply the reduction to the minMeas requirement for the branch stopper"};

m_branchStopperMeasCutReduce

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_branchStopperMeasCutReduce {this, "branchStopperMeasCutReduce", 2, "how much to reduce the minMeas requirement for the branch stopper"}

protected

Definition at line 113 of file TrackFindingBaseAlg.h.

{this, "branchStopperMeasCutReduce", 2, "how much to reduce the minMeas requirement for the branch stopper"};

m_branchStopperPtMinFactor

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_branchStopperPtMinFactor {this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"}

protected

Definition at line 110 of file TrackFindingBaseAlg.h.

{this, "branchStopperPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the branch stopper"};

m_checkCounts

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_checkCounts {this, "checkCounts", false, "check consistency among track state counts"}

protected

Definition at line 138 of file TrackFindingBaseAlg.h.

{this, "checkCounts", false, "check consistency among track state counts"};

m_chi2CutOff

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_chi2CutOff {this, "chi2CutOff", {}, "MeasurementSelector: maximum local chi2 contribution"}

protected

Definition at line 99 of file TrackFindingBaseAlg.h.

{this, "chi2CutOff", {}, "MeasurementSelector: maximum local chi2 contribution"};

m_chi2OutlierCutOff

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_chi2OutlierCutOff {this, "chi2OutlierCutOff", {}, "MeasurementSelector: maximum local chi2 contribution for outlier"}

protected

Definition at line 100 of file TrackFindingBaseAlg.h.

{this, "chi2OutlierCutOff", {}, "MeasurementSelector: maximum local chi2 contribution for outlier"};

m_ctxProvider

ContextUtility ActsTrk::TrackFindingBaseAlg::m_ctxProvider {this}

protected

Utility to fetch the geometry, magnetic field and calibration context in the event.

Definition at line 94 of file TrackFindingBaseAlg.h.

{this};

m_d0Max

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_d0Max {this, "d0Max", {}, "TrackSelector: d0Max"}

protected

Definition at line 127 of file TrackFindingBaseAlg.h.

{this, "d0Max", {}, "TrackSelector: d0Max"};

m_d0Min

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_d0Min {this, "d0Min", {}, "TrackSelector: d0Min"}

protected

Definition at line 126 of file TrackFindingBaseAlg.h.

{this, "d0Min", {}, "TrackSelector: d0Min"};

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_doBranchStopper

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_doBranchStopper {this, "doBranchStopper", true, "use branch stopper"}

protected

Definition at line 105 of file TrackFindingBaseAlg.h.

{this, "doBranchStopper", true, "use branch stopper"};

m_doTwoWay

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_doTwoWay {this, "doTwoWay", true, "run CKF twice, first with forward propagation with smoothing, then with backward propagation"}

protected

Definition at line 106 of file TrackFindingBaseAlg.h.

{this, "doTwoWay", true, "run CKF twice, first with forward propagation with smoothing, then with backward propagation"};

m_dumpAllStatEtaBins

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_dumpAllStatEtaBins {this, "DumpEtaBinsForAll", false, "Dump eta bins of all statistics counter."}

protected

Definition at line 154 of file TrackFindingBaseAlg.h.

{this, "DumpEtaBinsForAll", false, "Dump eta bins of all statistics counter."};

m_edgeHoleBorderWidth

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_edgeHoleBorderWidth {this,"EdgeHoleBorderWidth", 0. ,"Width of the border of surfaces (mm) within which holes are not counted as holes."}

protected

Definition at line 102 of file TrackFindingBaseAlg.h.

{this,"EdgeHoleBorderWidth", 0. ,"Width of the border of surfaces (mm) within which holes are not counted as holes."};

m_endOfWorldVolumeIds

Gaudi::Property<std::vector<std::uint32_t> > ActsTrk::TrackFindingBaseAlg::m_endOfWorldVolumeIds {this, "EndOfTheWorldVolumeIds", {}, ""}

protected

Definition at line 149 of file TrackFindingBaseAlg.h.

{this, "EndOfTheWorldVolumeIds", {}, ""};

m_etaBins

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_etaBins {this, "etaBins", {}, "bins in |eta| to specify variable selections"}

protected

Definition at line 97 of file TrackFindingBaseAlg.h.

{this, "etaBins", {}, "bins in |eta| to specify variable selections"};

m_etaMax

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_etaMax {this, "etaMax", {}, "TrackSelector: etaMax"}

protected

Definition at line 121 of file TrackFindingBaseAlg.h.

{this, "etaMax", {}, "TrackSelector: etaMax"};

m_etaMin

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_etaMin {this, "etaMin", {}, "TrackSelector: etaMin"}

protected

Definition at line 120 of file TrackFindingBaseAlg.h.

{this, "etaMin", {}, "TrackSelector: etaMin"};

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

privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

m_hgtdCalibTool

ToolHandle<ActsTrk::IHGTDOnTrackCalibratorTool<detail::RecoTrackStateContainer> > ActsTrk::TrackFindingBaseAlg::m_hgtdCalibTool {this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"}

protected

Definition at line 88 of file TrackFindingBaseAlg.h.

{this, "HGTDCalibrator", "", "Opt. HGTD measurement calibrator"};

m_inflateCovarianceTwoWay

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_inflateCovarianceTwoWay {this, "inflateCovarianceTwoWay", false, "inflate covariance matrix at the beginning of two-way track finding"}

protected

Definition at line 108 of file TrackFindingBaseAlg.h.

{this, "inflateCovarianceTwoWay", false, "inflate covariance matrix at the beginning of two-way track finding"};

m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::TrackFindingBaseAlg::m_logger

protected

logging instance

Definition at line 312 of file TrackFindingBaseAlg.h.

m_maxChi2

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_maxChi2 {this, "maxChi2", {}, "TrackSelector: maxChi2"}

protected

Definition at line 135 of file TrackFindingBaseAlg.h.

{this, "maxChi2", {}, "TrackSelector: maxChi2"};

m_maxHgtdHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxHgtdHoles {this, "maxHgtdHoles", {}, "maximum number of hgtd holes"}

protected

Definition at line 144 of file TrackFindingBaseAlg.h.

{this, "maxHgtdHoles", {}, "maximum number of hgtd holes"};

m_maxHgtdOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxHgtdOutliers {this, "maxHgtdOutliers", {}, "maximum number of hgtd outliers"}

protected

Definition at line 147 of file TrackFindingBaseAlg.h.

{this, "maxHgtdOutliers", {}, "maximum number of hgtd outliers"};

m_maxHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxHoles {this, "maxHoles", {}, "TrackSelector: maxHoles"}

protected

Definition at line 132 of file TrackFindingBaseAlg.h.

{this, "maxHoles", {}, "TrackSelector: maxHoles"};

m_maxOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxOutliers {this, "maxOutliers", {}, "TrackSelector: maxOutliers"}

protected

Definition at line 133 of file TrackFindingBaseAlg.h.

{this, "maxOutliers", {}, "TrackSelector: maxOutliers"};

m_maxPixelHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxPixelHoles {this, "maxPixelHoles", {}, "maximum number of pixel holes"}

protected

Definition at line 142 of file TrackFindingBaseAlg.h.

{this, "maxPixelHoles", {}, "maximum number of pixel holes"};

m_maxPixelOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxPixelOutliers {this, "maxPixelOutliers", {}, "maximum number of pixel outliers"}

protected

Definition at line 145 of file TrackFindingBaseAlg.h.

{this, "maxPixelOutliers", {}, "maximum number of pixel outliers"};

m_maxPropagationStep

Gaudi::Property<unsigned int> ActsTrk::TrackFindingBaseAlg::m_maxPropagationStep {this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"}

protected

Definition at line 96 of file TrackFindingBaseAlg.h.

{this, "maxPropagationStep", 1000, "Maximum number of steps for one propagate call"};

m_maxSharedHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxSharedHits {this, "maxSharedHits", {}, "TrackSelector: maxSharedHits"}

protected

Definition at line 134 of file TrackFindingBaseAlg.h.

{this, "maxSharedHits", {}, "TrackSelector: maxSharedHits"};

m_maxStripHoles

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxStripHoles {this, "maxStripHoles", {}, "maximum number of strip holes"}

protected

Definition at line 143 of file TrackFindingBaseAlg.h.

{this, "maxStripHoles", {}, "maximum number of strip holes"};

m_maxStripOutliers

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_maxStripOutliers {this, "maxStripOutliers", {}, "maximum number of strip outliers"}

protected

Definition at line 146 of file TrackFindingBaseAlg.h.

{this, "maxStripOutliers", {}, "maximum number of strip outliers"};

m_measurementSelectorConfig

struct ActsTrk::TrackFindingBaseAlg::MeasurementSelectorConfig ActsTrk::TrackFindingBaseAlg::m_measurementSelectorConfig

protected

m_minHgtdHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_minHgtdHits {this, "minHgtdHits", {}, "minimum number of hgtd hits"}

protected

Definition at line 141 of file TrackFindingBaseAlg.h.

{this, "minHgtdHits", {}, "minimum number of hgtd hits"};

m_minMeasurements

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_minMeasurements {this, "minMeasurements", {}, "TrackSelector: minMeasurements"}

protected

Definition at line 131 of file TrackFindingBaseAlg.h.

{this, "minMeasurements", {}, "TrackSelector: minMeasurements"};

m_minPixelHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_minPixelHits {this, "minPixelHits", {}, "minimum number of pixel hits"}

protected

Definition at line 139 of file TrackFindingBaseAlg.h.

{this, "minPixelHits", {}, "minimum number of pixel hits"};

m_minStripHits

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_minStripHits {this, "minStripHits", {}, "minimum number of strip hits"}

protected

Definition at line 140 of file TrackFindingBaseAlg.h.

{this, "minStripHits", {}, "minimum number of strip hits"};

m_monTool

ToolHandle<GenericMonitoringTool> ActsTrk::TrackFindingBaseAlg::m_monTool {this, "MonTool", "", "Monitoring tool"}

protected

Definition at line 83 of file TrackFindingBaseAlg.h.

{this, "MonTool", "", "Monitoring tool"};

m_numMeasurementsCutOff

Gaudi::Property<std::vector<size_t> > ActsTrk::TrackFindingBaseAlg::m_numMeasurementsCutOff {this, "numMeasurementsCutOff", {}, "MeasurementSelector: maximum number of associated measurements on a single surface"}

protected

Definition at line 101 of file TrackFindingBaseAlg.h.

{this, "numMeasurementsCutOff", {}, "MeasurementSelector: maximum number of associated measurements on a single surface"};

m_phiMax

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_phiMax {this, "phiMax", {}, "TrackSelector: phiMax"}

protected

Definition at line 119 of file TrackFindingBaseAlg.h.

{this, "phiMax", {}, "TrackSelector: phiMax"};

m_phiMin

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_phiMin {this, "phiMin", {}, "TrackSelector: phiMin"}

protected

Definition at line 118 of file TrackFindingBaseAlg.h.

{this, "phiMin", {}, "TrackSelector: phiMin"};

m_pixelCalibTool

ToolHandle<ActsTrk::IPixelOnTrackCalibratorTool<detail::RecoTrackStateContainer> > ActsTrk::TrackFindingBaseAlg::m_pixelCalibTool {this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"}

protected

Definition at line 86 of file TrackFindingBaseAlg.h.

{this, "PixelCalibrator", "", "Opt. pixel measurement calibrator"};

m_ptMax

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_ptMax {this, "ptMax", {}, "TrackSelector: ptMax"}

protected

Definition at line 125 of file TrackFindingBaseAlg.h.

{this, "ptMax", {}, "TrackSelector: ptMax"};

m_ptMin

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_ptMin {this, "ptMin", {}, "TrackSelector: ptMin"}

protected

Definition at line 124 of file TrackFindingBaseAlg.h.

{this, "ptMin", {}, "TrackSelector: ptMin"};

m_ptMinMeasurements

Gaudi::Property<std::vector<std::size_t> > ActsTrk::TrackFindingBaseAlg::m_ptMinMeasurements {this, "ptMinMeasurements", {}, "if specified for the given seed collection, applies ptMin cut in branch stopper once ptMinMinMeasurements have been encountered"}

protected

Definition at line 103 of file TrackFindingBaseAlg.h.

{this, "ptMinMeasurements", {}, "if specified for the given seed collection, applies ptMin cut in branch stopper once ptMinMinMeasurements have been encountered"};

m_recordMaterialStates

Gaudi::Property<bool> ActsTrk::TrackFindingBaseAlg::m_recordMaterialStates {this, "recordMaterialStates", false, "record track states on surfaces which have material but no measurement; keeping them off is faster, but they have to be on for the multi-component stepper and for anything downstream which needs the full track state sequence"}

protected

Definition at line 107 of file TrackFindingBaseAlg.h.

{this, "recordMaterialStates", false, "record track states on surfaces which have material but no measurement; keeping them off is faster, but they have to be on for the multi-component stepper and for anything downstream which needs the full track state sequence"};

m_seedLabels

Gaudi::Property<std::vector<std::string> > ActsTrk::TrackFindingBaseAlg::m_seedLabels {this, "SeedLabels", {}, "One label per seed key used in outputs"}

protected

Definition at line 153 of file TrackFindingBaseAlg.h.

{this, "SeedLabels", {}, "One label per seed key used in outputs"};

m_seedRefitPtMinFactor

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_seedRefitPtMinFactor {this, "seedRefitPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the seed refit"}

protected

Definition at line 111 of file TrackFindingBaseAlg.h.

{this, "seedRefitPtMinFactor", 1.0, "factor to multiply ptMin cut when used in the seed refit"};

m_showResolvedStats

bool ActsTrk::TrackFindingBaseAlg::m_showResolvedStats = false

protected

Definition at line 329 of file TrackFindingBaseAlg.h.

m_statEtaBins

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

protected

Definition at line 152 of file TrackFindingBaseAlg.h.

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

m_stripCalibTool

ToolHandle<ActsTrk::IStripOnTrackCalibratorTool<detail::RecoTrackStateContainer> > ActsTrk::TrackFindingBaseAlg::m_stripCalibTool {this, "StripCalibrator", "", "Opt. strip measurement calibrator"}

protected

Definition at line 87 of file TrackFindingBaseAlg.h.

{this, "StripCalibrator", "", "Opt. strip measurement calibrator"};

m_trackContainerKey

SG::WriteHandleKey<ActsTrk::TrackContainer> ActsTrk::TrackFindingBaseAlg::m_trackContainerKey {this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"}

protected

Definition at line 90 of file TrackFindingBaseAlg.h.

{this, "ACTSTracksLocation", "", "Output track collection (ActsTrk variant)"};

m_trackFinder

std::unique_ptr<CKF_pimpl> ActsTrk::TrackFindingBaseAlg::m_trackFinder

protected

Definition at line 79 of file TrackFindingBaseAlg.h.

m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> ActsTrk::TrackFindingBaseAlg::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

protected

Definition at line 84 of file TrackFindingBaseAlg.h.

{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

m_tracksBackendHandlesHelper

ActsTrk::MutableTrackContainerHandlesHelper ActsTrk::TrackFindingBaseAlg::m_tracksBackendHandlesHelper {this}

protected

Definition at line 91 of file TrackFindingBaseAlg.h.

{this};

m_trackStatePrinter

ToolHandle<ActsTrk::TrackStatePrinterTool> ActsTrk::TrackFindingBaseAlg::m_trackStatePrinter {this, "TrackStatePrinter", "", "optional track state printer"}

protected

Definition at line 85 of file TrackFindingBaseAlg.h.

{this, "TrackStatePrinter", "", "optional track state printer"};

m_twoWayinflateCovarianceFactor

Gaudi::Property<double> ActsTrk::TrackFindingBaseAlg::m_twoWayinflateCovarianceFactor {this, "twoWayinflateCovarianceFactor", 1.0, "factor to multiply the initial covariance matrix at the beginning of two-way track finding"}

protected

Definition at line 109 of file TrackFindingBaseAlg.h.

{this, "twoWayinflateCovarianceFactor", 1.0, "factor to multiply the initial covariance matrix at the beginning of two-way track finding"};

m_useAbsEtaForStat

bool ActsTrk::TrackFindingBaseAlg::m_useAbsEtaForStat = false

protected

Definition at line 328 of file TrackFindingBaseAlg.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_z0Max

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_z0Max {this, "z0Max", {}, "TrackSelector: z0Max"}

protected

Definition at line 129 of file TrackFindingBaseAlg.h.

{this, "z0Max", {}, "TrackSelector: z0Max"};

m_z0Min

Gaudi::Property<std::vector<double> > ActsTrk::TrackFindingBaseAlg::m_z0Min {this, "z0Min", {}, "TrackSelector: z0Min"}

protected

Definition at line 128 of file TrackFindingBaseAlg.h.

{this, "z0Min", {}, "TrackSelector: z0Min"};

s_branchState

BranchState ActsTrk::TrackFindingBaseAlg::s_branchState {}

staticconstexprprotected

Definition at line 293 of file TrackFindingBaseAlg.h.

{};

---

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

• TrackFindingBaseAlg.h
• TrackFindingBaseAlg.cxx