Trk::AmbiguityProcessorBase Class Reference

#include <AmbiguityProcessorBase.h>

Inheritance diagram for Trk::AmbiguityProcessorBase:

Collaboration diagram for Trk::AmbiguityProcessorBase:

Public Types
enum class	CounterIndex {   kNcandidates , kNcandScoreZero , kNcandDouble , kNscoreOk ,   kNscoreZeroBremRefit , kNscoreZeroBremRefitFailed , kNscoreZeroBremRefitScoreZero , kNscoreZero ,   kNaccepted , kNsubTrack , kNnoSubTrack , kNacceptedBrem ,   kNbremFits , kNfits , kNrecoveryBremFits , kNgoodFits ,   kNfailedFits , kNCounter }
using	Counter = AmbiCounter<CounterIndex>
using	TrackScoreMap = std::multimap<TrackScore, TrackPtr>

Public Member Functions
	AmbiguityProcessorBase (const std::string &, const std::string &, const IInterface *)
virtual	~AmbiguityProcessorBase ()=default
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (ITrackAmbiguityProcessorTool, 1, 0)
virtual const TrackCollection *	process (const EventContext &ctx, const TrackCollection *, Trk::PRDtoTrackMap *prd_to_track_map=nullptr) const =0
	(in concrete object) Returns a processed TrackCollection from the passed 'tracks'
virtual const TrackCollection *	process (const EventContext &ctx, const TracksScores *) const =0
virtual void	statistics ()=0
	Print statistics at the end of the processing.

Protected Types
using	UniqueClusterSplitProbabilityContainerPtr

Protected Member Functions
bool	shouldTryBremRecovery (const Trk::Track &track) const
bool	shouldTryBremRecovery (const Trk::Track &track, const TrackParameters *pPar) const
virtual std::unique_ptr< Trk::Track >	doBremRefit (const EventContext &ctx, const Trk::Track &track) const =0
Track *	refitTrack (const EventContext &ctx, const Trk::Track *track, Trk::PRDtoTrackMap &prdToTrackMap, Counter &stat, int trackId, int subtrackId) const
	refit track
virtual Trk::Track *	refitPrds (const EventContext &ctx, const Trk::Track *track, Trk::PRDtoTrackMap &prdToTrackMap, Counter &stat) const =0
virtual Trk::Track *	refitRots (const EventContext &ctx, const Trk::Track *track, Counter &stat) const
virtual std::unique_ptr< Trk::Track >	fit (const EventContext &ctx, const Track &track, bool flag, Trk::ParticleHypothesis hypo) const =0
void	addTrack (const EventContext &ctx, Trk::Track *in_track, const bool fitted, TrackScoreMap &trackScoreTrackMap, std::vector< std::unique_ptr< const Trk::Track > > &trackDustbin, Counter &stat, int parentTrackId) const
const TrackParameters *	getTrackParameters (const Trk::Track *track) const
StatusCode	initializeClusterSplitProbContainer ()
	Initialize read and write handles for ClusterSplitProbabilityContainers.
AmbiguityProcessorBase::UniqueClusterSplitProbabilityContainerPtr	createAndRecordClusterSplitProbContainer (const EventContext &ctx) const
	Create a new cluster splitting probability container and (optionally) record it in storegate The new container may be populated from an already existing container, and might be stored in StoreGate.
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
std::vector< float >	m_etaBounds
	eta intervals for internal monitoring
std::mutex	m_statMutex
Counter m_stat	ATLAS_THREAD_SAFE
ToolHandle< ITrackScoringTool >	m_scoringTool
	Scoring tool This tool is used to 'score' the tracks, i.e.
PublicToolHandle< Trk::ITrkObserverTool >	m_observerTool
	Observer tool This tool is used to observe the tracks and their 'score'.
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool
bool	m_tryBremFit {}
	brem recovery mode with brem fit ?
bool	m_caloSeededBrem {}
float	m_pTminBrem {1000.}
bool	m_suppressHoleSearch {}
bool	m_suppressTrackFit {}
bool	m_refitPrds {}
bool	m_forceRefit {true}
	by default tracks at input get refitted
int	m_matEffects {3}
	read in as an integer and convert to particle hypothesis
