Trk::TrackSelectionProcessorTool Class Reference

#include <TrackSelectionProcessorTool.h>

Inheritance diagram for Trk::TrackSelectionProcessorTool:

Collaboration diagram for Trk::TrackSelectionProcessorTool:

Public Types
typedef std::multimap< TrackScore, TrackPtr >	TrackScoreMap
typedef std::set< const PrepRawData * >	PrdSignature
typedef std::set< PrdSignature >	PrdSignatureSet

Public Member Functions
	TrackSelectionProcessorTool (const std::string &, const std::string &, const IInterface *)
virtual	~TrackSelectionProcessorTool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual const TrackCollection *	process (const EventContext &ctx, const TrackCollection *tracksCol, Trk::PRDtoTrackMap *prdToTrackMap) const override
	Returns a processed TrackCollection from the passed 'tracks' WITHOUT copying or refitting the input tracks.
virtual const TrackCollection *	process (const EventContext &, const TracksScores *) const override
void	statistics () override
	statistics output to be called by algorithm during finalize.
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)

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	addNewTracks (TrackScoreMap &trackScoreTrackMap, Trk::PRDtoTrackMap &prdToTrackMap, const std::vector< const Track * > &tracks) const
	Add passed TrackCollection, and Trk::PrepRawData from tracks to caches.
void	solveTracks (const EventContext &ctx, TrackScoreMap &trackScoreTrackMap, Trk::PRDtoTrackMap &prdToTrackMap, ConstDataVector< TrackCollection > &final_tracks) const
void	dumpTracks (const TrackCollection &tracks) const
	print out tracks and their scores for debugging
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_dropDouble
	by default drop double tracks before refit
ToolHandle< ITrackScoringTool >	m_scoringTool {this, "ScoringTool", "Muon::MuonAmbiTrackSelectionTool/MuonAmbiSelectionTool"}
	Scoring tool This tool is used to 'score' the tracks, i.e.
ToolHandle< IAmbiTrackSelectionTool >	m_selectionTool
	selection tool - here the decision which hits remain on a track and which are removed are made
ToolHandle< Trk::IPRDtoTrackMapTool >	m_assoTool
SG::ReadHandleKey< Trk::PRDtoTrackMap >	m_assoMapName
	key for the PRDtoTrackMap to filled by the ambiguity score processor.
SG::ReadHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainerIn
SG::WriteHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainerOut
bool	m_disableSorting
	option to disable sorting based on track score and use the ordering provided externally
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 33 of file TrackSelectionProcessorTool.h.

Member Typedef Documentation

PrdSignature

typedef std::set<const PrepRawData *> Trk::TrackSelectionProcessorTool::PrdSignature

Definition at line 40 of file TrackSelectionProcessorTool.h.

PrdSignatureSet

typedef std::set<PrdSignature> Trk::TrackSelectionProcessorTool::PrdSignatureSet

Definition at line 41 of file TrackSelectionProcessorTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TrackScoreMap

typedef std::multimap<TrackScore, TrackPtr> Trk::TrackSelectionProcessorTool::TrackScoreMap

Definition at line 38 of file TrackSelectionProcessorTool.h.

Constructor & Destructor Documentation

TrackSelectionProcessorTool()

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

Definition at line 12 of file TrackSelectionProcessorTool.cxx.

  :
  AthAlgTool(t,n,p),
  m_selectionTool("InDet::InDetAmbiTrackSelectionTool/InDetAmbiTrackSelectionTool")
{
  declareInterface<ITrackAmbiguityProcessorTool>(this);
  declareProperty("DropDouble"           , m_dropDouble         = true);
  declareProperty("SelectionTool"        , m_selectionTool);
  declareProperty("DisableSorting"       , m_disableSorting     = false);
}

~TrackSelectionProcessorTool()

Trk::TrackSelectionProcessorTool::~TrackSelectionProcessorTool ( )

virtualdefault

Member Function Documentation

addNewTracks()

void Trk::TrackSelectionProcessorTool::addNewTracks ( TrackScoreMap & trackScoreTrackMap, Trk::PRDtoTrackMap & prdToTrackMap, const std::vector< const Track * > & tracks ) const

private

Add passed TrackCollection, and Trk::PrepRawData from tracks to caches.

Parameters

tracks

the TrackCollection is looped over, and each Trk::Track is added to the various caches. The Trk::PrepRawData from each Trk::Track are added to the IPRD_AssociationTool

