Trk::DenseEnvironmentsAmbiguityScoreProcessorTool Class Reference

#include <DenseEnvironmentsAmbiguityScoreProcessorTool.h>

Inheritance diagram for Trk::DenseEnvironmentsAmbiguityScoreProcessorTool:

Collaboration diagram for Trk::DenseEnvironmentsAmbiguityScoreProcessorTool:

Public Types
enum	ScoreCategory {   ScoreCategory::kNtracks, ScoreCategory::kNcandidates, ScoreCategory::kNcandScoreZero, ScoreCategory::kNcandDouble,   ScoreCategory::kNaccept, ScoreCategory::kNCounter }
using	Counter = AmbiCounter< ScoreCategory >
typedef std::multimap< TrackScore, const Track * >	TrackScoreMap
typedef std::vector< const PrepRawData * >	PrdSignature
typedef std::set< PrdSignature >	PrdSignatureSet

Public Member Functions
	DenseEnvironmentsAmbiguityScoreProcessorTool (const std::string &, const std::string &, const IInterface *)
virtual	~DenseEnvironmentsAmbiguityScoreProcessorTool ()
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () override final
virtual void	process (const TrackCollection &tracks, TracksScores *trackScoreTrackMap) const override final
	Do actual processing of event. More...
void	statistics () override
	statistics output to be called by algorithm during finalize. More...
void	dumpStat (MsgStream &out) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	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 (const TrackCollection &tracks, TracksScores *trackScoreTrackMap) const
	Add passed TrackCollection, and Trk::PrepRawData from tracks to caches. More...
void	overlappingTracks (const TracksScores *scoreTrackMap, InDet::PixelGangedClusterAmbiguities *splitClusterMap, Trk::ClusterSplitProbabilityContainer &splitProbContainer, Trk::PRDtoTrackMap &prd_to_track_map) const
	Find SiS Tracks that share hits in the track score map. More...
void	updatePixelSplitInformationForCluster (const std::pair< const InDet::PixelCluster *const, const Trk::TrackParameters * > &clusterTrkPara, InDet::PixelGangedClusterAmbiguities *splitClusterMap, Trk::ClusterSplitProbabilityContainer &splitProbContainer) const
	Update pixel split information based using the fitted track. 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
ToolHandle< ITrackScoringTool >	m_scoringTool {this, "ScoringTool", "Trk::TrackScoringTool/TrackScoringTool" }
	Scoring tool This tool is used to 'score' the tracks, i.e. More...
ToolHandle< Trk::IPRDtoTrackMapTool >	m_assoTool {this, "AssociationTool", "InDet::InDetPRDtoTrackMapToolGangedPixels" }
ToolHandle< Trk::IPRDtoTrackMapTool >	m_assoToolNotGanged {this, "AssociationToolNotGanged", "Trk::PRDtoTrackMapTool" }
ToolHandle< InDet::IPixelClusterSplitProbTool >	m_splitProbTool {this, "SplitProbTool", "InDet::NnPixelClusterSplitProbTool/NnPixelClusterSplitProbTool" }
	recalculate split prob tool More...
PublicToolHandle< Trk::ITrkObserverTool >	m_observerTool {this, "ObserverTool", "", "track observer within ambiguity solver"}
	Observer tool This tool is used to observe the tracks and their 'score'. More...
SG::ReadHandleKey< InDet::PixelGangedClusterAmbiguities >	m_splitClusterMapKey_last
	cluster split information generated by previous instances More...
SG::WriteHandleKey< InDet::PixelGangedClusterAmbiguities >	m_splitClusterMapKey
	cluster split information which m_splitClusterMap_last will be merged into More...
SG::WriteHandleKey< Trk::PRDtoTrackMap >	m_assoMapName {this,"AssociationMapName",""}
	key for the PRDtoTrackMap to be used by the ambiguity process to resolve the ambiguities. More...
SG::ReadHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainerIn {this,"InputClusterSplitProbabilityName",""}
	the key given to the newly created association map More...
SG::WriteHandleKey< Trk::ClusterSplitProbabilityContainer >	m_clusterSplitProbContainerOut {this,"OutputClusterSplitProbabilityName",""}
	the key given to the newly created association map More...