Trk::ParticleHypothesis	m_particleHypothesis {undefined}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Private Attributes
SG::ReadHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainerIn
SG::WriteHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainerOut
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 35 of file AmbiguityProcessorBase.h.

Member Typedef Documentation

Counter

using Trk::AmbiguityProcessorBase::Counter = AmbiCounter<CounterIndex>

Definition at line 58 of file AmbiguityProcessorBase.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TrackScoreMap

using Trk::AmbiguityProcessorBase::TrackScoreMap = std::multimap<TrackScore, TrackPtr>

Definition at line 59 of file AmbiguityProcessorBase.h.

UniqueClusterSplitProbabilityContainerPtr

using Trk::AmbiguityProcessorBase::UniqueClusterSplitProbabilityContainerPtr

protected

Initial value:

 
std::unique_ptr<Trk::ClusterSplitProbabilityContainer,
                void (*)(Trk::ClusterSplitProbabilityContainer*)>

Definition at line 115 of file AmbiguityProcessorBase.h.

Member Enumeration Documentation

CounterIndex

enum class Trk::AmbiguityProcessorBase::CounterIndex

strong

Enumerator
kNcandidates
kNcandScoreZero
kNcandDouble
kNscoreOk
kNscoreZeroBremRefit
kNscoreZeroBremRefitFailed
kNscoreZeroBremRefitScoreZero
kNscoreZero
kNaccepted
kNsubTrack
kNnoSubTrack
kNacceptedBrem
kNbremFits
kNfits
kNrecoveryBremFits
kNgoodFits
kNfailedFits
kNCounter

Definition at line 38 of file AmbiguityProcessorBase.h.

                          {
    kNcandidates,
    kNcandScoreZero,
    kNcandDouble,
    kNscoreOk,
    kNscoreZeroBremRefit,
    kNscoreZeroBremRefitFailed,
    kNscoreZeroBremRefitScoreZero,
    kNscoreZero,
    kNaccepted,
    kNsubTrack,
    kNnoSubTrack,
    kNacceptedBrem,
    kNbremFits,
    kNfits,
    kNrecoveryBremFits,
    kNgoodFits,
    kNfailedFits,
    kNCounter
  };

Constructor & Destructor Documentation

AmbiguityProcessorBase()

Trk::AmbiguityProcessorBase::AmbiguityProcessorBase	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 12 of file AmbiguityProcessorBase.cxx.

    : AthAlgTool(t, n, p),
      m_etaBounds{0.8, 1.6, 2.5, 4.0},
      m_stat(m_etaBounds) {}

~AmbiguityProcessorBase()

virtual Trk::AmbiguityProcessorBase::~AmbiguityProcessorBase ( )

virtualdefault

Member Function Documentation

addTrack()

void Trk::AmbiguityProcessorBase::addTrack ( const EventContext & ctx, Trk::Track * in_track, const bool fitted, TrackScoreMap & trackScoreTrackMap, std::vector< std::unique_ptr< const Trk::Track > > & trackDustbin, Counter & stat, int parentTrackId ) const

protected