Definition at line 100 of file TrackSelectionProcessorTool.cxx.

                                                                                                {
  ATH_MSG_DEBUG ("Number of tracks at Input: "<<tracks.size());
  PrdSignatureSet prdSigSet;
  TrackScore itrack=0;
  for (const Track*a_track : tracks )   {
    if(m_disableSorting) {
      // add track to map using ordering provided by the collection
      trackScoreTrackMap.insert( std::make_pair(itrack, TrackPtr(a_track)) );
      itrack++;
      continue;
    }
    bool reject = false;
    TrackScore score = m_scoringTool->score( *a_track );
    // veto tracks with score 0
    if (score==0) { 
      ATH_MSG_DEBUG ("Track score is zero, reject it");
      reject = true;
    } else {
      if (m_dropDouble) {
        const std::vector<const Trk::PrepRawData*> & prds = m_assoTool->getPrdsOnTrack(prdToTrackMap, *a_track);
        // unfortunately PrepRawDataSet is not a set !
        PrdSignature prdSig;
        prdSig.insert( prds.begin(),prds.end() );
        // we try to insert it into the set, if we fail (pair.second), it then exits already
        if ( !(prdSigSet.insert(prdSig)).second ) {
          ATH_MSG_DEBUG ("Double track, reject it !");
          reject = true;
        } else {
          ATH_MSG_DEBUG ("Insert new track in PrdSignatureSet");
        }
      }
    }
    if (!reject) {
      // add track to map, map is sorted small to big ! set if fitted
      ATH_MSG_VERBOSE ("Track  ("<< a_track <<") has score "<<score);
      trackScoreTrackMap.insert( std::make_pair(-score, TrackPtr(a_track) ) );
    }
  }
  ATH_MSG_DEBUG ("Number of tracks in map:"<<trackScoreTrackMap.size());
}

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

dumpTracks()

void Trk::TrackSelectionProcessorTool::dumpTracks ( const TrackCollection & tracks ) const

private

print out tracks and their scores for debugging

Definition at line 211 of file TrackSelectionProcessorTool.cxx.

                                                                               {
  ATH_MSG_VERBOSE ("Dumping tracks in collection");
  int num=0;
  TrackScore totalScore = 0;
  TrackCollection::const_iterator it    = tracks.begin();
  TrackCollection::const_iterator itEnd = tracks.end();
  for (; it != itEnd ; ++it){
    // score track:
    const TrackScore score = m_scoringTool->score( **it );
    ATH_MSG_VERBOSE (num++<<"\tTrack :"<<*it<<"\tScore: "<<score);
    totalScore+=score;
  }
  ATH_MSG_DEBUG ("Total event score : "<<totalScore);
}

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

finalize()

StatusCode Trk::TrackSelectionProcessorTool::finalize ( )

overridevirtual

Definition at line 50 of file TrackSelectionProcessorTool.cxx.

                                        {
  StatusCode sc = AlgTool::finalize(); 
  return sc;
}

initialize()

StatusCode Trk::TrackSelectionProcessorTool::initialize ( )

overridevirtual

Definition at line 30 of file TrackSelectionProcessorTool.cxx.

                                          {
  StatusCode sc = AthAlgTool::initialize();
  if (sc.isFailure()) {
    ATH_MSG_FATAL( "AlgTool::initialise failed" );
    return StatusCode::FAILURE;
  }
  ATH_CHECK( m_assoMapName.initialize(!m_assoMapName.key().empty()));
  ATH_CHECK( m_assoTool.retrieve() );
  ATH_CHECK( m_scoringTool.retrieve());
  ATH_CHECK(m_selectionTool.retrieve());
 
  ATH_CHECK(m_clusterSplitProbContainerIn.initialize(!m_clusterSplitProbContainerIn.key().empty()));
  ATH_CHECK(m_clusterSplitProbContainerOut.initialize(!m_clusterSplitProbContainerOut.key().empty()));
 
  if (m_disableSorting) ATH_MSG_DEBUG( "Internal sorting disabled, using external ordering!" );
  return sc;
}

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::TrackSelectionProcessorTool::process ( const EventContext & , const TracksScores *  ) const

inlineoverridevirtual

Implements Trk::ITrackAmbiguityProcessorTool.

Definition at line 75 of file TrackSelectionProcessorTool.h.

                                               {
      return nullptr;
    }

process() [2/2]

