InDet::InDetExtensionProcessor Class Reference

Algorithm to process a TrackExtensionMap, refit the extended tracks and decide if the old track is to be replaced by the extended one. More...

#include <InDetExtensionProcessor.h>

Inheritance diagram for InDet::InDetExtensionProcessor:

Collaboration diagram for InDet::InDetExtensionProcessor:

Public Member Functions
	InDetExtensionProcessor (const std::string &name, ISvcLocator *pSvcLocator)
	Default Algorithm constructor with parameters. More...
virtual StatusCode	initialize ()
virtual StatusCode	execute (const EventContext &ctx) const
virtual StatusCode	finalize ()
virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...
virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
enum	StatIndex {   iAll, iBarrel, iTransi, iEndcap,   Nregions }
	internal monitoring: categories for counting different types of extension results More...
enum	StatTrkType {   nInput, nRecognised, nExtended, nRejected,   nFailed, nRecoveryBremFits, nBremFits, nFits,   nNotExtended, nLowScoreBremFits, nExtendedBrem, nTypes }
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
MsgStream &	dumpStat (MsgStream &out) const
TrackCollection *	createExtendedTracks (const EventContext &ctx, const TrackCollection *tracks_in, const TrackExtensionMap *track_extension_map) const
	process events More...
Trk::Track *	trackPlusExtension (const EventContext &ctx, const Trk::Track *, const std::vector< const Trk::MeasurementBase * > &) const
	internal structuring: creates new track with original one plus extension as outliers More...
void	incrementRegionCounter (std::array< std::atomic< int >, 4 > &, const Trk::Track *, bool=true) const
	monitoring and validation: does success/failure counting for each detector region More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
SG::ReadHandleKey< TrackCollection >	m_trackName
	Name of input Trackcollection. More...
bool	m_cosmics
	whether we are running cosmics More...
SG::ReadHandleKey< TrackExtensionMap >	m_extensionMapName
	Name of input extension map. More...
SG::WriteHandleKey< TrackCollection >	m_newTrackName
	Name of output Trackcollection. More...
ToolHandle< Trk::ITrackFitter >	m_trackFitter
	track fitter tool handle More...
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool
ToolHandle< Trk::ITrackScoringTool >	m_scoringTool
	track scorer tool handle More...
Trk::RunOutlierRemoval	m_runOutlier
	whether to run outlier logics More...
bool	m_keepFailedExtensionOnTrack
	switch whether to append a rejected extension as outlier trajectory More...
bool	m_refitPrds
	fitter steering: whether to do the fit with re-calibrated clusters (true) or not More...
int	m_matEffects
	type of material interaction in extrapolation More...
bool	m_suppressHoleSearch
	no hole search ? More...
bool	m_tryBremFit
	brem recovery mode ? More...
bool	m_caloSeededBrem
	run in Calo seeded mode More...
float	m_pTminBrem
	min pt for a brem fit More...
Trk::ParticleHypothesis	m_particleHypothesis
	nomen est omen More...
std::array< std::array< std::atomic< int >, Nregions >, nTypes > m_counters	ATLAS_THREAD_SAFE
std::atomic< int > m_Nevents	ATLAS_THREAD_SAFE
std::vector< float >	m_etabounds
	eta intervals for internal monitoring More...
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Algorithm to process a TrackExtensionMap, refit the extended tracks and decide if the old track is to be replaced by the extended one.

Author

Marku.nosp@m.s.El.nosp@m.sing@.nosp@m.cern.nosp@m..ch

Definition at line 37 of file InDetExtensionProcessor.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

StatIndex

enum InDet::InDetExtensionProcessor::StatIndex

private

internal monitoring: categories for counting different types of extension results

Enumerator
iAll
iBarrel
iTransi
iEndcap
Nregions

Definition at line 90 of file InDetExtensionProcessor.h.

                   {
      iAll, iBarrel, iTransi, iEndcap, Nregions
    };

StatTrkType

enum InDet::InDetExtensionProcessor::StatTrkType

private

Enumerator
nInput
nRecognised
nExtended
nRejected
nFailed
nRecoveryBremFits
nBremFits
nFits
nNotExtended
nLowScoreBremFits
nExtendedBrem
nTypes

Definition at line 94 of file InDetExtensionProcessor.h.

                     {
      nInput, nRecognised, nExtended, nRejected, nFailed, nRecoveryBremFits, 
      nBremFits, nFits, nNotExtended, nLowScoreBremFits, nExtendedBrem, nTypes 
    };