Definition at line 153 of file AmbiguityProcessorBase.cxx.

                                            {
 
  std::unique_ptr<Trk::Track> atrack(in_track);
  // compute score
  TrackScore score = Trk::TrackScore(0);;
  bool suppressHoleSearch = fitted ? m_suppressHoleSearch : true;
  bool passBasicSelections = m_scoringTool->passBasicSelections(*atrack);
  if(passBasicSelections){
    if (m_trackSummaryTool.isEnabled()) {
      m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *atrack,
                            suppressHoleSearch);
    }
    bool recheckBasicSel = false;
    score = m_scoringTool->score(*atrack, recheckBasicSel);
  }
  
  if (m_observerTool.isEnabled()) {
    m_observerTool->updateScore(parentTrackId, static_cast<double>(score));
  }
  
  // do we accept the track ?
  if (score != 0) {
    ATH_MSG_DEBUG("Track  (" << atrack.get() << ") has score " << score);
    // statistic
    stat.incrementCounterByRegion(CounterIndex::kNscoreOk, atrack.get());
    // add track to map, map is sorted small to big !
    if (m_observerTool.isEnabled()) {
      trackScoreTrackMap.emplace(
          -score, TrackPtr(atrack.release(), fitted, parentTrackId));
    } else {
      trackScoreTrackMap.emplace(-score, TrackPtr(atrack.release(), fitted));
    }
    return;
  }
  // do we try to recover the track ?
  if (fitted and shouldTryBremRecovery(*atrack)) {
    ATH_MSG_DEBUG("Track score is zero, try to recover it via brem fit");
    // run track fit using electron hypothesis
    auto bremTrack(doBremRefit(ctx, *atrack));
    if (!bremTrack) {
      ATH_MSG_DEBUG("Brem refit failed, drop track");
      if (m_observerTool.isEnabled()) {
        m_observerTool->rejectTrack(parentTrackId,
                                    xAOD::RejectionStep::addTrack,
                                    xAOD::RejectionReason::bremRefitFailed);
      }
      // statistic
      stat.incrementCounterByRegion(CounterIndex::kNscoreZeroBremRefitFailed,
                                    atrack.get());
      stat.incrementCounterByRegion(CounterIndex::kNfailedFits, atrack.get());
      // clean up
      trackDustbin.push_back(std::move(atrack));
    } else {
      int newTrackId = AmbiguityProcessor::getUid();
      if (m_observerTool.isEnabled()) {
        m_observerTool->rejectTrack(
            parentTrackId, xAOD::RejectionStep::addTrack,
            xAOD::RejectionReason::bremRefitSubtrackCreated);
        m_observerTool->addSubTrack(newTrackId, parentTrackId, *bremTrack);
      }
      // statistic
      stat.incrementCounterByRegion(CounterIndex::kNgoodFits, bremTrack.get());
      // rerun score
      score = Trk::TrackScore(0);
      passBasicSelections = m_scoringTool->passBasicSelections(*bremTrack);
      if(passBasicSelections){
        if (m_trackSummaryTool.isEnabled()) {
          m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *bremTrack,
                                                            suppressHoleSearch);
        }
        bool recheckBasicSel = false;
        score = m_scoringTool->score(*bremTrack, recheckBasicSel);
      }
      if (m_observerTool.isEnabled()) {
        m_observerTool->updateScore(newTrackId, static_cast<double>(score));
      }
      // put original track in the bin, ready to preserve a new Brem track
      trackDustbin.push_back(std::move(atrack));
      // do we accept the track ?
      if (score != 0) {
        ATH_MSG_DEBUG("Brem refit successful, recovered track  ("
                      << bremTrack.get() << ") has score " << score);
        // statistics
        stat.incrementCounterByRegion(CounterIndex::kNscoreZeroBremRefit,
                                      bremTrack.get());
        // add track to map, map is sorted small to big !
        if (m_observerTool.isEnabled()) {
          m_observerTool->addSubTrack(newTrackId, parentTrackId, *bremTrack);
          trackScoreTrackMap.emplace(
              -score, TrackPtr(bremTrack.release(), fitted, newTrackId));
        } else {
          trackScoreTrackMap.emplace(-score,
                                     TrackPtr(bremTrack.release(), fitted));
        }
        return;
      } else {
        ATH_MSG_DEBUG("Brem refit gave still track score zero, reject it");
        if (m_observerTool.isEnabled()) {
          m_observerTool->rejectTrack(
              newTrackId, xAOD::RejectionStep::addTrack,
              xAOD::RejectionReason::bremRefitTrackScoreZero);
        }
        // statistic
        stat.incrementCounterByRegion(
            CounterIndex::kNscoreZeroBremRefitScoreZero, bremTrack.get());
      }
    }
  } else {
    ATH_MSG_DEBUG("Track score is zero, reject it");
    if (m_observerTool.isEnabled()) {
      m_observerTool->rejectTrack(parentTrackId, xAOD::RejectionStep::addTrack,
                                  xAOD::RejectionReason::refitTrackScoreZero);
    }
    // statistic
    stat.incrementCounterByRegion(CounterIndex::kNscoreZero, atrack.get());
    trackDustbin.push_back(std::move(atrack));
  }
}

createAndRecordClusterSplitProbContainer()

AmbiguityProcessorBase::UniqueClusterSplitProbabilityContainerPtr Trk::AmbiguityProcessorBase::createAndRecordClusterSplitProbContainer ( const EventContext & ctx ) const

protected

Create a new cluster splitting probability container and (optionally) record it in storegate The new container may be populated from an already existing container, and might be stored in StoreGate.