float	m_sharedProbCut
	NN split sprob cut for 2 particle clusters. More...
float	m_sharedProbCut2
	NN split sprob cut for 3 particle clusters. More...
std::vector< float >	m_etaBounds
	eta intervals for internal monitoring More...
std::mutex	m_statMutex
Counter m_stat	ATLAS_THREAD_SAFE
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 40 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

Member Typedef Documentation

Counter

using Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::Counter = AmbiCounter<ScoreCategory>

Definition at line 52 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

PrdSignature

typedef std::vector<const PrepRawData*> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::PrdSignature

Definition at line 55 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

PrdSignatureSet

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

Definition at line 56 of file DenseEnvironmentsAmbiguityScoreProcessorTool.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, const Track* > Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::TrackScoreMap

Definition at line 54 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

Member Enumeration Documentation

ScoreCategory

enum Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::ScoreCategory

strong

Enumerator
kNtracks
kNcandidates
kNcandScoreZero
kNcandDouble
kNaccept
kNCounter

Definition at line 44 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

                             {
      kNtracks,
      kNcandidates,
      kNcandScoreZero,
      kNcandDouble,
      kNaccept,
      kNCounter
    };

Constructor & Destructor Documentation

DenseEnvironmentsAmbiguityScoreProcessorTool()

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

Definition at line 24 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

  :
  AthAlgTool(t,n,p),
  m_etaBounds{0.8, 1.6, 2.5,4.0},
  m_stat(m_etaBounds)
{
 
  declareInterface<ITrackAmbiguityScoreProcessorTool>(this);
  declareProperty("SplitClusterMap_old"  , m_splitClusterMapKey_last);
  declareProperty("SplitClusterMap_new"  , m_splitClusterMapKey);
  declareProperty("sharedProbCut"        , m_sharedProbCut           = 0.3);
  declareProperty("sharedProbCut2"       , m_sharedProbCut2          = 0.3);
  declareProperty("etaBounds"            , m_etaBounds,"eta intervals for internal monitoring");
 
}

~DenseEnvironmentsAmbiguityScoreProcessorTool()

Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::~DenseEnvironmentsAmbiguityScoreProcessorTool ( )

virtualdefault

Member Function Documentation

addNewTracks()

void Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::addNewTracks ( const TrackCollection &  tracks, Trk::TracksScores *  trackScoreTrackMap  ) 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 163 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

                                                                                                    {
  Counter stat(m_etaBounds);
  stat.newEvent();
  std::unique_ptr<Trk::PRDtoTrackMap> prdToTrackMap( m_assoTool->createPRDtoTrackMap() );
  PrdSignatureSet prdSigSet; 
  ATH_MSG_DEBUG ("Number of tracks at Input: "<<tracks.size());
  const std::array<ScoreCategory, 3> categoryMapping {ScoreCategory::kNcandScoreZero, ScoreCategory::kNcandDouble, ScoreCategory::kNaccept};
  constexpr bool dropDuplicateTracks{true};
  int nZeroScore = 0;
  int nDuplicates = 0;
  int nToMap = 0;
  for(const Track* pThisTrack : tracks) {
    ATH_MSG_VERBOSE ("Processing track candidate "<<pThisTrack);
    stat.incrementCounterByRegion(ScoreCategory::kNcandidates,pThisTrack); // @TODO should go to the score processor
    TrackScore score = m_scoringTool->score(*pThisTrack);
    const auto category =
      AmbiguityProcessor::categoriseTrack(*pThisTrack, score,
                      dropDuplicateTracks,
                      m_assoTool, *prdToTrackMap,
                      prdSigSet);
    if (category<categoryMapping.size()) {
      stat.incrementCounterByRegion(categoryMapping[category],pThisTrack);
    }
    ATH_MSG_DEBUG(AmbiguityProcessor::debugMessage[category]);
 
    if (category == AmbiguityProcessor::TrackAccepted){
      ATH_MSG_VERBOSE ("Track  ("<< pThisTrack <<") has score "<<score);
      trackScoreTrackMap->push_back(std::make_pair(pThisTrack, -score));
      if (m_observerTool.isEnabled()) {
        nToMap++;
      }
    } else if (m_observerTool.isEnabled() &&
           category == AmbiguityProcessor::ScoreIsZero){
      int input_track_uid = AmbiguityProcessor::getUid();
      m_observerTool->addInputTrack(input_track_uid, *pThisTrack);
      m_observerTool->updateTrackMap(input_track_uid,
                     static_cast<double>(score),
                     xAOD::RejectionStep::addNewTracks,
                     xAOD::RejectionReason::trackScoreZero);
      nZeroScore++;
    } else if (m_observerTool.isEnabled() &&
           category == AmbiguityProcessor::TrackIsDuplicate){
      int input_track_uid = AmbiguityProcessor::getUid();
      m_observerTool->addInputTrack(input_track_uid, *pThisTrack);
      m_observerTool->updateTrackMap(input_track_uid,
                     static_cast<double>(score),
                     xAOD::RejectionStep::addNewTracks,
                     xAOD::RejectionReason::duplicateTrack);
      nDuplicates++;
    }
  }
  {
     std::lock_guard<std::mutex> lock(m_statMutex);
     m_stat += stat;
  }
  if (m_observerTool.isEnabled()){
    if ((unsigned int) (nZeroScore+nDuplicates+nToMap) != tracks.size()){
      ATH_MSG_ERROR("(nZeroScore+nDuplicates+nToMap) = "<<nZeroScore+nDuplicates+nToMap<<" but tracks.size() = "<<tracks.size());
    }
    else{
      ATH_MSG_DEBUG("Track observer too sanity check passed!");
    }
  }
}

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.