Constructor & Destructor Documentation

InDetExtensionProcessor()

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

Default Algorithm constructor with parameters.

Definition at line 38 of file InDetExtensionProcessor.cxx.

                                                                                                     :
  AthReentrantAlgorithm(name, pSvcLocator),
  m_trackName("Tracks"),
  m_cosmics(false),
  m_extensionMapName("TrackExtensionMap"),
  m_newTrackName("ExtendedTrack"),
  m_trackFitter("Trk::KalmanFitter/InDetTrackFitter"),
  m_scoringTool("Trk::TrackScoringTool"),
  m_runOutlier(true),
  m_keepFailedExtensionOnTrack(true),
  m_refitPrds(true),
  m_matEffects(3),
  m_suppressHoleSearch(false),
  m_particleHypothesis(Trk::undefined),
  m_counters{},
  m_Nevents(0),
  m_etabounds{0.8, 1.6, 2.10} {
  // Get parameter values from jobOptions file
  declareProperty("TrackName", m_trackName, "Name of the input Trackcollection");
  declareProperty("Cosmics", m_cosmics, "switch whether we are running on cosmics");
  declareProperty("ExtensionMap", m_extensionMapName, "Name of the input extension map");
  declareProperty("NewTrackName", m_newTrackName, "Name of the output Trackcollection");
  declareProperty("TrackFitter", m_trackFitter, "Toolhandle for the track fitter");
  declareProperty("ScoringTool", m_scoringTool, "Toolhandle for the track scorer");
  declareProperty("runOutlier", m_runOutlier, "switch whether to run outlier logics or not");
  declareProperty("keepFailedExtension", m_keepFailedExtensionOnTrack,
                  "switch whether to keep failed extension as outlier hits on the new track");
  declareProperty("RefitPrds", m_refitPrds, "switch whether to do the fit with re-calibrated clusters (true) or not");
  declareProperty("matEffects", m_matEffects, "particle hypothesis to assume for material effects in track fit");
  declareProperty("suppressHoleSearch", m_suppressHoleSearch, "suppressing hole search for comparison");
  declareProperty("tryBremFit", m_tryBremFit = false, "brem recover mode");
  declareProperty("caloSeededBrem", m_caloSeededBrem = false, "calo seeded brem recovery");
  declareProperty("pTminBrem", m_pTminBrem = 1000., "min pT for trying a brem recovery");
  declareProperty("etaBounds", m_etabounds, "eta intervals for internal monitoring"); //note: only three values!
}

Member Function Documentation

cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const

overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

{
  return 0;
}

createExtendedTracks()

TrackCollection * InDet::InDetExtensionProcessor::createExtendedTracks ( const EventContext &  ctx, const TrackCollection *  tracks_in, const TrackExtensionMap *  track_extension_map  ) const

private

process events

