#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 TrackCollection tracksCol, Trk::PRDtoTrackMap prdToTrackMap) const override
	Returns a processed TrackCollection from the passed 'tracks' WITHOUT copying or refitting the input tracks. More...

virtual const TrackCollection *	process (const TracksScores *) const override

void	statistics () override
	statistics output to be called by algorithm during finalize. More...

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	sysInitialize () override
	Perform system initialization for an algorithm. 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

Static Public Member Functions
static const InterfaceID &	interfaceID ()

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
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. More...

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

void	dumpTracks (const TrackCollection &tracks) const
	print out tracks and their scores for debugging 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
bool	m_dropDouble
	by default drop double tracks before refit More...

ToolHandle< ITrackScoringTool >	m_scoringTool {this, "ScoringTool", "Muon::MuonAmbiTrackSelectionTool/MuonAmbiSelectionTool"}
	Scoring tool This tool is used to 'score' the tracks, i.e. More...

ToolHandle< IAmbiTrackSelectionTool >	m_selectionTool
	selection tool - here the decision which hits remain on a track and which are removed are made More...

ToolHandle< Trk::IPRDtoTrackMapTool >	m_assoTool

SG::ReadHandleKey< Trk::PRDtoTrackMap >	m_assoMapName
	key for the PRDtoTrackMap to filled by the ambiguity score processor. More...

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

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 99 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() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::detStore ( ) const

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ dumpTracks()

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

private

print out tracks and their scores for debugging

Definition at line 210 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() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { 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.

◆ interfaceID()

const InterfaceID & Trk::ITrackAmbiguityProcessorTool::interfaceID ( )

inlinestaticinherited

Definition at line 52 of file ITrackAmbiguityProcessorTool.h.

 {
   return IID_ITrackAmbiguityProcessorTool;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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]

const TrackCollection * Trk::TrackSelectionProcessorTool::process	(	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);
         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(trackScoreTrackMap, *pPrdToTrackMap, *result);
   if (msgLvl(MSG::DEBUG)) dumpTracks(*result->asDataVector());
   return result.release()->asDataVector();
 }

◆ process() [2/2]

virtual const TrackCollection* Trk::TrackSelectionProcessorTool::process ( const TracksScores * ) const

inlineoverridevirtual

Implements Trk::ITrackAmbiguityProcessorTool.

Definition at line 74 of file TrackSelectionProcessorTool.h.

                                                {
       return nullptr;
     }

◆ 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	(	TrackScoreMap &	trackScoreTrackMap,
		Trk::PRDtoTrackMap &	prdToTrackMap,
		ConstDataVector< TrackCollection > &	final_tracks
	)		const

private

Definition at line 143 of file TrackSelectionProcessorTool.cxx.

 {
   using namespace std;
  
   const EventContext& ctx = Gaudi::Hive::currentContext();
   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 80 of file TrackSelectionProcessorTool.h.

80 {}

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

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

◆ m_assoTool

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

private

Initial value:

{this, "AssociationTool",

"Trk::PRDtoTrackMapTool"}

Definition at line 115 of file TrackSelectionProcessorTool.h.

◆ m_clusterSplitProbContainerIn

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

private

Initial value:

{this, "InputClusterSplitProbabilityName",

"", ""}

Definition at line 124 of file TrackSelectionProcessorTool.h.

◆ m_clusterSplitProbContainerOut

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

private

Initial value:

{

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

Definition at line 127 of file TrackSelectionProcessorTool.h.

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

◆ m_dropDouble

bool Trk::TrackSelectionProcessorTool::m_dropDouble

private

by default drop double tracks before refit

Definition at line 102 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 107 of file TrackSelectionProcessorTool.h.

◆ 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 113 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:

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ PrdSignature

◆ PrdSignatureSet

◆ StoreGateSvc_t

◆ TrackScoreMap

Constructor & Destructor Documentation

◆ TrackSelectionProcessorTool()

◆ ~TrackSelectionProcessorTool()

Member Function Documentation

◆ addNewTracks()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ dumpTracks()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ process() [1/2]

◆ process() [2/2]

◆ renounce()

◆ renounceArray()

◆ solveTracks()

◆ statistics()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_assoMapName

◆ m_assoTool

◆ m_clusterSplitProbContainerIn

◆ m_clusterSplitProbContainerOut

◆ m_detStore

◆ m_disableSorting

◆ m_dropDouble

◆ m_evtStore

◆ m_scoringTool

◆ m_selectionTool

◆ m_varHandleArraysDeclared

◆ m_vhka