{ return m_detStore; }

dumpStat()

void Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::dumpStat

(

MsgStream &

out

)

const

Definition at line 361 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

{
   auto parseFileName=[](const std::string & fullname){
     auto dotPosition = fullname.rfind('.');
     auto slashPosition = fullname.rfind('/');
     auto stringLength = dotPosition - slashPosition;
     return fullname.substr(slashPosition, stringLength);
   };
   std::streamsize ss = out.precision();
   int iw=9;
   out << "Output from ";
   out << parseFileName(__FILE__);
   out << "::";
   out << __func__;
   out << "\n";
   out << "------------------------------------------------------------------------------------" << "\n";
   out << "  Number of events processed      :   "<< m_stat.globalCount(Counter::nEvents) << "\n";
   if (m_stat.globalCount(Counter::nInvalidTracks)>0) {
      out << "  Number of invalid tracks        :   "<< m_stat.globalCount(Counter::nInvalidTracks) << "\n";
   }
   if (m_stat.globalCount(Counter::nTracksWithoutParam)>0) {
      out << "  Tracks without parameters       :   "<< m_stat.globalCount(Counter::nTracksWithoutParam) << "\n";
   }
   out << "  statistics by eta range          ------All---Barrel---Trans.-- Endcap-- Forwrd-- " << "\n";
   out << "------------------------------------------------------------------------------------" << "\n";
   out << m_stat.dumpRegions("  Number of candidates at input   :",    ScoreCategory::kNcandidates,iw);
   out << m_stat.dumpRegions("  - candidates rejected score 0   :",    ScoreCategory::kNcandScoreZero,iw);
   out << m_stat.dumpRegions("  - candidates rejected as double :",    ScoreCategory::kNcandDouble,iw);
   out << "------------------------------------------------------------------------------------" << "\n";
   out << std::setiosflags(std::ios::fixed | std::ios::showpoint) << std::setprecision(2)
       << "    definition: ( 0.0 < Barrel < " << m_etaBounds[Counter::iBarrel] << " < Transition < " << m_etaBounds[Counter::iTransi]
       << " < Endcap < " << m_etaBounds[Counter::iEndcap] << " < Forward < " << m_etaBounds[Counter::iForwrd] << " )" << "\n";
   out << "------------------------------------------------------------------------------------" << "\n";
   out << std::setprecision(ss);
}

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.

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