Definition at line 123 of file InDetExtensionProcessor.cxx.

                                                                                                       {
  std::unique_ptr<TrackCollection> newTracks(std::make_unique<TrackCollection>());
  std::array< std::array<std::atomic<int>, Nregions>, nTypes> counters{};
  // loop over tracks
  for (const Trk::Track* thisTrack : *pTracks) {
    // statistics
    incrementRegionCounter(counters[nInput], thisTrack, false);
    ATH_MSG_DEBUG("evaluate input track : " << thisTrack);
    // try to find this track in extension map
    TrackExtensionMap::const_iterator pThisExtensionPair = trackExtensionMap->find(thisTrack);
    // copy input track if this track is not found in list
    if (pThisExtensionPair == trackExtensionMap->end()) {
      ATH_MSG_DEBUG("track not in extension map, copy original track to output");
      // copy track, set pattern info
      std::unique_ptr<Trk::Track> ntrk(std::make_unique<Trk::Track>(*thisTrack));
      ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
      newTracks->push_back(std::move(ntrk));
      // statistics
      incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nNotExtended], thisTrack);
    } else {
      ATH_MSG_DEBUG("track found in extension map, processing...");
      // statistics
      incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nRecognised], thisTrack);
      // setup new track
      std::unique_ptr<Trk::Track>  newtrack;
      // keep old track info
      const Trk::TrackInfo oldTrackInfo = thisTrack->info();
      // keep list of PRDs, initially assumed to be same size as pThisExtensionPair->second
      const auto nRIO_OnTrack {pThisExtensionPair->second.size()};
      std::vector<const Trk::PrepRawData*> vecPrd;
      vecPrd.reserve(nRIO_OnTrack);
      // --- refit PRD ?
      if (m_refitPrds) {
        auto getPrepRawDataPtr = [](const Trk::MeasurementBase* m) {
                                   const auto& pRot = dynamic_cast <const Trk::RIO_OnTrack*>(m);
                                   return pRot ? pRot->prepRawData() : nullptr;
                                 };
        const auto& theRIOs_OnTrack {pThisExtensionPair->second};
        //NOTE: Assumes success; I don't remove any nullptrs which result! (could use copy_if)
        std::transform(theRIOs_OnTrack.begin(), theRIOs_OnTrack.end(), std::back_inserter(vecPrd), getPrepRawDataPtr);
        // we have the PRD Vector, we need to refit the track and see if it is better
        ATH_MSG_DEBUG("fit track " << thisTrack << " with PRDs, number : " << vecPrd.size());
        if (!m_cosmics) {
          // normal event processing
          if (m_tryBremFit && thisTrack->info().trackProperties(Trk::TrackInfo::BremFit)) {
            ATH_MSG_DEBUG("brem fit of electron like track");
            //statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nBremFits], thisTrack);
            // try brem fit of combined track
            newtrack = m_trackFitter->fit(
              ctx, *thisTrack, vecPrd, m_runOutlier, Trk::electron);
          } else {
            ATH_MSG_DEBUG("normal fit track");
            //statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nFits], thisTrack);
            // normal fit of combined track
            newtrack = m_trackFitter->fit(ctx,
              *thisTrack, vecPrd, m_runOutlier, m_particleHypothesis);
            if (!newtrack && m_tryBremFit &&
                thisTrack->trackParameters()->front()->pT() > m_pTminBrem &&
                (!m_caloSeededBrem || thisTrack->info().patternRecoInfo(
                                        Trk::TrackInfo::TrackInCaloROI))) {
              ATH_MSG_DEBUG("normal fit track failed, try to recover with brem fit");
              // statistics
              incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nRecoveryBremFits], thisTrack);
              // try brem fit of combined track
              newtrack=m_trackFitter->fit(ctx,*thisTrack, vecPrd, m_runOutlier, Trk::electron);
            }
          }
        } else {
          // ===> special case for cosmics
          std::vector<const Trk::PrepRawData*> vecPrdComb;
          // get track parameters
          const Trk::Perigee* siPerigee = thisTrack->perigeeParameters();
          if (!siPerigee) {
            ATH_MSG_DEBUG("no perigee found on track, copy input");
            // statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nFailed], thisTrack);
            // copy track, set pattern info
            std::unique_ptr<Trk::Track> ntrk(std::make_unique< Trk::Track>(*thisTrack));
            ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
            newTracks->push_back(std::move(ntrk));
          } else {
            // loop over extension RIO-on-tracks and add PRD it into vecPrdComb
            DataVector<const Trk::MeasurementBase>::const_iterator RIOit =
              pThisExtensionPair->first->measurementsOnTrack()->begin();
            for (; RIOit != pThisExtensionPair->first->measurementsOnTrack()->end(); ++RIOit) {
              const Trk::RIO_OnTrack* rot = dynamic_cast <const Trk::RIO_OnTrack*> (*RIOit);
              if (!rot) ATH_MSG_ERROR("cast to ROT failed, should not happen here !");
              else vecPrdComb.push_back(rot->prepRawData());
            }
            // merge lists
            for (auto & i : vecPrd) {
              double inprod =
                (i->detectorElement()->surface(i->identify()).center() - siPerigee->position()).dot(
                  siPerigee->momentum());
              if (inprod < 0) {
                vecPrdComb.insert(vecPrdComb.begin(), i);
              } else {
                vecPrdComb.push_back(i);
              }
            }
            //statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nFits], thisTrack);
            // normal fit of combined track
            newtrack = m_trackFitter->fit(
              ctx, vecPrdComb, *siPerigee, m_runOutlier, m_particleHypothesis);
          }
        }
      } else {
        const auto& RIOs_OnTrack {pThisExtensionPair->second};
        // we have an extension map with RIO-on-tracks, we need to refit the track and see if it is better
        ATH_MSG_DEBUG("fit track " << thisTrack << " with ROTs, number : " << RIOs_OnTrack.size());
        if (!m_cosmics) {
          if (m_tryBremFit && thisTrack->info().trackProperties(Trk::TrackInfo::BremFit)) {
            ATH_MSG_DEBUG("brem fit of electron like track");
            //statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nBremFits], thisTrack);
            // try brem fit of combined track
            newtrack=m_trackFitter->fit(ctx,*thisTrack, RIOs_OnTrack, m_runOutlier, Trk::electron);
          } else {
            ATH_MSG_DEBUG("normal fit track");
            //statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nFits], thisTrack);
            // fit combined track
            newtrack=m_trackFitter->fit(ctx,*thisTrack, RIOs_OnTrack, m_runOutlier, m_particleHypothesis);
            if (!newtrack && m_tryBremFit &&
                thisTrack->trackParameters()->front()->pT() > m_pTminBrem &&
                (!m_caloSeededBrem || thisTrack->info().patternRecoInfo(Trk::TrackInfo::TrackInCaloROI))) {
              ATH_MSG_DEBUG("normal fit track failed, try to recover with brem fit");
              // statistics
              incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nRecoveryBremFits], thisTrack);
              // try to recover with brem fit
              newtrack=m_trackFitter->fit(ctx,*thisTrack, RIOs_OnTrack, m_runOutlier, Trk::electron);
            }
          }//end-if of normal track fit
        } else {
          // special case for cosmics
          Trk::MeasurementSet rotSet;
          // get track parameters
          const Trk::Perigee* siPerigee = thisTrack->perigeeParameters();
          if (!siPerigee) {
            ATH_MSG_DEBUG("no perigee found on track, copy input");
            // statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nFailed], thisTrack);
            // copy track, set pattern info
            std::unique_ptr<Trk::Track>  ntrk(std::make_unique< Trk::Track>(*thisTrack));
            ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
            newTracks->push_back(std::move(ntrk));
          } else {
            // extract RIO-on-tracks from extension
            DataVector<const Trk::MeasurementBase>::const_iterator RIOit =
              pThisExtensionPair->first->measurementsOnTrack()->begin();
            for (; RIOit != pThisExtensionPair->first->measurementsOnTrack()->end(); ++RIOit) {
              rotSet.push_back(*RIOit);
            }
            // merge RIO-on-track lists
            for (const auto *i : pThisExtensionPair->second) {
              double inprod = (i->associatedSurface().center() - siPerigee->position()).dot(
                siPerigee->momentum());
              if (inprod < 0) {
                rotSet.insert(rotSet.begin(), i);
              } else {
                rotSet.push_back(i);
              }
            }
            ATH_MSG_DEBUG("normal fit track");
            //statistics
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nFits], thisTrack);
            // fit combined track
            newtrack=m_trackFitter->fit(ctx,rotSet, *siPerigee, m_runOutlier, m_particleHypothesis);
          }
        }
      }
      if (!newtrack) {
        ATH_MSG_DEBUG("refit of extended track failed, copy original track to output");
        // statistics
        incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nFailed], thisTrack);
        // push track into output, does copy, needs fixing
        if (m_keepFailedExtensionOnTrack) {
          newTracks->push_back(trackPlusExtension(ctx,thisTrack, pThisExtensionPair->second));
        } else {
          // copy track, set pattern info
          std::unique_ptr<Trk::Track>  ntrk(std::make_unique<Trk::Track>(*thisTrack));
          ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
          newTracks->push_back(std::move(ntrk));
        }
      } else {
        if (m_trackSummaryTool.isEnabled()) {
          m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *newtrack, m_suppressHoleSearch);
        }
        // score old and new tool and decide which one to push back
        Trk::TrackScore oldScore = m_scoringTool->score(*thisTrack);
        ATH_MSG_DEBUG("original track has score : " << oldScore);
        Trk::TrackScore newScore = m_scoringTool->score(*newtrack);
        ATH_MSG_DEBUG("new track has score      : " << newScore);
        // do we need to recover with a brem fit
        if (newScore < oldScore && m_tryBremFit &&
            !newtrack->info().trackProperties(Trk::TrackInfo::BremFit) &&
            thisTrack->trackParameters()->front()->pT() > m_pTminBrem &&
            (!m_caloSeededBrem || thisTrack->info().patternRecoInfo(Trk::TrackInfo::TrackInCaloROI))) {
          ATH_MSG_DEBUG("new track has low score, try to recover track using brem fit");
          // statistics
          incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nLowScoreBremFits], thisTrack);
          std::unique_ptr<Trk::Track> newBremTrack;
          // try to recover with brem fit
          if (m_refitPrds) {
            newBremTrack=m_trackFitter->fit(ctx,*thisTrack, vecPrd, m_runOutlier, Trk::electron);
          } else {
            newBremTrack=m_trackFitter->fit(ctx,*thisTrack, pThisExtensionPair->second, m_runOutlier, Trk::electron);
          }
          if (newBremTrack) {
            // score again
            // @TODO should score newBremTrack
            if (m_trackSummaryTool.isEnabled()) {
              m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *newBremTrack, m_suppressHoleSearch);
            }
            newScore = m_scoringTool->score(*newtrack);
            ATH_MSG_DEBUG("recovered new track has score      : " << newScore);
            // copy pointer
            newtrack = std::move(newBremTrack);
          }
        }
        if (newScore >= oldScore) {
          ATH_MSG_DEBUG("take extended track, it's better !");
          // statistics
          incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nExtended], newtrack.get());
          if (m_tryBremFit && newtrack->info().trackProperties(Trk::TrackInfo::BremFit)) {
            incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nExtendedBrem], newtrack.get());
          }
          //storing the precedent info
          newtrack->info().addPatternReco(oldTrackInfo);
          // push track into output
          newtrack->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
          newTracks->push_back(std::move(newtrack));
        } else {
          ATH_MSG_DEBUG("take original track, new one is worse !");
          // statistics
          incrementRegionCounter(counters[InDet::InDetExtensionProcessor::nRejected], newtrack.get());
          // push track into output, does copy
          std::unique_ptr<Trk::Track> ntrk;
          if (m_keepFailedExtensionOnTrack) {
            ntrk.reset(trackPlusExtension(ctx,thisTrack, pThisExtensionPair->second));
          } else {
            ntrk = std::make_unique<Trk::Track>(*thisTrack);
          }
          ntrk->info().setPatternRecognitionInfo(Trk::TrackInfo::InDetExtensionProcessor);
          newTracks->push_back(std::move(ntrk));
        }
      }
    }
  }
 
  {
 
    for (unsigned int itype = 0; itype < InDet::InDetExtensionProcessor::nTypes; itype++) m_counters[itype] += counters[itype];
  }
  return newTracks.release();
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