The ownersip, which might be either storegate or the calling scope, is taken into account by the UniqueClusterSplitProbabilityContainerPtr and must not be touched i.e. unique_ptr::release must not be called.

Definition at line 71 of file AmbiguityProcessorBase.cxx.

                                   {
  SG::ReadHandle<Trk::ClusterSplitProbabilityContainer> splitProbContainerIn;
  if (!m_clusterSplitProbContainerIn.key().empty()) {
    splitProbContainerIn = SG::ReadHandle(m_clusterSplitProbContainerIn, ctx);
    if (!splitProbContainerIn.isValid()) {
      ATH_MSG_ERROR("Failed to get input cluster split probability container "
                    << m_clusterSplitProbContainerIn.key());
    }
  }
  std::unique_ptr<Trk::ClusterSplitProbabilityContainer> newSplitProbContainer(
      !m_clusterSplitProbContainerIn.key().empty()
          ? std::make_unique<Trk::ClusterSplitProbabilityContainer>(
                *splitProbContainerIn)
          : std::make_unique<Trk::ClusterSplitProbabilityContainer>());
  SG::WriteHandle<Trk::ClusterSplitProbabilityContainer>
      splitProbContainerHandle;
  if (!m_clusterSplitProbContainerOut.key().empty()) {
    splitProbContainerHandle =
        SG::WriteHandle<Trk::ClusterSplitProbabilityContainer>(
            m_clusterSplitProbContainerOut, ctx);
    if (splitProbContainerHandle.record(std::move(newSplitProbContainer))
            .isFailure()) {
      ATH_MSG_FATAL(
          "Failed to record output cluster split probability container "
          << m_clusterSplitProbContainerOut.key());
    }
    // newSplitProbContainer owned by storegate -> no cleanup
    return {splitProbContainerHandle.ptr(),
            [](Trk::ClusterSplitProbabilityContainer*) {}};
  } else {
    // when not recording the split prob container in storegate the container
    // must be deleted once going out of scope
    return {newSplitProbContainer.release(),
            [](Trk::ClusterSplitProbabilityContainer* ptr) { delete ptr; }};
  }
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

DeclareInterfaceID()

Trk::ITrackAmbiguityProcessorTool::DeclareInterfaceID ( ITrackAmbiguityProcessorTool , 1 , 0  )

inherited

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

doBremRefit()

virtual std::unique_ptr< Trk::Track > Trk::AmbiguityProcessorBase::doBremRefit ( const EventContext & ctx, const Trk::Track & track ) const

protectedpure virtual

Implemented in Trk::DenseEnvironmentsAmbiguityProcessorTool, and Trk::SimpleAmbiguityProcessorTool.

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::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; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

fit()

virtual std::unique_ptr< Trk::Track > Trk::AmbiguityProcessorBase::fit ( const EventContext & ctx, const Track & track, bool flag, Trk::ParticleHypothesis hypo ) const

protectedpure virtual

Implemented in Trk::DenseEnvironmentsAmbiguityProcessorTool, and Trk::SimpleAmbiguityProcessorTool.

getTrackParameters()

const TrackParameters * Trk::AmbiguityProcessorBase::getTrackParameters ( const Trk::Track * track ) const

protected

Definition at line 276 of file AmbiguityProcessorBase.cxx.

                                 {
  const TrackParameters* par = track->perigeeParameters();
  if (not par) {
    ATH_MSG_DEBUG("Track (" << track << ") has no perigee! Try any other ?");
    par = track->trackParameters()->front();
  }
  if (not par)
    ATH_MSG_DEBUG("Track (" << track
                            << ") has no Track Parameters ! No refit !");
  return par;
}

initializeClusterSplitProbContainer()

StatusCode Trk::AmbiguityProcessorBase::initializeClusterSplitProbContainer ( )

protected

Initialize read and write handles for ClusterSplitProbabilityContainers.

If a write handle key is specified for the new ClusterSplitProbabilityContainer, read handles for this key are "renounced" in all child tools.

usage:

Definition at line 28 of file AmbiguityProcessorBase.cxx.

                                                                       {
  // init ClusterSplitProb input and output container handles and renounce the
  // output handle from its tools. the latter works because the ClusterSplitProb
  // output container is created and recorded before the tools are called.
  ATH_CHECK(m_clusterSplitProbContainerIn.initialize(
      !m_clusterSplitProbContainerIn.key().empty()));
  ATH_CHECK(m_clusterSplitProbContainerOut.initialize(
      !m_clusterSplitProbContainerOut.key().empty()));
  if (!m_clusterSplitProbContainerOut.key().empty()) {
    auto visitor = [this](const IAlgTool* tool) {
      const AlgTool* alg_tool = dynamic_cast<const AlgTool*>(tool);
      for (Gaudi::DataHandle* handle : alg_tool->inputHandles()) {
        this->msg(MSG::DEBUG) << " input Handle " << tool->name() << " . "
                              << handle->objKey() << endmsg;
      }
      for (const auto& elm : alg_tool->inputDataObjs()) {
        this->msg(MSG::DEBUG)
            << " input object " << tool->name() << " . " << elm.key() << endmsg;
      }
    };
    if (msgLvl(MSG::DEBUG)) {
      ToolVisitor::visit(tools(), visitor);
    }
    ATH_MSG_DEBUG(" Renounce " << m_clusterSplitProbContainerOut.objKey());
    auto logger = RenounceToolInputsVisitor::createLogger(
        [this](const std::string_view& tool_name, const std::string_view& key) {
          this->msg(MSG::INFO)
              << " Renounce " << tool_name << " . " << key << endmsg;
        });
    RenounceToolInputsVisitor renounce(
        std::vector<DataObjID>{m_clusterSplitProbContainerOut.fullKey()},
        logger);
    ToolVisitor::visit(tools(), renounce);
    ATH_MSG_DEBUG(" renounced " << m_clusterSplitProbContainerOut.objKey());
    if (msgLvl(MSG::DEBUG)) {
      ToolVisitor::visit(tools(), visitor);
    }
  }
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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.

process() [1/2]

virtual const TrackCollection * Trk::ITrackAmbiguityProcessorTool::process ( const EventContext & ctx, const TrackCollection * , Trk::PRDtoTrackMap * prd_to_track_map = nullptr ) const

pure virtualinherited

(in concrete object) Returns a processed TrackCollection from the passed 'tracks'

Parameters

tracks	collection of tracks which will have ambiguities resolved. Will not be modified.
prd_to_track_map	on optional prd-to-track map being filled by the processor.

Returns

new collections of tracks, with ambiguities resolved. Ownership is passed on. (i.e. client handles deletion).

If no prd-to-track map is given the processor might create one internally (for internal
use only, or exported to storegate).

Implemented in Trk::DenseEnvironmentsAmbiguityProcessorTool, Trk::SimpleAmbiguityProcessorTool, and Trk::TrackSelectionProcessorTool.

process() [2/2]

virtual const TrackCollection * Trk::ITrackAmbiguityProcessorTool::process ( const EventContext & ctx, const TracksScores *  ) const

pure virtualinherited

Implemented in Trk::DenseEnvironmentsAmbiguityProcessorTool, Trk::SimpleAmbiguityProcessorTool, and Trk::TrackSelectionProcessorTool.

refitPrds()

virtual Trk::Track * Trk::AmbiguityProcessorBase::refitPrds ( const EventContext & ctx, const Trk::Track * track, Trk::PRDtoTrackMap & prdToTrackMap, Counter & stat ) const

protectedpure virtual

Implemented in Trk::DenseEnvironmentsAmbiguityProcessorTool, and Trk::SimpleAmbiguityProcessorTool.

refitRots()

Trk::Track * Trk::AmbiguityProcessorBase::refitRots ( const EventContext & ctx, const Trk::Track * track, Counter & stat ) const

protectedvirtual

Definition at line 291 of file AmbiguityProcessorBase.cxx.

                                                                   {
  ATH_MSG_VERBOSE("Refit track " << track);
  // refit using first parameter, do outliers
  std::unique_ptr<Trk::Track> newTrack{};
  if (m_tryBremFit and track->info().trackProperties(Trk::TrackInfo::BremFit)) {
    stat.incrementCounterByRegion(CounterIndex::kNbremFits, track);
    ATH_MSG_VERBOSE("Brem track, refit with electron brem fit");
    newTrack = doBremRefit(ctx, *track);
  } else {
    stat.incrementCounterByRegion(CounterIndex::kNfits, track);
    ATH_MSG_VERBOSE("Normal track, refit");
    newTrack = fit(ctx, *track, true, m_particleHypothesis);
    if ((not newTrack) and shouldTryBremRecovery(*track)) {
      stat.incrementCounterByRegion(CounterIndex::kNrecoveryBremFits, track);
      ATH_MSG_VERBOSE("Normal fit failed, try brem recovery");
      newTrack = doBremRefit(ctx, *track);
    }
  }
 
  if (newTrack) {
    stat.incrementCounterByRegion(CounterIndex::kNgoodFits, newTrack.get());
    // keeping the track of previously accumulated TrackInfo
    const Trk::TrackInfo& originalInfo = track->info();
    newTrack->info().addPatternReco(originalInfo);
  } else {
    stat.incrementCounterByRegion(CounterIndex::kNfailedFits, track);
  }
  return newTrack.release();
}

refitTrack()

Track * Trk::AmbiguityProcessorBase::refitTrack ( const EventContext & ctx, const Trk::Track * track, Trk::PRDtoTrackMap & prdToTrackMap, Counter & stat, int trackId, int subtrackId ) const

protected

refit track

Definition at line 116 of file AmbiguityProcessorBase.cxx.

                                                                {
  std::unique_ptr<Trk::Track> newTrack;
  if (!m_suppressTrackFit) {
    if (m_refitPrds) {
      // simple case, fit PRD directly
      ATH_MSG_VERBOSE("Refit track " << track << " from PRDs");
      newTrack.reset(refitPrds(ctx, track, prdToTrackMap, stat));
    } else {
      // ok, we fit ROTs
      ATH_MSG_VERBOSE("Refit track " << track << " from ROTs");
      newTrack.reset(refitRots(ctx, track, stat));
    }
  } else {
    newTrack = AmbiguityProcessor::createNewFitQualityTrack(*track);
  }
  if (newTrack) {
    if (m_observerTool.isEnabled()) {
      m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::refitTrack,
                                  xAOD::RejectionReason::subtrackCreated);
      m_observerTool->addSubTrack(subtrackId, trackId, *newTrack);
    }
    ATH_MSG_DEBUG("New track " << newTrack.get() << " successfully fitted from "
                               << track);
  } else {
    if (m_observerTool.isEnabled()) {
      m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::refitTrack,
                                  xAOD::RejectionReason::refitFailed);
    }
    ATH_MSG_DEBUG("Fit failed !");
  }
  return newTrack.release();
}

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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