const TrackCollection * Trk::TrackSelectionProcessorTool::process ( const EventContext & ctx, const TrackCollection * tracksCol, Trk::PRDtoTrackMap * pPrdToTrackMap ) const

overridevirtual

Returns a processed TrackCollection from the passed 'tracks' WITHOUT copying or refitting the input tracks.

Do actual processing of event.

The pointers of the tracks in the input collection are copied into the output collection which does NOT own the pointers. Clients must ensure that the Input Collection is not deleted before the output collection else all pointers in the output collection will be invalid!

Parameters

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

Returns

new collections of tracks, with ambiguities resolved. The returned track collection is a SG::VIEW_ELEMENTS container, meaning that it should NOT be written to disk. Ownership of the collection 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).

Takes a track container, and then returns the tracks which have been selected

Implements Trk::ITrackAmbiguityProcessorTool.

Definition at line 61 of file TrackSelectionProcessorTool.cxx.

                                                                                 {
  //TODO: make sure the ownership; delete origin tracks from map?
  std::vector<const Track*> tracks;
  tracks.reserve(tracksCol->size());
  for(const auto *e: *tracksCol){
    tracks.push_back(e);
  }
  ATH_MSG_DEBUG ("Processing "<<tracks.size()<<" tracks");
  std::unique_ptr<Trk::PRDtoTrackMap> tmpPrdToTrackMap;
  if (!pPrdToTrackMap) {
     tmpPrdToTrackMap = m_assoTool->createPRDtoTrackMap();
     if (!m_assoMapName.key().empty()) {
        SG::ReadHandle<Trk::PRDtoTrackMap> inputPrdMap(m_assoMapName, ctx);
        if (!inputPrdMap.isValid()) {
           ATH_MSG_ERROR("Failed to retrieve prd to track map " << m_assoMapName.key() );
        } else {
           *tmpPrdToTrackMap = *inputPrdMap;
        }
     }
     pPrdToTrackMap = tmpPrdToTrackMap.get();
  }
  TrackScoreMap trackScoreTrackMap;
  //put tracks into maps etc
  addNewTracks(trackScoreTrackMap,*pPrdToTrackMap, tracks);
  // going to do simple algorithm for now:
  // - take track with highest score
  // - remove shared hits from all other tracks
  // - take next highest scoring tracks, and repeat 
  std::unique_ptr<ConstDataVector<TrackCollection> > result(std::make_unique<ConstDataVector<TrackCollection> >(SG::VIEW_ELEMENTS)); //TODO, old or new
  solveTracks(ctx, trackScoreTrackMap, *pPrdToTrackMap, *result);
  if (msgLvl(MSG::DEBUG)) dumpTracks(*result->asDataVector());
  return result.release()->asDataVector();
}

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

solveTracks()

void Trk::TrackSelectionProcessorTool::solveTracks ( const EventContext & ctx, TrackScoreMap & trackScoreTrackMap, Trk::PRDtoTrackMap & prdToTrackMap, ConstDataVector< TrackCollection > & final_tracks ) const

private

Definition at line 144 of file TrackSelectionProcessorTool.cxx.

