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
SG::ReadHandleKey< TrackExtensionMap >	m_extensionMapName
SG::WriteHandleKey< TrackCollection >	m_newTrackName
PublicToolHandle< Trk::ITrackFitter >	m_trackFitter
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool
PublicToolHandle< Trk::ITrackScoringTool >	m_scoringTool
BooleanProperty	m_cosmics
Gaudi::Property< Trk::RunOutlierRemoval >	m_runOutlier
BooleanProperty	m_keepFailedExtensionOnTrack
BooleanProperty	m_refitPrds
IntegerProperty	m_matEffects
BooleanProperty	m_suppressHoleSearch
BooleanProperty	m_tryBremFit
BooleanProperty	m_caloSeededBrem
FloatProperty	m_pTminBrem
Gaudi::Property< std::vector< float > >	m_etabounds
Trk::ParticleHypothesis	m_particleHypothesis {Trk::undefined}
	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
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 108 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 112 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_counters{},
  m_Nevents(0)
{}

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality

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 75 of file AthCommonReentrantAlgorithm.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 93 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 {
        // 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 = Trk::TrackScore(0);
        bool passBasicSelections = m_scoringTool->passBasicSelections(*newtrack);
        if(passBasicSelections){
          if (m_trackSummaryTool.isEnabled()) {
            m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *newtrack, m_suppressHoleSearch);
          }
          bool recheckBasicSel = false;
          newScore = m_scoringTool->score(*newtrack, recheckBasicSel);
        }
        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 + only replace summary if passBasicSelection
            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 456 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 71 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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

filterPassed()

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

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

finalize()

StatusCode InDet::InDetExtensionProcessor::finalize ( )

virtual

Definition at line 446 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 362 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 48 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state, const EventContext &  ctx  ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

sysExecute()

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

overridevirtualinherited

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

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 385 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 118 of file InDetExtensionProcessor.h.

ATLAS_THREAD_SAFE [2/2]

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

mutableprivate

Definition at line 119 of file InDetExtensionProcessor.h.

m_caloSeededBrem

BooleanProperty InDet::InDetExtensionProcessor::m_caloSeededBrem

private

Initial value:

{
      this, "caloSeededBrem", false, "calo seeded brem recovery"}

Definition at line 96 of file InDetExtensionProcessor.h.

m_cosmics

BooleanProperty InDet::InDetExtensionProcessor::m_cosmics

private

Initial value:

{
      this, "Cosmics", false, "switch whether we are running on cosmics"}

Definition at line 79 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

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

private

Initial value:

{
      this, "etaBounds", {0.8, 1.6, 2.10}, "eta intervals for internal monitoring"}

Definition at line 100 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_extensionMapName

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

private

Initial value:

{
      this, "ExtensionMap", "TrackExtensionMap", "Name of the input extension map"}

Definition at line 63 of file InDetExtensionProcessor.h.

m_keepFailedExtensionOnTrack

BooleanProperty InDet::InDetExtensionProcessor::m_keepFailedExtensionOnTrack

private

Initial value:

{
      this, "keepFailedExtension", true,
      "switch whether to keep failed extension as outlier hits on the new track"}

Definition at line 83 of file InDetExtensionProcessor.h.

m_matEffects

IntegerProperty InDet::InDetExtensionProcessor::m_matEffects

private

Initial value:

{
      this, "matEffects", 3,
      "particle hypothesis to assume for material effects in track fit"}

Definition at line 89 of file InDetExtensionProcessor.h.

m_newTrackName

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

private

Initial value:

{
      this, "NewTrackName", "ExtendedTrack", "Name of the output Trackcollection"}

Definition at line 65 of file InDetExtensionProcessor.h.

m_particleHypothesis

Trk::ParticleHypothesis InDet::InDetExtensionProcessor::m_particleHypothesis {Trk::undefined}

private

nomen est omen

Definition at line 105 of file InDetExtensionProcessor.h.

m_pTminBrem

FloatProperty InDet::InDetExtensionProcessor::m_pTminBrem

private

Initial value:

{
      this, "pTminBrem", 1000., "min pT for trying a brem recovery"}

Definition at line 98 of file InDetExtensionProcessor.h.

m_refitPrds

BooleanProperty InDet::InDetExtensionProcessor::m_refitPrds

private

Initial value:

{
      this, "RefitPrds", true,
      "switch whether to do the fit with re-calibrated clusters (true) or not"}

Definition at line 86 of file InDetExtensionProcessor.h.

m_runOutlier

Gaudi::Property<Trk::RunOutlierRemoval> InDet::InDetExtensionProcessor::m_runOutlier

private

Initial value:

{
      this, "runOutlier", true, "switch whether to run outlier logics or not"}

Definition at line 81 of file InDetExtensionProcessor.h.

m_scoringTool

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

private

Initial value:

{
      this, "ScoringTool", "Trk::TrackScoringTool",
      "Toolhandle for the track scorer"}

Definition at line 75 of file InDetExtensionProcessor.h.

m_suppressHoleSearch

BooleanProperty InDet::InDetExtensionProcessor::m_suppressHoleSearch

private

Initial value:

{
      this, "suppressHoleSearch", false, "suppressing hole search for comparison"}

Definition at line 92 of file InDetExtensionProcessor.h.

m_trackFitter

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

private

Initial value:

{
      this, "TrackFitter", "Trk::KalmanFitter/InDetTrackFitter",
      "Toolhandle for the track fitter"}

Definition at line 68 of file InDetExtensionProcessor.h.

m_trackName

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

private

Initial value:

{
      this, "TrackName", "Tracks", "Name of the 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 72 of file InDetExtensionProcessor.h.

m_tryBremFit

BooleanProperty InDet::InDetExtensionProcessor::m_tryBremFit

private

Initial value:

{
      this, "tryBremFit", false, "brem recovery mode"}

Definition at line 94 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