dumpStat()

MsgStream & InDet::InDetExtensionProcessor::dumpStat ( MsgStream &  out ) const

private

Definition at line 481 of file InDetExtensionProcessor.cxx.

{
    int iw = 9;
    out.width(9);
    out << "-------------------------------------------------------------------------------" << std::endl;
    out << "  Number of events processed      :   " << m_Nevents << std::endl;
    out << "  statistics by eta range          ------All---Barrel---Trans.-- Endcap-- " << std::endl;
    out << "-------------------------------------------------------------------------------" << std::endl;
    out << "  Number of tracks at input       :" << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    out << "  Number of not extended tracks   :" << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nNotExtended][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
    std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nNotExtended][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
    std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nNotExtended][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
    std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nNotExtended][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    out << "  Number of proposed ext. roads   :" << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nRecognised][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nRecognised][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(
      iw)
              << m_counters[InDet::InDetExtensionProcessor::nRecognised][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(
      iw)
              << m_counters[InDet::InDetExtensionProcessor::nRecognised][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    out << "-------------------------------------------------------------------------------" << std::endl;
    out << "  Number of track fits            :" << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFits][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    if (m_tryBremFit) {
      out << "  + brem fits for electron tracks :" << std::setiosflags(std::ios::dec) << std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nBremFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nBremFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(
        iw)
                << m_counters[InDet::InDetExtensionProcessor::nBremFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(
        iw)
                << m_counters[InDet::InDetExtensionProcessor::nBremFits][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
      out << "  + brem fit to recover failed fit:" << std::setiosflags(std::ios::dec) << std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nRecoveryBremFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nRecoveryBremFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nRecoveryBremFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nRecoveryBremFits][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
      out << "  + brem fit to recover low score :" << std::setiosflags(std::ios::dec) << std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nLowScoreBremFits][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nLowScoreBremFits][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nLowScoreBremFits][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nLowScoreBremFits][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    }
    out << "-------------------------------------------------------------------------------" << std::endl;
    out << "  Number of track fit failing     :" << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFailed][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFailed][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFailed][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nFailed][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    out << "  Number of rejected extensions   :" << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nRejected][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nRejected][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
    std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nRejected][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
    std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nRejected][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    out << "  Number of successful extensions :" << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nExtended][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) << std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nExtended][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
    std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nExtended][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
    std::setw(iw)
              << m_counters[InDet::InDetExtensionProcessor::nExtended][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    if (m_tryBremFit) {
      out << "  including brem fitted tracks    :" << std::setiosflags(std::ios::dec) << std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nExtendedBrem][InDet::InDetExtensionProcessor::iAll] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nExtendedBrem][InDet::InDetExtensionProcessor::iBarrel] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nExtendedBrem][InDet::InDetExtensionProcessor::iTransi] << std::setiosflags(std::ios::dec) <<
      std::setw(iw)
                << m_counters[InDet::InDetExtensionProcessor::nExtendedBrem][InDet::InDetExtensionProcessor::iEndcap] << std::endl;
    }
    out << "-------------------------------------------------------------------------------" << std::endl;
    out << std::setiosflags(std::ios::fixed | std::ios::showpoint) << std::setprecision(2)
              << "    definition: ( 0.0 < Barrel < " << m_etabounds[0] << " < Transition < " << m_etabounds[1]
              << " < Endcap < " << m_etabounds[2] << " )" << std::setprecision(-1) << std::endl;
    out << "-------------------------------------------------------------------------------" << std::endl;
    return out;
}

evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode InDet::InDetExtensionProcessor::execute ( const EventContext &  ctx ) const

virtual

Definition at line 101 of file InDetExtensionProcessor.cxx.

                                                                   {
  // process the extensions
  SG::ReadHandle<TrackCollection>   tracks(m_trackName, ctx);
  SG::ReadHandle<TrackExtensionMap> trackExtensionMap(m_extensionMapName, ctx);
  SG::WriteHandle<TrackCollection>  extendedTracksResult(m_newTrackName, ctx);
  const auto nTracks {tracks->size()};
  ATH_MSG_DEBUG("Number of Tracks found : " << nTracks);
  // input statistics
  {
    ++m_Nevents;
    m_counters[InDet::InDetExtensionProcessor::nInput][InDet::InDetExtensionProcessor::iAll] += nTracks;
  }
  ATH_CHECK(extendedTracksResult.record(std::unique_ptr<TrackCollection>(
    createExtendedTracks(ctx, tracks.cptr(), trackExtensionMap.cptr()))));
  ATH_MSG_DEBUG("Container '" << m_newTrackName.key()
                              << "' recorded in StoreGate, size : "
                              << extendedTracksResult->size());
  if (extendedTracksResult->size() != nTracks) ATH_MSG_WARNING("Lost tracks after extension ??? This is a bug !");
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

extraOutputDeps()

const DataObjIDColl & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

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

filterPassed()

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

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

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

finalize()

StatusCode InDet::InDetExtensionProcessor::finalize ( )

virtual

Definition at line 471 of file InDetExtensionProcessor.cxx.

                                                  {
  if (msgLvl(MSG::INFO)) {
     MsgStream &out = msg(MSG::INFO);
     out << "::finalize() -- statistics:" << std::endl;
     dumpStat(out);
     out << endmsg;
  }
  return StatusCode::SUCCESS;
}

incrementRegionCounter()

void InDet::InDetExtensionProcessor::incrementRegionCounter ( std::array< std::atomic< int >, 4 > &  Ntracks, const Trk::Track *  track, bool  updateAll = true  ) const

private

monitoring and validation: does success/failure counting for each detector region

Definition at line 387 of file InDetExtensionProcessor.cxx.

                                                                                  {
  if (updateAll) Ntracks[InDet::InDetExtensionProcessor::iAll] += 1;
  // test
  if (!track) {
    ATH_MSG_ERROR("track pointer zero, should not happen!");
    return;
  }
  const auto *const pTrackParameters {track->trackParameters()};
  // use first parameter
  if (not pTrackParameters) {
    ATH_MSG_WARNING("No track parameters, needed for statistics code in Trk::SimpleAmbiguityProcessorTool!");
  } else {
    const double absEta = std::abs(pTrackParameters->front()->eta());
    if (absEta < m_etabounds[0]) ++Ntracks[InDet::InDetExtensionProcessor::iBarrel];
    else if (absEta < m_etabounds[1]) ++Ntracks[InDet::InDetExtensionProcessor::iTransi];
    else if (absEta < m_etabounds[2]) ++Ntracks[InDet::InDetExtensionProcessor::iEndcap];
  }
}

initialize()

StatusCode InDet::InDetExtensionProcessor::initialize ( )

virtual

Definition at line 78 of file InDetExtensionProcessor.cxx.

                                         {
  ATH_MSG_DEBUG("InDetExtensionProcessor::initialize()");
  ATH_CHECK(m_trackFitter.retrieve());
  ATH_MSG_DEBUG("Retrieved tool " << m_trackFitter);
  // Configuration of the material effects
  m_particleHypothesis = Trk::ParticleSwitcher::particle[m_matEffects];
  //
  ATH_CHECK(m_trackSummaryTool.retrieve(DisableTool {m_trackSummaryTool.name().empty()}));
  ATH_CHECK(m_scoringTool.retrieve());
  ATH_MSG_DEBUG("Retrieved tool " << m_scoringTool);
  // brem fitting enabled ?
  if (m_tryBremFit) ATH_MSG_DEBUG("Try brem fit and recovery for electron like tracks.");
  //
  ATH_CHECK(m_trackName.initialize());
  ATH_CHECK(m_extensionMapName.initialize());
  ATH_CHECK(m_newTrackName.initialize());
  return StatusCode::SUCCESS;
}

inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 44 of file AthReentrantAlgorithm.cxx.

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

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

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.

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

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

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

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

sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext &  ctx )

overridevirtualinherited

Execute an algorithm.

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

Definition at line 67 of file AthReentrantAlgorithm.cxx.

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

sysInitialize()

StatusCode AthReentrantAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

trackPlusExtension()

Trk::Track * InDet::InDetExtensionProcessor::trackPlusExtension ( const EventContext &  ctx, const Trk::Track *  siTrack, const std::vector< const Trk::MeasurementBase * > &  extension  ) const

private

internal structuring: creates new track with original one plus extension as outliers

Definition at line 410 of file InDetExtensionProcessor.cxx.

{
  const auto& trackStatesOnSurfaces{ *(siTrack->trackStateOnSurfaces()) };
  auto pExtendedTrajectory = std::make_unique<Trk::TrackStates>();
 
  pExtendedTrajectory->reserve(trackStatesOnSurfaces.size() + extension.size());
  int nSiStates = 0, nExtStates = 0;
  // copy existing si track as first part to new track - including all track pars since fit does not change
  auto cloneTSOS = [](const Trk::TrackStateOnSurface* pTSOS) {
                     return new Trk::TrackStateOnSurface(*pTSOS);
                   };
  std::transform(trackStatesOnSurfaces.begin(), trackStatesOnSurfaces.end(), std::back_inserter(
                   *pExtendedTrajectory), cloneTSOS);
  nSiStates += trackStatesOnSurfaces.size();
  // copy proposed (but failed) extension as second part onto new track - all hits flagged as outliers.
  constexpr auto outlierDigit {1 << Trk::TrackStateOnSurface::Outlier};
  constexpr std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> outlierPattern(outlierDigit);
  //create new track state on surface
  auto createNewTSOS = [outlierPattern](const Trk::MeasurementBase* pm) -> const Trk::TrackStateOnSurface*{
                         return new Trk::TrackStateOnSurface(pm->uniqueClone(), nullptr, nullptr, outlierPattern);
                       };
  //Adding to cosmic tracks beginning or end depending on the direction of track
  auto addNewTSOS_ForCosmics = [&pExtendedTrajectory, siTrack, createNewTSOS](const Trk::MeasurementBase* pm) {
                                 const auto& perigee {siTrack->perigeeParameters()};
                                 //the sign of this gives the direction
                                 const double inprod = (pm->associatedSurface().center() - perigee->position()).dot(
                                   perigee->momentum());
                                 if (inprod < 0) {
                                   pExtendedTrajectory->insert(pExtendedTrajectory->begin(), createNewTSOS(pm));
                                 } else {
                                   pExtendedTrajectory->push_back(createNewTSOS(pm));
                                 }
                               };
  //actual copying done here, using preceding lambda functions
  if (not m_cosmics) {
    std::transform(extension.begin(), extension.end(), std::back_inserter(*pExtendedTrajectory), createNewTSOS);
  } else {
    //difficult to use std::transform here, since don't know whether back or front are added to
    for (const auto *const pMeasurementBase: extension) {
      addNewTSOS_ForCosmics(pMeasurementBase);
    }
  }
  nExtStates += pExtendedTrajectory->size();
  const auto& pFitQuality {siTrack->fitQuality()};
  Trk::Track* extTrack =
    new Trk::Track(siTrack->info(), std::move(pExtendedTrajectory), (pFitQuality ? pFitQuality->uniqueClone() : nullptr));
  if (m_trackSummaryTool.isEnabled()) {
    m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *extTrack, m_suppressHoleSearch);
  }
  Trk::TrackScore extScore = m_scoringTool->score(*extTrack);
  ATH_MSG_DEBUG("rejected extension saved as Trk::Track with " << nSiStates <<
                " fitted hits and " << nExtStates << " additional Outliers, score :" << extScore);
  return extTrack;
}

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::array< std::array<std::atomic<int>, Nregions>, nTypes > m_counters InDet::InDetExtensionProcessor::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 100 of file InDetExtensionProcessor.h.