{
  using namespace std;
 
  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> splitProbContainerCleanup(!m_clusterSplitProbContainerIn.key().empty()
                                                                                      ? std::make_unique<ClusterSplitProbabilityContainer>(*splitProbContainerIn)
                                                                                      : std::make_unique<ClusterSplitProbabilityContainer>());
  SG::WriteHandle<Trk::ClusterSplitProbabilityContainer> splitProbContainerHandle;
  Trk::ClusterSplitProbabilityContainer *splitProbContainer;
  if (!m_clusterSplitProbContainerOut.key().empty()) {
     splitProbContainerHandle = SG::WriteHandle<Trk::ClusterSplitProbabilityContainer>( m_clusterSplitProbContainerOut, ctx);
     if (splitProbContainerHandle.record(std::move(splitProbContainerCleanup)).isFailure()) {
        ATH_MSG_FATAL( "Failed to record output cluster split probability container "  << m_clusterSplitProbContainerOut.key());
     }
     splitProbContainer=splitProbContainerHandle.ptr();
  }
  else {
     splitProbContainer=splitProbContainerCleanup.get();
  }
 
  ATH_MSG_VERBOSE ("Starting to solve tracks");
  // now loop as long as map is not empty
  while ( !trackScoreTrackMap.empty() ) {
    TrackScoreMap::iterator itnext = trackScoreTrackMap.begin();
    TrackPtr atrack( std::move(itnext->second) );
    TrackScore ascore( itnext->first);
    trackScoreTrackMap.erase(itnext);
    ATH_MSG_VERBOSE ("--- Trying next track "<<atrack.track()<<"\t with score "<<-ascore);
    std::unique_ptr<Trk::Track> cleanedTrack;
    const auto &[cleanedTrack_tmp, keepOriginal]  = m_selectionTool->getCleanedOutTrack( atrack.track() , -(ascore), *splitProbContainer, prdToTrackMap, -1, -1);
    cleanedTrack.reset(cleanedTrack_tmp);
    if (keepOriginal ){
      // track can be kept as identical to the input track
      ATH_MSG_DEBUG ("Accepted track "<<atrack.track()<<"\t has score "<<-(ascore));
      // add track to PRD_AssociationTool
      StatusCode sc = m_assoTool->addPRDs(prdToTrackMap,*atrack);
      if (sc.isFailure()) ATH_MSG_ERROR( "addPRDs() failed" );
      // add to output list
      result.push_back( atrack.track() );
 
    } else if ( !cleanedTrack ) {
      // track should be discarded
      ATH_MSG_DEBUG ("Track "<< atrack.track() << " doesn't meet the cuts of the AmbiTrack Selection tool");
    } else  {
      // delete cleaned track
      cleanedTrack.reset();
      // stripped down version cannot be handled discarding
      ATH_MSG_DEBUG("Selection tool returned a new track, cannot handle memory management of new track, deleting it. Check you configuration ");
    }
    // don't forget to drop track from map
  }
  ATH_MSG_DEBUG ("Finished, number of track on output: "<<result.size());
}

statistics()

void Trk::TrackSelectionProcessorTool::statistics ( )

inlineoverridevirtual

statistics output to be called by algorithm during finalize.

Implements Trk::ITrackAmbiguityProcessorTool.

Definition at line 82 of file TrackSelectionProcessorTool.h.

{}

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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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

m_assoMapName

SG::ReadHandleKey<Trk::PRDtoTrackMap> Trk::TrackSelectionProcessorTool::m_assoMapName

private

Initial value:

{
        this, "AssociationMapName",
        ""}

key for the PRDtoTrackMap to filled by the ambiguity score processor.

the key given to the newly created association map

Definition at line 122 of file TrackSelectionProcessorTool.h.

                                                   {
        this, "AssociationMapName",
        ""};  

m_assoTool

ToolHandle<Trk::IPRDtoTrackMapTool> Trk::TrackSelectionProcessorTool::m_assoTool

private

Initial value:

{this, "AssociationTool",
                                                   "Trk::PRDtoTrackMapTool"}

Definition at line 118 of file TrackSelectionProcessorTool.h.

                                                {this, "AssociationTool",
                                                   "Trk::PRDtoTrackMapTool"};

m_clusterSplitProbContainerIn

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

private

Initial value:

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

Definition at line 127 of file TrackSelectionProcessorTool.h.

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

m_clusterSplitProbContainerOut

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

private

Initial value:

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

Definition at line 130 of file TrackSelectionProcessorTool.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_disableSorting

bool Trk::TrackSelectionProcessorTool::m_disableSorting

private

option to disable sorting based on track score and use the ordering provided externally

Definition at line 135 of file TrackSelectionProcessorTool.h.

m_dropDouble

bool Trk::TrackSelectionProcessorTool::m_dropDouble

private

by default drop double tracks before refit

Definition at line 105 of file TrackSelectionProcessorTool.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_scoringTool

ToolHandle<ITrackScoringTool> Trk::TrackSelectionProcessorTool::m_scoringTool {this, "ScoringTool", "Muon::MuonAmbiTrackSelectionTool/MuonAmbiSelectionTool"}

private

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 110 of file TrackSelectionProcessorTool.h.

{this, "ScoringTool", "Muon::MuonAmbiTrackSelectionTool/MuonAmbiSelectionTool"};

m_selectionTool

ToolHandle<IAmbiTrackSelectionTool> Trk::TrackSelectionProcessorTool::m_selectionTool

private

selection tool - here the decision which hits remain on a track and which are removed are made

Definition at line 116 of file TrackSelectionProcessorTool.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:

• TrackSelectionProcessorTool.h
• TrackSelectionProcessorTool.cxx