shouldTryBremRecovery() [1/2]

bool Trk::AmbiguityProcessorBase::shouldTryBremRecovery ( const Trk::Track & track ) const

protected

Definition at line 19 of file AmbiguityProcessorBase.cxx.

                                 {
  return m_tryBremFit and
         not(track.info().trackProperties(Trk::TrackInfo::BremFit)) and
         (track.trackParameters()->front()->pT() > m_pTminBrem) and
         ((not m_caloSeededBrem) or
          track.info().patternRecoInfo(Trk::TrackInfo::TrackInCaloROI));
}

shouldTryBremRecovery() [2/2]

bool Trk::AmbiguityProcessorBase::shouldTryBremRecovery ( const Trk::Track & track, const TrackParameters * pPar ) const

protected

Definition at line 109 of file AmbiguityProcessorBase.cxx.

                                                              {
  return m_tryBremFit and (pPar->pT() > m_pTminBrem) and
         ((not m_caloSeededBrem) or
          track.info().patternRecoInfo(Trk::TrackInfo::TrackInCaloROI));
}

statistics()

virtual void Trk::ITrackAmbiguityProcessorTool::statistics ( )

pure virtualinherited

Print statistics at the end of the processing.

Implemented in Trk::DenseEnvironmentsAmbiguityProcessorTool, Trk::SimpleAmbiguityProcessorTool, and Trk::TrackSelectionProcessorTool.

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