ATLAS_THREAD_SAFE [2/2]

std::atomic<int> m_Nevents InDet::InDetExtensionProcessor::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 101 of file InDetExtensionProcessor.h.

m_caloSeededBrem

bool InDet::InDetExtensionProcessor::m_caloSeededBrem

private

run in Calo seeded mode

Definition at line 83 of file InDetExtensionProcessor.h.

m_cosmics

bool InDet::InDetExtensionProcessor::m_cosmics

private

whether we are running cosmics

Definition at line 62 of file InDetExtensionProcessor.h.

m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_etabounds

std::vector<float> InDet::InDetExtensionProcessor::m_etabounds

private

eta intervals for internal monitoring

Definition at line 103 of file InDetExtensionProcessor.h.

m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

m_extensionMapName

SG::ReadHandleKey<TrackExtensionMap> InDet::InDetExtensionProcessor::m_extensionMapName

private

Name of input extension map.

Definition at line 63 of file InDetExtensionProcessor.h.

m_keepFailedExtensionOnTrack

bool InDet::InDetExtensionProcessor::m_keepFailedExtensionOnTrack

private

switch whether to append a rejected extension as outlier trajectory

Definition at line 76 of file InDetExtensionProcessor.h.

m_matEffects

int InDet::InDetExtensionProcessor::m_matEffects