{ 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::DenseEnvironmentsAmbiguityScoreProcessorTool::finalize ( )

finaloverridevirtual

Definition at line 74 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

                                                         {
  return StatusCode::SUCCESS;
}

initialize()

StatusCode Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::initialize ( )

finaloverridevirtual

Definition at line 47 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

                                                           {
  StatusCode sc = StatusCode::SUCCESS;
  ATH_CHECK( m_scoringTool.retrieve());
  ATH_CHECK( m_assoTool.retrieve()) ;
  ATH_CHECK( m_assoToolNotGanged.retrieve( DisableTool{m_assoToolNotGanged.empty()} )) ;
  ATH_CHECK( m_assoMapName.initialize(!m_assoMapName.key().empty()) );
 
  ATH_CHECK(m_splitProbTool.retrieve( DisableTool{m_splitProbTool.empty()} ));
  ATH_CHECK(m_clusterSplitProbContainerIn.initialize(!m_clusterSplitProbContainerIn.key().empty()) );
  ATH_CHECK(m_clusterSplitProbContainerOut.initialize(!m_clusterSplitProbContainerOut.key().empty()) );
 
  ATH_CHECK( m_splitClusterMapKey_last.initialize(!m_splitClusterMapKey_last.key().empty()) );
  ATH_CHECK( m_splitClusterMapKey.initialize(!m_splitClusterMapKey.key().empty()) );
 
  ATH_CHECK(m_observerTool.retrieve(DisableTool{m_observerTool.empty()}));
 
  if (m_etaBounds.size() != Counter::nRegions) {
     ATH_MSG_FATAL("There must be exactly " << (Counter::nRegions) << " eta bounds but "
                   << m_etaBounds.size() << " are set." );
     return StatusCode::FAILURE;
  }
 
  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::ITrackAmbiguityScoreProcessorTool::interfaceID ( )

inlinestaticinherited

Definition at line 37 of file ITrackAmbiguityScoreProcessorTool.h.

{
    return IID_ITrackAmbiguityScoreProcessorTool;
}

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.

overlappingTracks()

void Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::overlappingTracks ( const TracksScores *  scoreTrackMap, InDet::PixelGangedClusterAmbiguities *  splitClusterMap, Trk::ClusterSplitProbabilityContainer &  splitProbContainer, Trk::PRDtoTrackMap &  prd_to_track_map  ) const

private

Find SiS Tracks that share hits in the track score map.

Definition at line 270 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

{
  const Trk::IPRDtoTrackMapTool *the_asso_tool = (m_assoToolNotGanged.isEnabled() ? &(*m_assoToolNotGanged) : &(*m_assoTool));
  // Function currently does nothing useful except for printing debug information
  ATH_MSG_DEBUG ("Starting to resolve overlapping tracks");
  // Map to add all pixel clusters on track to
  std::map< const InDet::PixelCluster*, const Trk::TrackParameters* > setOfPixelClustersOnTrack;
  std::map< const InDet::PixelCluster*, const Trk::Track* > setOfPixelClustersToTrackAssoc;
  // Fill pixel cluster into the above map
  // Fill all PRD infromation into the association tool
  for( const std::pair<const Track*, float>& scoredTracksItem : *scoredTracks ){
    // clean it out to make sure not to many shared hits
    ATH_MSG_VERBOSE ("--- Adding next track "<<scoredTracksItem.first
                     << ":" << (scoredTracksItem.first->trackParameters() ? scoredTracksItem.first->trackParameters()->front()->pT() : -1.)
                     << ", " << scoredTracksItem.first->measurementsOnTrack()->size()
                     <<"\t with score "<<-scoredTracksItem.second << " to PRD map");
    
    //  This should only be done in region defined by Jets 
    //  ..... for now let do the whole detector coudl be slow
    if(the_asso_tool->addPRDs( prdToTrackMap, *scoredTracksItem.first ).isSuccess()){
      ATH_MSG_VERBOSE("--- Added hits to the association tool");
    } else {
      ATH_MSG_VERBOSE("--- Failed to add hits to the association tool");
      continue;    
    }  
    // get all prds on 'track'
    const Trk::TrackStates* tsosVec = scoredTracksItem.first->trackStateOnSurfaces();  
    if(!tsosVec){
      ATH_MSG_WARNING("TSOS vector does not exist");
      continue;   
    }
    ATH_MSG_VERBOSE("---> Looping over TSOS's to allow  for cluster updates: "<< tsosVec->size() );
    Trk::TrackStates::const_iterator tsos = tsosVec->begin();
    for (; tsos != tsosVec->end(); ++tsos) {
      const MeasurementBase* measurement = (*tsos)->measurementOnTrack();
      if(!measurement || ! (*tsos)->trackParameters()){
        ATH_MSG_VERBOSE("---- TSOS has either no measurement or parameters: "<< measurement << "  " << (*tsos)->trackParameters() );
        continue;
      }
      if (!measurement->type(Trk::MeasurementBaseType::RIO_OnTrack)) continue;
      const Trk::RIO_OnTrack* rio = static_cast<const Trk::RIO_OnTrack*>(measurement);
      if (rio->rioType(Trk::RIO_OnTrackType::PixelCluster)) {
         const InDet::PixelCluster* pixel = static_cast<const InDet::PixelCluster*> ( rio->prepRawData() );
         assert( pixel);
         //Update the pixel split information if the element is unique (The second element of the pair indiciates if the element was inserted into the map)
         auto ret =  setOfPixelClustersOnTrack.insert(std::make_pair( pixel, (*tsos)->trackParameters() ));
         if (ret.second && m_splitProbTool.isEnabled()) {
            updatePixelSplitInformationForCluster( *(ret.first), splitClusterMap, splitProbContainer);
         }
         setOfPixelClustersToTrackAssoc.insert( std::make_pair( pixel, scoredTracksItem.first ) );
      }
    }
  }
  if (msgLvl(MSG::VERBOSE)) {
  // now loop as long as map is not empty
     std::vector< std::pair< const InDet::PixelCluster*, const Trk::Track* > > sorted;
     sorted.reserve( setOfPixelClustersToTrackAssoc.size() );
     for( const std::pair< const InDet::PixelCluster* const, const Trk::Track* > &pixelTrackItem : setOfPixelClustersToTrackAssoc ) {
        sorted.emplace_back(pixelTrackItem );
     }
     std::sort( sorted.begin(), sorted.end(), [](const std::pair< const InDet::PixelCluster*, const Trk::Track* > &a,
                                                 const std::pair< const InDet::PixelCluster*, const Trk::Track* > &b) {
                                                 return a.first->getHashAndIndex().collHash() < b.first->getHashAndIndex().collHash()
                                                    || ( a.first->getHashAndIndex().collHash() == b.first->getHashAndIndex().collHash()
                                                         &&  a.first->getHashAndIndex().objIndex() < b.first->getHashAndIndex().objIndex() );
                                              });
     for (const std::pair< const InDet::PixelCluster*, const Trk::Track* >  &pixelTrackItem :  sorted) {
        ATH_MSG_VERBOSE ("---- Checking if track shares pixel hits if other tracks: " << pixelTrackItem.first << " with R " << pixelTrackItem.first->globalPosition().perp() );
        // find out how many tracks use this hit already
        Trk::PRDtoTrackMap::ConstPrepRawDataTrackMapRange range = prdToTrackMap.onTracks( *pixelTrackItem.first );
        int numberOfTracksWithThisPrd = std::distance(range.first,range.second);
        if (msgLvl(MSG::VERBOSE)) {
           TString tracks("---- number of tracks with this shared Prd: ");
           tracks += numberOfTracksWithThisPrd;
           for (Trk::IPRD_AssociationTool::ConstPRD_MapIt it =range.first; it != range.second;++it ){
              tracks += "    ";
              tracks += Form( " %p",(void*)(it->second));
              double pt = (it->second->trackParameters() ? it->second->trackParameters()->front()->pT() : -1);
              tracks += Form(":%.3f", pt);
              tracks += Form(",%i",static_cast<int>(it->second->measurementsOnTrack()->size()));
           }
           ATH_MSG_VERBOSE (tracks);
        }
     }
  }
}

process()

void Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::process ( const TrackCollection &  tracks, Trk::TracksScores *  trackScoreTrackMap  ) const

finaloverridevirtual

Do actual processing of event.

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

Implements Trk::ITrackAmbiguityScoreProcessorTool.

Definition at line 96 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

                                                                                              {
  const EventContext& ctx = Gaudi::Hive::currentContext();
  InDet::PixelGangedClusterAmbiguities *splitClusterMap = nullptr;
  if(!m_splitClusterMapKey.key().empty()){
    if(!m_splitClusterMapKey_last.key().empty()){
      SG::ReadHandle<InDet::PixelGangedClusterAmbiguities> splitClusterMapHandle_last(m_splitClusterMapKey_last,ctx);
      if ( !splitClusterMapHandle_last.isValid() ){
        ATH_MSG_ERROR("Could not read last splitClusterMap.");
      }
      splitClusterMap =  new InDet::PixelGangedClusterAmbiguities(*splitClusterMapHandle_last);
    }
    else{
      splitClusterMap =  new InDet::PixelGangedClusterAmbiguities();
    }
  }
 
  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;
 
  // Have to write the ClusterSplitProbabilityContainer first, to allow child tools to already use this new container.
  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();
  }
 
  addNewTracks(tracks, trackScoreTrackMap);
  std::unique_ptr<Trk::PRDtoTrackMap> prdToTrackMap( m_assoToolNotGanged.isEnabled()
                                                        ? m_assoToolNotGanged->createPRDtoTrackMap()
                                                        : m_assoTool->createPRDtoTrackMap() );
  overlappingTracks(trackScoreTrackMap, splitClusterMap, *splitProbContainer, *prdToTrackMap);
  if (!m_assoMapName.key().empty()) {
     if (SG::WriteHandle<Trk::PRDtoTrackMap>(m_assoMapName,ctx).record(
                (m_assoToolNotGanged.isEnabled()
                 ? m_assoToolNotGanged->reduceToStorableMap(std::move(prdToTrackMap))
                 : m_assoTool->reduceToStorableMap(std::move(prdToTrackMap)) )).isFailure()) {
        ATH_MSG_FATAL("Failed to add PRD to track association map " << m_assoMapName.key() << ".");
     }
  }
  if(!m_splitClusterMapKey.key().empty()){
    SG::WriteHandle<InDet::PixelGangedClusterAmbiguities> splitClusterMapHandle(m_splitClusterMapKey,ctx);
    splitClusterMapHandle = std::unique_ptr<InDet::PixelGangedClusterAmbiguities>(splitClusterMap);
    if( !splitClusterMapHandle.isValid() ){
      ATH_MSG_ERROR("Could not record splitClusterMap.");
    }
  }
}

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

statistics()

void Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::statistics ( )

overridevirtual

statistics output to be called by algorithm during finalize.

Implements Trk::ITrackAmbiguityScoreProcessorTool.

Definition at line 79 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

                                                            {
   if (msgLvl(MSG::INFO)) {
      MsgStream &out=msg(MSG::INFO);
      out << " -- statistics " << "\n";
      std::lock_guard<std::mutex> lock( m_statMutex );
      dumpStat(out);
      out << endmsg;
   }
}

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.

updatePixelSplitInformationForCluster()

void Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::updatePixelSplitInformationForCluster ( const std::pair< const InDet::PixelCluster *const, const Trk::TrackParameters * > &  clusterTrkPara, InDet::PixelGangedClusterAmbiguities *  splitClusterMap, Trk::ClusterSplitProbabilityContainer &  splitProbContainer  ) const

private

Update pixel split information based using the fitted track.

Definition at line 231 of file DenseEnvironmentsAmbiguityScoreProcessorTool.cxx.

{
 
  // Recalculate the split prob with the use of the track parameters
  InDet::PixelClusterSplitProb splitProb = m_splitProbTool->splitProbability( *clusterTrkPara.first, *clusterTrkPara.second );
  // update the split prob information on the cluster --  the use of the split flag is now questionable -- possible itP will now indicate if the cluster is shared between multiple tracks
  const InDet::PixelCluster* pixelCluster = clusterTrkPara.first;
  if (msgLvl(MSG::DEBUG)) {
     const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProbCurrent = (pixelCluster
                                                                                      ? splitProbContainer.splitProbability(pixelCluster)
                                                                                      : Trk::ClusterSplitProbabilityContainer::getNoSplitProbability());
 
     ATH_MSG_DEBUG (  "---- "<< pixelCluster->globalPosition().perp()
                      <<" Updating split probs 1: " << pixelCluster->identify() << ": Old " <<  splitProbCurrent.splitProbability1() << "  New " << splitProb.splitProbability(2)
                      <<" Probs 2:  Old " << splitProbCurrent.splitProbability2() << "  New " << splitProb.splitProbability(3)
                      << "\n"
                      << " --- pixelCluster: " <<  *pixelCluster
                      << "\n"
                      << " --- trk params: " << *clusterTrkPara.second  );
  }
  const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &
     splitProbNew = splitProbContainer.setSplitInformation(pixelCluster, splitProb.splitProbability(2), splitProb.splitProbability(3));
 
  if(splitClusterMap){
    if(  splitProbNew.splitProbability2()  >=  m_sharedProbCut2){
      splitClusterMap->insert(std::make_pair( pixelCluster, pixelCluster ) );
      splitClusterMap->insert(std::make_pair( pixelCluster, pixelCluster ) );
    } else if ( splitProbNew.splitProbability1()  >=  m_sharedProbCut ){
      splitClusterMap->insert(std::make_pair( pixelCluster, pixelCluster ) );
    }
  }
 
}

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::DenseEnvironmentsAmbiguityScoreProcessorTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 134 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_assoMapName

SG::WriteHandleKey<Trk::PRDtoTrackMap> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_assoMapName {this,"AssociationMapName",""}

private

key for the PRDtoTrackMap to be used by the ambiguity process to resolve the ambiguities.

the key given to the newly created association map

Definition at line 118 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_assoTool

ToolHandle<Trk::IPRDtoTrackMapTool> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_assoTool {this, "AssociationTool", "InDet::InDetPRDtoTrackMapToolGangedPixels" }

private

Definition at line 98 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_assoToolNotGanged

ToolHandle<Trk::IPRDtoTrackMapTool> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_assoToolNotGanged {this, "AssociationToolNotGanged", "Trk::PRDtoTrackMapTool" }

private

Definition at line 101 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_clusterSplitProbContainerIn

SG::ReadHandleKey<Trk::ClusterSplitProbabilityContainer> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_clusterSplitProbContainerIn {this,"InputClusterSplitProbabilityName",""}

private

the key given to the newly created association map

Definition at line 121 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_clusterSplitProbContainerOut

SG::WriteHandleKey<Trk::ClusterSplitProbabilityContainer> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_clusterSplitProbContainerOut {this,"OutputClusterSplitProbabilityName",""}

private

the key given to the newly created association map

Definition at line 123 of file DenseEnvironmentsAmbiguityScoreProcessorTool.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_etaBounds

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

private

eta intervals for internal monitoring

Definition at line 132 of file DenseEnvironmentsAmbiguityScoreProcessorTool.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_observerTool

PublicToolHandle<Trk::ITrkObserverTool> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_observerTool {this, "ObserverTool", "", "track observer within ambiguity solver"}

private

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

Definition at line 109 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_scoringTool

ToolHandle<ITrackScoringTool> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_scoringTool {this, "ScoringTool", "Trk::TrackScoringTool/TrackScoringTool" }

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 95 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_sharedProbCut

float Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_sharedProbCut

private

NN split sprob cut for 2 particle clusters.

Definition at line 127 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_sharedProbCut2

float Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_sharedProbCut2

private

NN split sprob cut for 3 particle clusters.

Definition at line 130 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_splitClusterMapKey

SG::WriteHandleKey<InDet::PixelGangedClusterAmbiguities> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_splitClusterMapKey

private

cluster split information which m_splitClusterMap_last will be merged into

Definition at line 115 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_splitClusterMapKey_last

SG::ReadHandleKey<InDet::PixelGangedClusterAmbiguities> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_splitClusterMapKey_last

private

cluster split information generated by previous instances

Definition at line 112 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_splitProbTool

ToolHandle<InDet::IPixelClusterSplitProbTool> Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_splitProbTool {this, "SplitProbTool", "InDet::NnPixelClusterSplitProbTool/NnPixelClusterSplitProbTool" }

private

recalculate split prob tool

Definition at line 105 of file DenseEnvironmentsAmbiguityScoreProcessorTool.h.

m_statMutex

std::mutex Trk::DenseEnvironmentsAmbiguityScoreProcessorTool::m_statMutex

mutableprivate

Definition at line 133 of file DenseEnvironmentsAmbiguityScoreProcessorTool.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:

• DenseEnvironmentsAmbiguityScoreProcessorTool.h
• DenseEnvironmentsAmbiguityScoreProcessorTool.cxx