Counter m_stat Trk::AmbiguityProcessorBase::ATLAS_THREAD_SAFE

mutableprotected

Definition at line 132 of file AmbiguityProcessorBase.h.

m_caloSeededBrem

bool Trk::AmbiguityProcessorBase::m_caloSeededBrem {}

protected

Definition at line 161 of file AmbiguityProcessorBase.h.

{};

m_clusterSplitProbContainerIn

SG::ReadHandleKey<Trk::ClusterSplitProbabilityContainer> Trk::AmbiguityProcessorBase::m_clusterSplitProbContainerIn

private

Initial value:

{this, "InputClusterSplitProbabilityName",
                                    "", ""}

Definition at line 152 of file AmbiguityProcessorBase.h.

                                   {this, "InputClusterSplitProbabilityName",
                                    "", ""};

m_clusterSplitProbContainerOut

SG::WriteHandleKey<Trk::ClusterSplitProbabilityContainer> Trk::AmbiguityProcessorBase::m_clusterSplitProbContainerOut

private

Initial value:

{this, "OutputClusterSplitProbabilityName",
                                     "", ""}

Definition at line 155 of file AmbiguityProcessorBase.h.

                                    {this, "OutputClusterSplitProbabilityName",
                                     "", ""};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_etaBounds

std::vector<float> Trk::AmbiguityProcessorBase::m_etaBounds