private

type of material interaction in extrapolation

Definition at line 80 of file InDetExtensionProcessor.h.

m_newTrackName

SG::WriteHandleKey<TrackCollection> InDet::InDetExtensionProcessor::m_newTrackName

private

Name of output Trackcollection.

Definition at line 64 of file InDetExtensionProcessor.h.

m_particleHypothesis

Trk::ParticleHypothesis InDet::InDetExtensionProcessor::m_particleHypothesis

private

nomen est omen

Definition at line 87 of file InDetExtensionProcessor.h.

m_pTminBrem

float InDet::InDetExtensionProcessor::m_pTminBrem

private

min pt for a brem fit

Definition at line 84 of file InDetExtensionProcessor.h.

m_refitPrds

bool InDet::InDetExtensionProcessor::m_refitPrds

private

fitter steering: whether to do the fit with re-calibrated clusters (true) or not

Definition at line 78 of file InDetExtensionProcessor.h.

m_runOutlier

Trk::RunOutlierRemoval InDet::InDetExtensionProcessor::m_runOutlier

private

whether to run outlier logics

Definition at line 74 of file InDetExtensionProcessor.h.

m_scoringTool

ToolHandle<Trk::ITrackScoringTool> InDet::InDetExtensionProcessor::m_scoringTool

private

track scorer tool handle

Definition at line 73 of file InDetExtensionProcessor.h.

m_suppressHoleSearch

bool InDet::InDetExtensionProcessor::m_suppressHoleSearch

private

no hole search ?

Definition at line 81 of file InDetExtensionProcessor.h.

m_trackFitter

ToolHandle<Trk::ITrackFitter> InDet::InDetExtensionProcessor::m_trackFitter

private

track fitter tool handle

Definition at line 65 of file InDetExtensionProcessor.h.

m_trackName

SG::ReadHandleKey<TrackCollection> InDet::InDetExtensionProcessor::m_trackName

private

Name of input Trackcollection.

Definition at line 61 of file InDetExtensionProcessor.h.

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> InDet::InDetExtensionProcessor::m_trackSummaryTool

private

Initial value:

{
      this, "TrackSummaryTool", ""
    }

Definition at line 67 of file InDetExtensionProcessor.h.

m_tryBremFit

bool InDet::InDetExtensionProcessor::m_tryBremFit

private

brem recovery mode ?

Definition at line 82 of file InDetExtensionProcessor.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.

---

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

• InDetExtensionProcessor.h
• InDetExtensionProcessor.cxx