protected

eta intervals for internal monitoring

Definition at line 130 of file AmbiguityProcessorBase.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_forceRefit

bool Trk::AmbiguityProcessorBase::m_forceRefit {true}

protected

by default tracks at input get refitted

Definition at line 168 of file AmbiguityProcessorBase.h.

{true};

m_matEffects

int Trk::AmbiguityProcessorBase::m_matEffects {3}

protected

read in as an integer and convert to particle hypothesis

reference: /TrkEventPrimitives/ParticleHypothesis.h

Definition at line 172 of file AmbiguityProcessorBase.h.

{3};  // pion

m_observerTool

PublicToolHandle<Trk::ITrkObserverTool> Trk::AmbiguityProcessorBase::m_observerTool

protected

Initial value:

{
      this, "ObserverTool", "", "track observer within ambiguity solver"}

Observer tool This tool is used to observe the tracks and their 'score'.

Definition at line 142 of file AmbiguityProcessorBase.h.

                                                      {
      this, "ObserverTool", "", "track observer within ambiguity solver"};

m_particleHypothesis

Trk::ParticleHypothesis Trk::AmbiguityProcessorBase::m_particleHypothesis {undefined}

protected

Definition at line 173 of file AmbiguityProcessorBase.h.

{undefined};

m_pTminBrem

float Trk::AmbiguityProcessorBase::m_pTminBrem {1000.}

protected

Definition at line 162 of file AmbiguityProcessorBase.h.

{1000.};

m_refitPrds

bool Trk::AmbiguityProcessorBase::m_refitPrds {}

protected

Definition at line 166 of file AmbiguityProcessorBase.h.

{};

m_scoringTool

ToolHandle<ITrackScoringTool> Trk::AmbiguityProcessorBase::m_scoringTool

protected

Initial value:

{this, "ScoringTool", "",
                                              "track scoring tool"}

Scoring tool This tool is used to 'score' the tracks, i.e.

to quantify what a good track is.

Todo

The actual tool that is used should be configured through job options

Definition at line 138 of file AmbiguityProcessorBase.h.

                                             {this, "ScoringTool", "",
                                              "track scoring tool"};

m_statMutex

std::mutex Trk::AmbiguityProcessorBase::m_statMutex

mutableprotected

Definition at line 131 of file AmbiguityProcessorBase.h.

m_suppressHoleSearch

bool Trk::AmbiguityProcessorBase::m_suppressHoleSearch {}

protected

Definition at line 163 of file AmbiguityProcessorBase.h.

{};

m_suppressTrackFit

bool Trk::AmbiguityProcessorBase::m_suppressTrackFit {}

protected

Definition at line 165 of file AmbiguityProcessorBase.h.

{};

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> Trk::AmbiguityProcessorBase::m_trackSummaryTool

protected

Initial value:

{
      this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"}

Definition at line 144 of file AmbiguityProcessorBase.h.

                                                             {
      this, "TrackSummaryTool", "InDetTrackSummaryToolNoHoleSearch"};

m_tryBremFit

bool Trk::AmbiguityProcessorBase::m_tryBremFit {}

protected

brem recovery mode with brem fit ?

Definition at line 160 of file AmbiguityProcessorBase.h.

{};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• AmbiguityProcessorBase.h
• AmbiguityProcessorBase.cxx