InDet::InDetDenseEnvAmbiTrackSelectionTool Class Reference

This tool cross checks the hits on a track with the hits already stored in a PRD_AssociationTool. More...

#include <InDetDenseEnvAmbiTrackSelectionTool.h>

Inheritance diagram for InDet::InDetDenseEnvAmbiTrackSelectionTool:

Collaboration diagram for InDet::InDetDenseEnvAmbiTrackSelectionTool:

Classes
struct	CacheEntry
struct	lessTrkTrack
struct	TrackHitDetails
struct	TSoS_Details

Public Member Functions
	InDetDenseEnvAmbiTrackSelectionTool (const std::string &, const std::string &, const IInterface *)
virtual	~InDetDenseEnvAmbiTrackSelectionTool ()=default
	default destructor
virtual StatusCode	initialize () override
	standard Athena-Algorithm method
virtual StatusCode	finalize () override
virtual std::tuple< Trk::Track *, bool >	getCleanedOutTrack (const Trk::Track *track, const Trk::TrackScore score, Trk::ClusterSplitProbabilityContainer &splitProbContainer, Trk::PRDtoTrackMap &prd_to_track_map, int trackId, int subtrackId) const override
	Decide what to do with a candidate track.

Private Types
enum	TsosTypes {   UnusedHit = 1 , SplitSharedHit = 2 , SharedHit = 3 , RejectedHitOverUse = 4 ,   RejectedHitInvalid = 5 , RejectedHit = 6 , Outlier = 7 , OtherTsos = 8 }

Private Member Functions
Trk::Track *	createSubTrack (const std::vector< const Trk::TrackStateOnSurface * > &tsos, const Trk::Track *track) const
	method to create a new track from a vector of TSOS's
void	fillTrackDetails (const Trk::Track *ptrTrack, Trk::ClusterSplitProbabilityContainer &splitProbContainer, const Trk::PRDtoTrackMap &prd_to_track_map, TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails) const
	Fill the two structs TrackHitDetails & TSoS_Details full of information.
void	decideWhichHitsToKeep (const Trk::Track *, const Trk::TrackScore score, Trk::ClusterSplitProbabilityContainer &splitProbContainer, Trk::PRDtoTrackMap &prd_to_track_map, TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails, CacheEntry *ent, int trackId) const
	Determine which hits to keep on this track Look at the hits on track and decided if they should be kept on the track or rejected.
bool	performConversionCheck (const Trk::Track *ptrTrack, Trk::PRDtoTrackMap &prd_to_track_map, TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails) const
	Specific logic for identifing conversions with the goal of passing those tracks through to the final collection with as little loss as possible.
bool	performHadDecayCheck (const Trk::Track *ptrTrack, Trk::PRDtoTrackMap &prd_to_track_map, TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails) const
	Specific logic for identifing boosted light particle decays in jet topologies (tau and b), with the goal of passing those tracks through to the final collection with as little loss as possible.
void	updateSharedForCollimated (TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails) const
	Handle update of the shared hit counts if either a conversion or a dense hadronic decay was identified using one of the methods above.
void	setPixelClusterSplitInformation (TSoS_Details &tsosDetails, Trk::ClusterSplitProbabilityContainer &clusterSplitProbMap) const
	Update the pixel clusters split information.
bool	inHadronicROI (const Trk::Track *ptrTrack) const
	Does track pass criteria for hadronic ROI?
bool	isHadCaloCompatible (const Trk::TrackParameters &Tp) const
	Check if the cluster is compatible with a hadronic cluster.
bool	isEmCaloCompatible (const Trk::TrackParameters &Tp) const
	Check if the cluster is compatible with a EM cluster.
bool	checkOtherTracksValidity (TSoS_Details &tsosDetails, int index, Trk::ClusterSplitProbabilityContainer &splitProbContainer, Trk::PRDtoTrackMap &prd_to_track_map, int &maxiShared, int &maxOtherNPixel, bool &maxOtherHasIBL, CacheEntry *ent) const
	Returns true if accepted tracks remain about thresholds, false otherwise maxiShared = max number of shared modules on an accepted shared track which has maxOtherNPixel pixel hits and blayer hit if maxOtherHasIBL is true.
std::pair< const Trk::TrackParameters *, const Trk::TrackParameters * >	getOverlapTrackParameters (int n, const Trk::Track *track1, const Trk::Track *track2, const Trk::PRDtoTrackMap &prd_to_track_map, int splitSharedPix) const
	Returns the Trackparameters of the two tracks on the n'th TrackStateOnSurface of the first track.
bool	isNearbyTrackCandidate (const Trk::TrackParameters *paraA, const Trk::TrackParameters *paraB) const
	Check if two sets of track paremeters are compatible with being from a the same low mass particle decay.
bool	clusCanBeSplit (float splitProb1, float splitProb2) const
	Simple helper functions to tell is cluster is split.
bool	isTwoPartClus (float splitProb1, float splitProb2) const
bool	isMultiPartClus (float splitProb2) const

Static Private Member Functions
static void	newEvent (CacheEntry *ent)
	Fill hadronic & EM cluster map.
static void	rejectHitOverUse (TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails, int index)
static void	rejectHit (TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails, int index)
static void	rejectSharedHit (TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails, int index)
static void	rejectSharedHitInvalid (TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails, int index)
static void	sharedToSplitPix (TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails, int index)
static void	addSharedHit (TrackHitDetails &trackHitDetails, TSoS_Details &tsosDetails, int index)
static void	increaseSharedHitCounters (TrackHitDetails &trackHitDetails, bool isPix, bool isSCT)
static void	decreaseSharedHitCounters (TrackHitDetails &trackHitDetails, bool isPix, bool isSCT)

Private Attributes
std::mutex	m_mutex
SG::SlotSpecificObj< CacheEntry > m_cache	ATLAS_THREAD_SAFE
PublicToolHandle< ITrtDriftCircleCutTool >	m_selectortool {this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"}
	TRT minimum number of drift circles tool- returns allowed minimum number of TRT drift circles.
ServiceHandle< IInDetEtaDependentCutsSvc >	m_etaDependentCutsSvc {this, "InDetEtaDependentCutsSvc", ""}
	ITk eta-dependet cuts.
const SiliconID *	m_detID {nullptr}
	atlas id helper
ToolHandle< Trk::IPRDtoTrackMapTool >	m_assoTool {this, "AssociationTool", "InDet::InDetPRDtoTrackMapToolGangedPixels" }
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'.
IntegerProperty	m_minHits {this, "minHits", 5, "Min Number of hits on track"}
	some cut values
IntegerProperty	m_minTRT_Hits {this, "minTRTHits", 0, "Min Number of TRT hits on track"}
IntegerProperty	m_maxSharedModules {this, "maxShared", 1, "Max number of shared modules"}
IntegerProperty	m_maxTracksPerPRD {this, "maxTracksPerSharedPRD", 2, "Max number of tracks per hit. When NN is used, other flags set the limits."}
IntegerProperty	m_minNotSharedHits {this, "minNotShared", 6, "Min number of non shared hits"}
FloatProperty	m_minScoreShareTracks {this, "minScoreShareTracks", 0.0, "Min track score to alow it to share hits"}
BooleanProperty	m_cosmics {this, "Cosmics", false, "Trying to reco cosmics?"}
BooleanProperty	m_parameterization {this, "UseParameterization", true, "Use table of min number DCs"}
BooleanProperty	m_doPixelClusterSplitting {this, "doPixelSplitting", false, "Split pixel clusters"}
FloatProperty	m_sharedProbCut {this, "sharedProbCut", 0.3, "Min split prob to break a cluster into two parts"}
FloatProperty	m_sharedProbCut2 {this, "sharedProbCut2", 0.3, "Min split prob to break a clsuter into three parts"}
FloatProperty	m_minTrackChi2ForSharedHits {this, "minTrackChi2ForSharedHits", 3, "Min track chi2 to split share hits"}
IntegerProperty	m_minUniqueSCTHits {this, "minUniqueSCTHits", 2, "Min number of hits in the SCT that we need before we allow hit sharing in the SCT"}
IntegerProperty	m_minSiHitsToAllowSplitting {this, "minSiHitsToAllowSplitting", 9, "Min number of hits before we allow split sharing of hits"}
IntegerProperty	m_maxPixOnePartCluster {this, "maxPixOnePartCluster", 2, "Max number of tracks that can be associated to a 1 particle cluster"}
IntegerProperty	m_maxPixTwoPartCluster {this, "maxPixTwoPartCluster", 2, "Max number of tracks that can be associated to a 2 particle cluster"}
IntegerProperty	m_maxPixMultiCluster {this, "maxPixMultiCluster", 4, "Max number of tracks that can be associated to a >= 3 particle cluster"}
BooleanProperty	m_shareSplitHits {this, "shareSplitHits", false, "Allow shared hits to be shared on 1 more track"}
IntegerProperty	m_minPixHitAccepted {this, "minPixHitAccepted", 2, "Min number of pixel hits needed to be allowed to push accepted tracks over shared module limits"}
BooleanProperty	m_useHClusSeed {this, "doHadCaloSeed", false}
BooleanProperty	m_skipAmbiInROI {this, "doSkipAmbiInROI", false}
FloatProperty	m_minPtSplit {this, "minPtSplit", 0.}
FloatProperty	m_minPtBjetROI {this, "minPtBjetROI", 15000., "in MeV"}
FloatProperty	m_phiWidth {this, "phiWidth", 0.2}
FloatProperty	m_etaWidth {this, "etaWidth", 0.2}
SG::ReadHandleKey< ROIPhiRZContainer >	m_inputHadClusterContainerName {this, "HadROIPhiRZContainer", ""}
BooleanProperty	m_useEmClusSeed {this, "doEmCaloSeed", false}
FloatProperty	m_phiWidthEm {this, "phiWidthEM", 0.05}
FloatProperty	m_etaWidthEm {this, "etaWidthEM", 0.05}
SG::ReadHandleKey< ROIPhiRZContainer >	m_inputEmClusterContainerName {this, "EMROIPhiRZContainer", ""}
BooleanProperty	m_doPairSelection {this, "doPairSelection", true}
FloatProperty	m_minPairTrackPt {this, "minPairTrackPt", 1000., "In MeV"}
BooleanProperty	m_monitorTracks {this, "MonitorAmbiguitySolving", false, "to track observeration/monitoring (default is false)"}

Detailed Description

This tool cross checks the hits on a track with the hits already stored in a PRD_AssociationTool.

Shared hits are allowed to some extent und under certain conditions (e.g. the track score is high enough), additional shared hits are removed if necessary. This tool does not delete any tracks. If the client is going to discard tracks entered into this tool, the tracks have to be deleted by this client.

Definition at line 60 of file InDetDenseEnvAmbiTrackSelectionTool.h.

Member Enumeration Documentation

TsosTypes

enum InDet::InDetDenseEnvAmbiTrackSelectionTool::TsosTypes

private

Enumerator
UnusedHit
SplitSharedHit
SharedHit
RejectedHitOverUse
RejectedHitInvalid
RejectedHit
Outlier
OtherTsos

Definition at line 91 of file InDetDenseEnvAmbiTrackSelectionTool.h.

                   {
      // A measurement not yet used in any other track
      UnusedHit   = 1,
      // A measurement shared with another track that can be split
      SplitSharedHit = 2, 
      // A measurement shared with another track
      SharedHit   = 3, 
      // A hit that needs to be removed from the track 
      // because it is used on too many tracks already
      RejectedHitOverUse = 4,
      // A hit that needs to be removed from the track
      // because sharing it would invalidate an accepted track
      RejectedHitInvalid = 5,
      // A hit that needs to be removed from the track
      // reason other than the above two
      RejectedHit = 6,
      // an outlier, to be copied in case
      Outlier     = 7,
      // other TSOS types to be copied in case
      OtherTsos   = 8
    };

Constructor & Destructor Documentation

InDetDenseEnvAmbiTrackSelectionTool()

InDet::InDetDenseEnvAmbiTrackSelectionTool::InDetDenseEnvAmbiTrackSelectionTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 33 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

:
base_class(t,n,p){}

~InDetDenseEnvAmbiTrackSelectionTool()

virtual InDet::InDetDenseEnvAmbiTrackSelectionTool::~InDetDenseEnvAmbiTrackSelectionTool ( )

virtualdefault

default destructor

Member Function Documentation

addSharedHit()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::addSharedHit ( TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails, int index )

inlinestaticprivate

Definition at line 1668 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                          {
  tsosDetails.m_type[index] = SharedHit;
  increaseSharedHitCounters( trackHitDetails, (tsosDetails.m_detType[index]%10 == 1), (tsosDetails.m_detType[index]%10 == 2) );
}

checkOtherTracksValidity()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::checkOtherTracksValidity ( TSoS_Details & tsosDetails, int index, Trk::ClusterSplitProbabilityContainer & splitProbContainer, Trk::PRDtoTrackMap & prd_to_track_map, int & maxiShared, int & maxOtherNPixel, bool & maxOtherHasIBL, CacheEntry * ent ) const

private

Returns true if accepted tracks remain about thresholds, false otherwise maxiShared = max number of shared modules on an accepted shared track which has maxOtherNPixel pixel hits and blayer hit if maxOtherHasIBL is true.

Definition at line 354 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
 
  // Hits here are only shared hits. 
  // Assumption: the decision to split has been done outside this function
  if( tsosDetails.m_type[index] != SharedHit ) {
    ATH_MSG_WARNING("Calling checkOtherTracksValidity with a hit that is not shared!");
    return true;
  }
 
  // needed?
  const Trk::RIO_OnTrack* rot = tsosDetails.m_RIO[index];
 
  // get list of tracks that use this hit already
  int numberOfTracksWithThisPrd = tsosDetails.m_hitIsShared[index];
  ATH_MSG_VERBOSE ("---> number of tracks with this shared Prd: " << numberOfTracksWithThisPrd << " maxtracks: " << m_maxTracksPerPRD);
 
  // check if adding one more shared hit would push any accepted track 
  //  -over the limit of shared hits
  //  -under the limit of unique hits
  maxiShared = -1;
  bool otherwillFailMinHits = false;
  bool otherwillFailSCTuniqueHits = false;
 
  //Setup counters
  int  iSharedMod     = 0;  //Number of Shared modules on the accepted track (will include this hit)
  int  iNotShared     = 0;  //Number of unshared hits on the accepted track
  int  iSctUnique     = 0;  //Number of unique SCT hits on the accepted track 
  int  iPixel         = 0;  //Number of pixel hits on the accepted track
  int  iSCT           = 0;  //Number of SCT hits on the accepted track
  bool iHasBlayer     = false; // Does the accepted track have a b-layer hit
 
  // loop over all tracks that have this hit and make sure none fail
  //  - requirement on unique hits
  //  - requirement on shared modules
  //  - requirement on unique sct hits
  //  send back some information about the most overlapping track
  auto currentHitsSharedTracks = tsosDetails.m_tracksSharingHit.equal_range(index);
  for ( auto track = currentHitsSharedTracks.first; track != currentHitsSharedTracks.second; ++track ){
 
    //Count up the hit properties of the track you are inspecting 
    iSharedMod     = 0;
    iNotShared     = 0;             
    iSctUnique     = 0;
    iPixel         = 0;
    iHasBlayer     = false;
    iSCT           = 0; 
 
    std::vector< const Trk::PrepRawData* > prdsToCheck = m_assoTool->getPrdsOnTrack(prd_to_track_map, *(track->second));
    for (const Trk::PrepRawData* prdToCheck : prdsToCheck) {
      bool isPixel(false);
      bool isSplitPixel(false);
      if (m_detID->is_pixel(prdToCheck->identify())) {
        isPixel = true;
        if (prdToCheck->type(Trk::PrepRawDataType::PixelCluster)){
          const InDet::PixelCluster* constPixelCluster = static_cast<const InDet::PixelCluster*> ( prdToCheck  );
          const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProb = splitProbContainer.splitProbability(constPixelCluster);
          if ( splitProb.isSplit() )  {
            isSplitPixel = true;
          }
        }
 
        ++iPixel;
        if (m_detID->is_blayer(prdToCheck->identify()) ) iHasBlayer=true;
      }
 
      if ( m_detID->is_sct(prdToCheck->identify()) ) {
        ++iSCT;
      }
 
      //
      // count for general cases considering current flags (i.e. if split can be shared)
      // hit which are overused, are rejected and should not be in this part of the code
      //  if hit is new one to be shared, count it as shared
      //    - the new cluster to be shared is not a split cluster (that is why we are here)
      //    - this will count correctly if a split hit can also be shared
      if ( rot->prepRawData() == prdToCheck ) {
        iSharedMod += isPixel ? 2 : 1;
      //  else if hit is not the new hit to be shared, then see if it is already shared
      //    - if so, count considering if it is split or not
      } else if ( prd_to_track_map.isShared( *prdToCheck ) ) {
        iSharedMod += isSplitPixel ? 0 : isPixel ? 2 : 1;
      //  else 
      //    - not a shared cluster
      } else {
        ++iNotShared;
        if (m_detID->is_sct(prdToCheck->identify())){
          ++iSctUnique;
        }
      }
    } // loop over PRDs
 
    ATH_MSG_VERBOSE( "Track " <<  track->second << " will has " << iNotShared << " unique hits and  " <<  iSctUnique << " unique SCT hits.");
    // You are sharing too many hits reject the new track
    // TODO does not include dead modules! Can we get that from the track summary?
    if ( iNotShared  < ent->m_minNotShared ) otherwillFailMinHits = true;
    // You are sharing SCT hits and don't have enough to share -reject hit.
    if ( iSCT > iSctUnique && iSctUnique < m_minUniqueSCTHits ) otherwillFailSCTuniqueHits = true;    
  } // loop over tracks
    
  // Update details for the track with the most shared hits          
  if ( iSharedMod > maxiShared){
    maxiShared        = iSharedMod;
    maxOtherNPixel    = iPixel;
    maxOtherHasIBL    = iHasBlayer;
  }
   
  return !( otherwillFailMinHits || otherwillFailSCTuniqueHits );
}

clusCanBeSplit()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::clusCanBeSplit ( float splitProb1, float splitProb2 ) const

inlineprivate

Simple helper functions to tell is cluster is split.

Definition at line 1617 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  return ( isTwoPartClus(splitProb1, splitProb2) || isMultiPartClus(splitProb2) );
}

createSubTrack()

Trk::Track * InDet::InDetDenseEnvAmbiTrackSelectionTool::createSubTrack ( const std::vector< const Trk::TrackStateOnSurface * > & tsos, const Trk::Track * track ) const

private

method to create a new track from a vector of TSOS's

Definition at line 1421 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  std::vector<const Trk::TrackStateOnSurface*>::const_iterator tsosit=tsos.begin();
  int nmeas=0;
  for (;tsosit!=tsos.end();++tsosit){
    if ((**tsosit).type(Trk::TrackStateOnSurface::Measurement)) ++nmeas;
  }
  if (nmeas<3) {
    ATH_MSG_DEBUG ("Less than 3 measurements, reject track !");
    return nullptr;
  }
 
  auto vecTsos = std::make_unique<Trk::TrackStates>();
 
  // loop over TSOS, copy TSOS and push into vector
  for (const Trk::TrackStateOnSurface* iTsos : tsos) {
    const Trk::TrackStateOnSurface* newTsos = new Trk::TrackStateOnSurface(*iTsos);
    vecTsos->push_back(newTsos);
  }
 
  Trk::TrackInfo info;
  info.addPatternRecoAndProperties(track->info());
  Trk::TrackInfo newInfo;
  newInfo.setPatternRecognitionInfo(Trk::TrackInfo::InDetAmbiTrackSelectionTool);
  info.addPatternReco(newInfo);
 
  Trk::Track* newTrack = new Trk::Track(info, std::move(vecTsos),nullptr);
  
  return newTrack;
 
}

decideWhichHitsToKeep()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::decideWhichHitsToKeep ( const Trk::Track * ptrTrack, const Trk::TrackScore score, Trk::ClusterSplitProbabilityContainer & splitProbContainer, Trk::PRDtoTrackMap & prd_to_track_map, TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails, CacheEntry * ent, int trackId ) const

private

Determine which hits to keep on this track Look at the hits on track and decided if they should be kept on the track or rejected.

The decision focuses on the track in question and how often clusters are used Within getCleanedOutTrack (from which this is called), accepted tracks are checked to see if they are pushed over limits

Definition at line 666 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
 
  // Can the track automatically be accepted without further checks
  trackHitDetails.m_trkCouldBeAccepted = true;
 
  // Does this track fall into an hadronic ROI?
  trackHitDetails.m_passHadronicROI = false;
  if( m_useHClusSeed && inHadronicROI(ptrTrack) ) {
    trackHitDetails.m_passHadronicROI = true;
  }
 
 
  //------------------------------------------------------------------//
  // Should a shared hit be called shared or is it compatible with multiple clusters?
  // this flag controls if the additional information is conisdered and shared hits on this track
  // are "recovered" from the shared state to the split state
  // 
  // First criteria are checked which would NOT allow recovery
  // Then override criteria are checked
  bool recoverSharedHits(true);
  // reasons NOT to consider the information
  // not above pT for splitting
  if( ptrTrack->trackParameters()->front()->pT() < m_minPtSplit ) { recoverSharedHits = false; }
  // score too low
  if(score <= m_minScoreShareTracks) { recoverSharedHits = false; }
  // the following 2 cuts use information from the track summary stored in the details struct
  // not enough SiHits 
  if(trackHitDetails.m_numPixelHits+trackHitDetails.m_numSCTHits < m_minSiHitsToAllowSplitting) {
    recoverSharedHits = false;
  }
  // too many holes
  if(trackHitDetails.m_numPixelHoles>1) { recoverSharedHits = false; }
 
 
 
  //------------------------------------------------------------------//
  //
  // loop over all measurements, make decisions, increment counters
  //
  for (unsigned int index(0);  index  < tsosDetails.m_nTSoS; ++index ){
    //Skip all non-measurement TSOS's 
    if (tsosDetails.m_type[index] == OtherTsos) { continue; }
 
    // in fillTrackDetails, if an error, cluster could be rejected
    // also shared TRT hits are rejected there
    if (tsosDetails.m_type[index] == RejectedHit) {  // only generic rejects at that point
      trackHitDetails.m_trkCouldBeAccepted = false; // we have to remove at least one PRD
      if (m_observerTool.isEnabled()){
        m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::TSOSRejectedHit);
      }
      continue;
    }
 
    // Keep all unused hits
    if (tsosDetails.m_type[index] == UnusedHit ){
      if ( tsosDetails.m_detType[index] == 3 ) {
        ++trackHitDetails.m_numTRT_Unused;
      } else {
        ++trackHitDetails.m_numUnused;
        if ( tsosDetails.m_detType[index] == 2 ) { ++trackHitDetails.m_numSCT_Unused; }
      }
      continue;
    }
 
    //===================================================================//
    //
    // OUTLIERS - not type Outlier is given to both Shared and UnShared hits. Sort it out here
    // Note in fillTrackDetails, for outliers we saved "1" in m_hitIsShared for any used hit, 
    // even if the true value is higher. As we will reject them here, it does not matter 
    // how many it is shared with
    // if a pattern track 
    //    - used   : reject the hit
    //    - unused : call it unused and move on (reintegration of pattern outliers)
    // if fitted track
    //    - used   : reject the hit
    //    - unused : keep it but do not call it an unused hit (not counted towards total SiHit count)
    //
    if( tsosDetails.m_type[index] == Outlier ) {
 
      // if on another track, get it off of this one
      // for an outlier, we need to check m_hitIsShared to see if it used
      if( tsosDetails.m_hitIsShared[index]>0 ) { // hit is used on another track
        ATH_MSG_VERBOSE( Form("---> Prd is outlier and shared, reject it. %d", index) );
        rejectHit(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::TSOSOutlierShared);
        }
        continue;
      }
 
      if(trackHitDetails.m_isPatternTrack) {
 
        // For pattern tracks:
        // if used   : reject it  --> see above
        // if unused : reintegrate it and send to track fit
        ATH_MSG_VERBOSE ( Form("---> Prd is outlier on a pattern track and is unused, %d", index) );
        // change to unused hit, increment counter
        tsosDetails.m_type[index] = UnusedHit;  // change name so m_numUnused matches types on track
        ++trackHitDetails.m_numUnused;
        if( tsosDetails.m_detType[index]%10 == 2 ) { ++trackHitDetails.m_numSCT_Unused; }
        continue;
      }
      else { // is outlier on fitted track and ...
        // used  : reject the hit --> see above
        // unused: send it through, but do not count it towards the hit content
        ATH_MSG_DEBUG( Form("---> Prd is outlier on a fitted track and is unused, %d", index) );
        continue;
      } // m_isPatternTrack or not
    } // isOutlier or not
    //===================================================================//
 
    // cleaning cut: fitted track with 1 pixel hit without an IBL hit
    /* hurts conversion performance, slighly better perf in min-bias without it
     * but high pT jets can use this in the core
    if(!trackHitDetails.m_isPatternTrack  &&  // fitted track
        trackHitDetails.m_numPixelHits==1 &&  // 1 pixel hit
        !trackHitDetails.m_thisHasIBLHit  &&  // no IBL hits
        tsosDetails.m_detType[index]%10 == 1  && // index is the pixel hit
        !(tsosDetails.m_type[index]==Outlier)) { // and it is not an outlier) 
       ATH_MSG_VERBOSE ("-> Special case, problematic single pixel hit on fitted track, reject it !");
       TrkCouldBeAccepted = false; // we have to remove at least one PRD
       tsosDetails.m_type[index]    = RejectedHit;
       continue;             
    }
    */
 
    // At this point, only hits labeled shared from fillTrackDetails
    if( tsosDetails.m_type[index] != SharedHit ) {
      ATH_MSG_ERROR("A NON-Shared hit is being treated as one!");
    }
 
    //===================================================================//
    // Try and recover shared hits if
    //   - pixel cluster splitting flag is turned on
    //   - track passes criteria for cluster splitting
    //   - is a pixel hit
    if ( m_doPixelClusterSplitting && recoverSharedHits && tsosDetails.m_detType[index]%10 == 1 ) {
 
      //Find the index of the previous measurement on track
      int indexPreviousMeasurement = tsosDetails.findIndexOfPreviousMeasurement(index);
      if (indexPreviousMeasurement > 0 ) {
        ATH_MSG_VERBOSE ("--> Previous Measurement was at : " << indexPreviousMeasurement 
            << " and was a: "  << tsosDetails.m_type[indexPreviousMeasurement] 
            << " with splitprob1 " << tsosDetails.m_splitProb1[indexPreviousMeasurement] 
            << " and splitprob2 "  << tsosDetails.m_splitProb2[indexPreviousMeasurement]);
      }
 
      // If the previous measurement is a shared pixel and the current pixel 
      //  - wants to be shared 
      //  - and is compatible with being from multiple clusters
      // allow the previous measurement to be shared with up to m_maxTracksPerPRD tracks without penalty 
      if ( indexPreviousMeasurement >= 0 && 
          tsosDetails.m_type[indexPreviousMeasurement] == SharedHit &&
          tsosDetails.m_hitIsShared[indexPreviousMeasurement] < m_maxTracksPerPRD &&
          clusCanBeSplit(tsosDetails.m_splitProb1[index],tsosDetails.m_splitProb2[index]) ) {
 
        // Check if the previous shared hit shared on the same track as this one 
        bool sharedbetweenthesametracks = false;
        auto previousHitsSharedTracks = tsosDetails.m_tracksSharingHit.equal_range(indexPreviousMeasurement);
        auto currentHitsSharedTracks  = tsosDetails.m_tracksSharingHit.equal_range(index);
        for (auto iteratorP = previousHitsSharedTracks.first; 
            iteratorP != previousHitsSharedTracks.second; ++iteratorP) {
          for (auto iteratorC = currentHitsSharedTracks.first; 
              iteratorC != currentHitsSharedTracks.second; ++iteratorC) {
            if ( iteratorC->second == iteratorP->second){
              sharedbetweenthesametracks = true;
              break;                
            }
          }
          if (sharedbetweenthesametracks) break;
        }
        if (sharedbetweenthesametracks){
          sharedToSplitPix(trackHitDetails, tsosDetails, indexPreviousMeasurement);
        }          
      } 
 
      //
      //  Check the number network. 
      //   - check if the particle is compatible with 2 particles
      //   - else check if particle is compatible with >= 3 particles
      //   - else it is a 1 particle cluster
      //   Is a 2 particle cluster?
      if ( isTwoPartClus(tsosDetails.m_splitProb1[index],tsosDetails.m_splitProb2[index]) ) {
 
        // can be split, but how many accepted tracks use the hit?
        // okay to share
        if (tsosDetails.m_hitIsShared[index] < m_maxPixTwoPartCluster) {
          ATH_MSG_VERBOSE ("---> Pixel cluster is to be split shared with another track: Split Prob1 " << tsosDetails.m_splitProb1[index] );
          tsosDetails.m_type[index] = SplitSharedHit;
          ++trackHitDetails.m_numSplitSharedPix;
          continue;
        } else if(m_shareSplitHits && tsosDetails.m_hitIsShared[index] == m_maxPixTwoPartCluster) { 
          // if we allow split hits to also be shared
          //  - the first m_maxPixTwoPartCluster cluster get to use it without penalty
          //  - the m_maxPixTwoPartCluster+1 cluster gets called shared
          ATH_MSG_VERBOSE ("---> Pixel cluster is split, but must be called shared to stay on this track!");
          addSharedHit(trackHitDetails, tsosDetails, index);
          continue;
        } else {
          ATH_MSG_VERBOSE ("---> Pixel split but shared between too many tracks -- will be removed from the track!!!");
          rejectHitOverUse(trackHitDetails, tsosDetails, index);
          if (m_observerTool.isEnabled()){
            m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::pixelSplitButTooManyShared2Ptc);
          }
          continue;
        }
 
        //  Is a 3+ particle cluster?
      } else if ( isMultiPartClus(tsosDetails.m_splitProb2[index]) ) {
 
        // can be split, but how many accepted tracks use the hit?
        // okay to share
        if (tsosDetails.m_hitIsShared[index] < m_maxPixMultiCluster ){
          ATH_MSG_VERBOSE ("---> Pixel cluster is to be split shared with another track: Split Prob2 " <<  tsosDetails.m_splitProb2[index] );
          tsosDetails.m_type[index] = SplitSharedHit;
          ++trackHitDetails.m_numSplitSharedPix;
          continue;             
        } else if(m_shareSplitHits && tsosDetails.m_hitIsShared[index] == m_maxPixMultiCluster) { 
          // if we allow split hits to also be shared
          //  - the first m_maxPixMultiCluster cluster get to use it without penalty
          //  - the m_maxPixMultiCluster+1 cluster gets called shared
          ATH_MSG_VERBOSE ("---> Pixel cluster is split, but must be called shared to stay on this track!");
          addSharedHit(trackHitDetails, tsosDetails, index);
          continue;
        } else {
          ATH_MSG_VERBOSE ("---> Pixel split but shared between too many tracks -- will be removed from the track!!!");
          rejectHitOverUse(trackHitDetails, tsosDetails, index);
          if (m_observerTool.isEnabled()){
            m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::pixelSplitButTooManyShared3Ptc);
          }
          continue;
        }
 
      }  // end of checking number network output
 
      ATH_MSG_VERBOSE("---> Pixel cluster is not compatible with being shared (splitProb1 = " 
          << tsosDetails.m_splitProb1[index] << "), (splitProb2 = " 
          << tsosDetails.m_splitProb2[index] << ") , reject shared hit !!!");
      if ( tsosDetails.m_hitIsShared[index] < m_maxPixOnePartCluster ) {
        // this is a shared cluster
        addSharedHit(trackHitDetails, tsosDetails, index);
        continue;
      } else {
        ATH_MSG_DEBUG ("reject track; Too many hits shared - we have to remove at least one PRD");    
        rejectHitOverUse(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::tooManySharedRecoverable);
        }
        continue; 
      }
    }// End Attempt to recover shared hits
    //===================================================================//
 
    if( tsosDetails.m_hitIsShared[index] == 0 ) {
      ATH_MSG_ERROR("A hit is not shared but is where only shared hits should be");
    }
 
    //For all other shared hits 
    if ( tsosDetails.m_hitIsShared[index] < m_maxTracksPerPRD ){  // we do not allow to share with too many tracks
      ATH_MSG_VERBOSE ("---> Shared hit, but good track, let's enter hit in the list and try to keep it !");
      ATH_MSG_VERBOSE ("----- Index: "<< index << " Type: " << tsosDetails.m_detType[index]  << " splitprob1  " << tsosDetails.m_splitProb1[index]);
      addSharedHit(trackHitDetails, tsosDetails, index);
      continue;
    } else {
      ATH_MSG_DEBUG ("reject track; Too many hits shared - we have to remove at least one PRD");
      rejectHitOverUse(trackHitDetails, tsosDetails, index);
      if (m_observerTool.isEnabled()){
        m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::tooManySharedNonRecoverable);
      }
      continue;     
    }
    ATH_MSG_ERROR("Reached end of TSOS loop without a decision." );
  } // loop over TSOS 
  //------------------------------------------------------------------//
 
  //------------------------------------------------------------------//
  //
  // COUNTERS have been set above. From here on, if change the state
  // of any hit, must also adjust counters
  //
  //------------------------------------------------------------------//
 
  //------------------------------------------------------------------//
  // Check if the pair is compatible with being a light particle decay 
  // This focuses on conversions
  // The track in question must 
  //  - have an overlapping hit with an accepted track
  //  - those two track have a small separation 
  //
  trackHitDetails.m_passConversionSel = false; // make sure off to start
  if (m_doPairSelection && !tsosDetails.m_overlappingTracks.empty()) {
    trackHitDetails.m_passConversionSel = performConversionCheck(ptrTrack, 
        prd_to_track_map, trackHitDetails, tsosDetails);
  }
  //------------------------------------------------------------------//
 
  //------------------------------------------------------------------//
  // Also check if the pair is compatible with being a boosted hadronic topology. 
  // This branch focuses on high-pt taus and b-jets in particular  
  // Same conditions as above.
  // Do not process any track already modified by the conversion check
  //
  if (m_useHClusSeed && !trackHitDetails.m_passConversionSel && trackHitDetails.m_passHadronicROI && 
    m_doPairSelection && !tsosDetails.m_overlappingTracks.empty()) {
    trackHitDetails.m_passConversionSel = performHadDecayCheck(ptrTrack, 
        prd_to_track_map, trackHitDetails, tsosDetails);
  }
  
  //------------------------------------------------------------------//
  //
  // Three cuts which can pull shared hits off of the track (no order)
  //   1. min unique SCT hits to share hits
  //   2. min chi2/ndf to share hits
  //
  // We shared SCT hits when we don't really have enough to share
  // Reject SCT shared hits on the track 
  if ( trackHitDetails.m_numSCT_Unused != trackHitDetails.m_numSCTHits && // have shared SCT
       trackHitDetails.m_numSCT_Unused <  m_minUniqueSCTHits ){
    for (unsigned int index( 0 );  index > tsosDetails.m_nTSoS; ++index ){    
      if ( tsosDetails.m_detType[index]==2 && tsosDetails.m_type[index] == SharedHit){
        rejectSharedHit(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::sharedSCT);
        }
      }      
    }
  }
  
  // Cut on chi2/NDF if shared hits on track
  // if fail cuts, remove all shared hits and reject track
  if ( !trackHitDetails.m_isPatternTrack && trackHitDetails.m_numShared > 0) {
    double trackchi2 = 0;
    if  (ptrTrack->fitQuality() && ptrTrack->fitQuality()->numberDoF()>0 ) {
      trackchi2 = ptrTrack->fitQuality()->chiSquared()/ptrTrack->fitQuality()->numberDoF();  
    }
 
    // if track fails cut for shared hits, remove the shared hits
    if ( trackchi2 > m_minTrackChi2ForSharedHits ) {
      ATH_MSG_DEBUG ("Shared hits, we have a bad chi2 track, mark it as bad !");
      // remove shared hits and see if track survives
      for (unsigned int index( 0 );  index > tsosDetails.m_nTSoS; ++index ){    
        if ( tsosDetails.m_type[index] != SharedHit ) { continue; }
        rejectSharedHit(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::sharedHitsBadChi2);
        }
      }
    } // fails cut
  } // is not a pattern track and has shared hits
 
  //------------------------------------------------------------------//
 
  
  //------------------------------------------------------------------//
  // Check accepted tracks with the surviving list of shared hits
  // Remove shared hits which push track over shared module cut
  // Set flags
  //
  // add up weighted count of shared hits on track, start removing
  // hits after counter is above cut. This preferences inner hits
  int newNumWeightedShared = 0; // tmp counter
  bool firstMeasurement(true);
  trackHitDetails.m_firstPixIsShared = false;
  // was already set in fillTrackDetails, but set again depending if blayer was rejected or not
  trackHitDetails.m_thisHasIBLHit = false;
  for (unsigned int index(0);  index  <tsosDetails.m_nTSoS; ++index ){
 
    // don't count rejected hits when setting flags
    if (tsosDetails.m_type[index] == RejectedHitOverUse ||
        tsosDetails.m_type[index] == RejectedHitInvalid ||
        tsosDetails.m_type[index] == RejectedHit ){ continue; }
 
    // Any track which is still labeled as SharedHit has to be checked 
    // against the accepted tracks. Accepted track should not be pushed
    // above cuts imposed here, some historic cuts remain
    if (tsosDetails.m_type[index] == SharedHit) {
 
      int  maxiShared     = -1;
      int  maxOtherNPixel = 0;
      bool maxOtherHasIBL = false;
      bool otherPassMinUniqueHits = checkOtherTracksValidity( tsosDetails, index, 
          splitProbContainer, prd_to_track_map, maxiShared, maxOtherNPixel, 
          maxOtherHasIBL, ent);
 
      if (!otherPassMinUniqueHits) {
        ATH_MSG_DEBUG ("reject track; Tracks shared hits does not leave enough unique hits on accepted track");
        rejectSharedHitInvalid(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::sharedHitsNotEnoughUniqueHits);
        }
        continue;
      }
 
      // 
      // do not allow other accepted track to exceed the shared limit...
      // ...IF first pixel hit is shared  (historic cut)
      // NOTE: here "pixel" includes IBL
      // tightening cut by dropping shared hit clause impacts performance in high pT jet cores
      if( maxiShared >= ent->m_maxSharedModules ){
 
        // if this is the first hit (it is shared), and a pixel, reject
        if( (tsosDetails.m_detType[index] % 10 == 1) && firstMeasurement ) {
          ATH_MSG_DEBUG ("reject track; Tracks shared hits pushes accepted track above shared module limit");
          rejectSharedHitInvalid(trackHitDetails, tsosDetails, index);
          if (m_observerTool.isEnabled()){
            m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::firstHitSharedAndPixIBL);
          }
          continue;
        }
        // if first pixel was shared (and this is not that hit)
        if( trackHitDetails.m_firstPixIsShared ) {
          ATH_MSG_DEBUG ("reject track; Tracks shared hits pushes accepted track above shared module limit");
          rejectSharedHitInvalid(trackHitDetails, tsosDetails, index);
          if (m_observerTool.isEnabled()){
            m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::firstHitSharedAndExtraShared);
          }
          continue;
        }
 
        // unlinked (no truth particle) tracks tend to have low hit counts
        // don't let track that look like this touch accepted tracks (new)
        if( trackHitDetails.totalPixelHits() < m_minPixHitAccepted ) { 
          rejectSharedHitInvalid(trackHitDetails, tsosDetails, index);
          if (m_observerTool.isEnabled()){
            m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::sharedHitsNotEnoughUniqueSiHits);
          }
          continue;
        }
 
      } // accepted track exceeds shared module cuts
 
 
      // 
      // only allow shared pixel if both have IBL or both not (historic cut)
      // if this is IBL hit, and other does not have IBL hit, remove shared IBL hit
      if( tsosDetails.m_detType[index] == 11 && !maxOtherHasIBL ) {
        ATH_MSG_VERBOSE ("---> Remove shared IBL as MaxShared accepted does not have an IBL hit");
        rejectSharedHit(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::sharedIBLSharedWithNoIBLTrack);
        }
        continue;
      }
      // if this is pixel hit, and candidate does not match IBL content of MaxShared accepted, remove shared hit
      if(tsosDetails.m_detType[index] == 1 && (trackHitDetails.m_thisHasIBLHit != maxOtherHasIBL) ) {
        ATH_MSG_VERBOSE ("---> Only allow shared pixel if candidate and accepted have same IBL hit content");
        rejectSharedHit(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::sharedPixelSharedWithDifferentIBLTrack);
        }
        continue;
      }
 
      // number of shared modules to be added to new sub-track
      // add shared hit to temporary counter
      newNumWeightedShared += (tsosDetails.m_detType[index]%10== 1 ? 2 : 1); // increase counter
      // should remain below the threshold 
      if (newNumWeightedShared >= ent->m_maxSharedModules) {
        ATH_MSG_VERBOSE ("-> Too many share hits, dropping outer hit(s) " 
            << newNumWeightedShared << "\t" << ent->m_maxSharedModules);  
        newNumWeightedShared -= (tsosDetails.m_detType[index]%10== 1 ? 2 : 1); // decrease counter
        rejectSharedHit(trackHitDetails, tsosDetails, index);
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::decideWhichHitsToKeep, xAOD::RejectionReason::tooManySharedAfterIncreasingShared);
        }
        continue;
      }
 
      //------------------------------------------//
      // if still shared and not rejected by above, set flags
      if( tsosDetails.m_detType[index] % 10 == 1 ) {
        if (firstMeasurement) {
          trackHitDetails.m_firstPixIsShared = true;
        }
        if (tsosDetails.m_detType[index] == 11 ){ // Blayer
          trackHitDetails.m_hasSharedIBLHit = true;
        } else if ( tsosDetails.m_detType[index] == 1 ){
          trackHitDetails.m_hasSharedPixel  = true; // historic definition
        }
      } // pixel hit
 
    } // if shared
 
    if (tsosDetails.m_detType[index] == 11 ){ // Blayer
      trackHitDetails.m_thisHasIBLHit = true;
    }
    if (firstMeasurement && tsosDetails.m_type[index] != OtherTsos){ firstMeasurement = false; }
 
  } // loop over TSOS
  //------------------------------------------------------------------//
 
  if (msgLvl(MSG::VERBOSE)){
    trackHitDetails.dumpInfo();
  }
 
  if (m_observerTool.isEnabled()){
    // calculate average split probabilities
    float splitProbAvg1 = -2;
    if (!tsosDetails.m_splitProb1.empty()){
      splitProbAvg1 = std::accumulate(tsosDetails.m_splitProb1.begin(), tsosDetails.m_splitProb1.end(), 0.0) / tsosDetails.m_splitProb1.size();
    }
    float splitProbAvg2 = -2;
    if (!tsosDetails.m_splitProb2.empty()){
      splitProbAvg2 = std::accumulate(tsosDetails.m_splitProb2.begin(), tsosDetails.m_splitProb2.end(), 0.0) / tsosDetails.m_splitProb2.size();
    }
    m_observerTool->updateHolesSharedHits(trackId,
                                          trackHitDetails.m_numPixelHoles,
                                          trackHitDetails.m_numSCTHoles,
                                          trackHitDetails.m_numSplitSharedPix,
                                          trackHitDetails.m_numSplitSharedSCT,
                                          -2,
                                          -2,
                                          trackHitDetails.m_numShared,
                                          trackHitDetails.m_isPatternTrack,
                                          trackHitDetails.totalSiHits(),
                                          trackHitDetails.m_passHadronicROI,
                                          trackHitDetails.m_thisHasIBLHit,
                                          trackHitDetails.m_hasSharedIBLHit,
                                          trackHitDetails.m_hasSharedPixel,
                                          trackHitDetails.m_firstPixIsShared,
                                          trackHitDetails.m_numPixelDeadSensor,
                                          trackHitDetails.m_numSCTDeadSensor,
                                          trackHitDetails.m_numPixelHits,
                                          trackHitDetails.m_numSCTHits,
                                          trackHitDetails.m_numUnused,
                                          trackHitDetails.m_numTRT_Unused,
                                          trackHitDetails.m_numSCT_Unused,
                                          trackHitDetails.m_numPseudo,
                                          splitProbAvg1,
                                          splitProbAvg2,
                                          trackHitDetails.m_numWeightedShared);
  }
 
  } // decideWhichHitsToKeep 

decreaseSharedHitCounters()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::decreaseSharedHitCounters ( TrackHitDetails & trackHitDetails, bool isPix, bool isSCT )

inlinestaticprivate

Definition at line 1679 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                                                                                                                        {
  trackHitDetails.m_numShared--; // decrease counter
  trackHitDetails.m_numWeightedShared -= (isPix ? 2 : 1); // increase counter
  // protect from TRT hits (needed?)
  if( isSCT ) { trackHitDetails.m_numSCT_Shared--; }
  }

fillTrackDetails()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::fillTrackDetails ( const Trk::Track * ptrTrack, Trk::ClusterSplitProbabilityContainer & splitProbContainer, const Trk::PRDtoTrackMap & prd_to_track_map, TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails ) const

private

Fill the two structs TrackHitDetails & TSoS_Details full of information.

Definition at line 473 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{ 
 
  // get all TSOS the track
  const Trk::TrackStates* tsos = ptrTrack->trackStateOnSurfaces();
  ATH_MSG_DEBUG ("Study new Track "<< ptrTrack<<"\t , it has "<<tsos->size()<<"\t track states");
 
 
  // is this a track from the pattern or a fitted track ?
  trackHitDetails.m_isPatternTrack = (ptrTrack->info().trackFitter()==Trk::TrackInfo::Unknown);
  if (trackHitDetails.m_isPatternTrack) {
    ATH_MSG_DEBUG ("-> this is a pattern track, outliers are good hits (reintegration) ! " << ptrTrack->perigeeParameters() );
  } else {
    ATH_MSG_DEBUG ("-> this is a refitted track, so we can use the chi2 ! " << ptrTrack->perigeeParameters());
  }
 
  // some pre-processing of the summary information, if available, needed for special cuts
  const Trk::TrackSummary* trkSummary=ptrTrack->trackSummary();
  if (trkSummary) {
    ATH_MSG_VERBOSE ("--> Found summary information");
    trackHitDetails.m_numPixelDeadSensor = trkSummary->get(Trk::numberOfPixelDeadSensors);
    trackHitDetails.m_numSCTDeadSensor   = trkSummary->get(Trk::numberOfSCTDeadSensors);
    trackHitDetails.m_numPixelHits       = trkSummary->get(Trk::numberOfPixelHits);
    trackHitDetails.m_numPixelHoles      = trkSummary->get(Trk::numberOfPixelHoles);
    trackHitDetails.m_numSCTHoles        = trkSummary->get(Trk::numberOfSCTHoles);
    trackHitDetails.m_numSCTHits         = trkSummary->get(Trk::numberOfSCTHits);
  } else {
    ATH_MSG_WARNING("Did not find track summary. Some cuts will be less efficienct!");
  }
 
 
  // set nDeadSensors to 0 in case trkSummary wasn't called with HoleSearch
  // (i.e. number of deadSensors not available)
  if (trackHitDetails.m_numPixelDeadSensor == -1) trackHitDetails.m_numPixelDeadSensor = 0;
  if (trackHitDetails.m_numSCTDeadSensor   == -1) trackHitDetails.m_numSCTDeadSensor   = 0;
  ATH_MSG_VERBOSE ("--- Number of dead si sensors: " << trackHitDetails.m_numPixelDeadSensor + trackHitDetails.m_numSCTDeadSensor);
 
 
  //
  // loop over TSOS and save information about each
  // label each TSOS as Outlier, UnusedHit, SharedHit or RejectedHit (only for errors here)
  // labels are used refined in decideWhichHitsToKeep 
  ATH_MSG_VERBOSE ("--> Looping over TSOS's");
  Trk::TrackStates::const_iterator iTsos    = tsos->begin();
  Trk::TrackStates::const_iterator iTsosEnd = tsos->end();
  for (int index = 0 ; iTsos != iTsosEnd ; ++iTsos, ++index) {
 
    // get measurment from TSOS
    const Trk::MeasurementBase* meas = (*iTsos)->measurementOnTrack();
 
    // if we do not have a measurement, we should just mark it
    if (!meas) {
      ATH_MSG_VERBOSE ( Form("---> No measurement on TSOS, it is another type, %2d",index) );
      tsosDetails.m_type[index] = OtherTsos;
      continue;
    }
 
    // ok, let try to get the ROT then
    
    if (not meas->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
      // could be a Pseudo-Measurement ?
      if (meas->type(Trk::MeasurementBaseType::PseudoMeasurementOnTrack)){
        ATH_MSG_VERBOSE ( Form("---> Pseudo measurement, %2d",index) );
        ++trackHitDetails.m_numPseudo; // increase counter
      } else {
        ATH_MSG_WARNING ( Form("---> Measurement is not a pseudo measurment, not yet supported! %2d",index));
      }
      tsosDetails.m_type[index] = OtherTsos;
      continue;
    }
    const Trk::RIO_OnTrack* rot = static_cast <const Trk::RIO_OnTrack*> (meas);
    //Store RIO into vector for later use
    tsosDetails.m_RIO[index] = rot;
 
    //
    // we have a TSOS with a measurement, keep analysing it
    //
 
    // let's get some information about the measurement
    const Identifier& id = rot->identify();
    bool isTRT           = m_detID->is_trt(id);
    bool isPixel         = m_detID->is_pixel(id);
    bool isSCT           = m_detID->is_sct(id);
    bool isIBL           = isPixel ? m_detID->is_blayer(id) : false; // checks layer 0
    bool isoutlier       = (*iTsos)->type(Trk::TrackStateOnSurface::Outlier);              
 
    tsosDetails.m_detType[index] = isTRT * 3 + isSCT * 2 + isPixel * 1 + isIBL * 10;
 
    // Do we have a IBL hit on the track?
    if ( isIBL && (!isoutlier || trackHitDetails.m_isPatternTrack ) ) {
      trackHitDetails.m_thisHasIBLHit = true;  // we may reintegrate outliers from pattern 
    }
 
    // Add splitting information about the cluster
    if (isPixel) {
      if ( not rot->prepRawData()->type(Trk::PrepRawDataType::PixelCluster) ) {
        ATH_MSG_WARNING ("---> Cluster is not from pixels; should not happen !");
        tsosDetails.m_type[index] = RejectedHit;
        continue; 
      } else {
        // get pixel cluster
        const InDet::PixelCluster* clus = static_cast <const InDet::PixelCluster*> (rot->prepRawData());
        const Trk::ClusterSplitProbabilityContainer::ProbabilityInfo &splitProb = splitProbContainer.splitProbability(clus);
        if ( !splitProb.isTooBigToBeSplit() )  {
          tsosDetails.m_splitProb1[index] = splitProb.splitProbability1();
          tsosDetails.m_splitProb2[index] = splitProb.splitProbability2();
        } else { 
          // cluster too big to split are default to 3 particle cluster
          // rigorously checked?
          tsosDetails.m_splitProb1[index] = m_sharedProbCut - 0.01f;
          tsosDetails.m_splitProb2[index] = m_sharedProbCut2 + 0.01f;
        }
      }
    } // isPixel
 
 
    //
    // define each hit
    // continue once definition set
    //
 
    // is this cluster used on an accepted track?
    bool isUsed = prd_to_track_map.isUsed(*(rot->prepRawData()));
 
    // assign outlier label using isoutlier bool above 
    // or if not inDet (does this even happen? Historical criteria)
    // further criteria on keeping a hit or not is done in decideWhichHitsToKeep
    // NOTE outliers can be shared but cannot save both in tsosDetails
    if( isoutlier || !(m_detID->is_indet(id))) {
      ATH_MSG_VERBOSE ( Form("---> Prd is outlier, %d", index) );
      tsosDetails.m_type[index] = Outlier;
      // if it is used, we need to send that information to the rest of the code
      // in decideWhichHitsToKeep we reject any outlier used on another track
      // if that logic was to change, and the number of tracks was needed, this would
      // need to change
      if(isUsed) { tsosDetails.m_hitIsShared[index] = 1; }
      continue;
    }
 
    
    if (!isUsed) {
      ATH_MSG_VERBOSE ( Form("---> Prd is unused, %d", index) );
      tsosDetails.m_type[index] = UnusedHit;
      continue;
    }
 
    //
    // we have a shared hit
    //
 
 
    // check if it is a shared TRT hit, this is not allowed
    if (isTRT) {
      ATH_MSG_VERBOSE (  Form("---> Share TRT hit, drop it !, %d", index) );
      tsosDetails.m_type[index] = RejectedHit;
      continue;
    }
 
    /* Allow a hit to be a shared one, if
       - not too many tracks share this hit already
       - the score of the track is high enough to allow for shared hits
       store information here but make decisions in decideWhichHitsToKeep
    */
    Trk::PRDtoTrackMap::ConstPrepRawDataTrackMapRange range = prd_to_track_map.onTracks(*(rot->prepRawData()));
    int numberOfTracksWithThisPrd = std::distance(range.first,range.second);
    ATH_MSG_VERBOSE ( Form("---> Number of tracks with this share Prd %d: %2d maxtracks: %2d",index, numberOfTracksWithThisPrd, m_maxTracksPerPRD.value()) );
    tsosDetails.m_hitIsShared[index] = numberOfTracksWithThisPrd;
 
 
    // get iterators for range
    Trk::PRDtoTrackMap::PrepRawDataTrackMap::const_iterator  mapIt    = range.first;
    Trk::PRDtoTrackMap::PrepRawDataTrackMap::const_iterator mapItEnd = range.second;
    // simple for loop instead of fancier remove_if above
    for ( ;mapIt!=mapItEnd; ++mapIt) {
      tsosDetails.m_overlappingTracks.insert( std::pair<const Trk::Track*, int >(mapIt->second, index) );
      tsosDetails.m_tracksSharingHit.insert(std::pair< int, const Trk::Track* >(index, mapIt->second ) ); 
    }
 
    ATH_MSG_VERBOSE ("-----> Mark this hits as shared  -- Try and recover later!");
    ATH_MSG_VERBOSE ("------ Index: "<< index << " Type: " << tsosDetails.m_detType[index]  << " splitprob1  " << tsosDetails.m_splitProb1[index]);
    tsosDetails.m_type[index] = SharedHit;
  } // End loop over TSOS's
  
  }

finalize()

StatusCode InDet::InDetDenseEnvAmbiTrackSelectionTool::finalize ( )

overridevirtual

Definition at line 62 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                                              {
  return StatusCode::SUCCESS;
}

getCleanedOutTrack()

std::tuple< Trk::Track *, bool > InDet::InDetDenseEnvAmbiTrackSelectionTool::getCleanedOutTrack ( const Trk::Track * track, const Trk::TrackScore score, Trk::ClusterSplitProbabilityContainer & splitProbContainer, Trk::PRDtoTrackMap & prd_to_track_map, int trackId, int subtrackId ) const

overridevirtual

Decide what to do with a candidate track.

• count and characterize hits on track
• not those which are used too often (decideWhichHitsToKeep)
• accept the track as is, remove hits and make a subtrack, or reject track
• track candidate are also checked against accepted tracks to ensure accepted tracks are not pushed over threshold

Definition at line 74 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
 
  CacheEntry  cache;
  
  if (m_skipAmbiInROI && inHadronicROI(ptrTrack)){
    ATH_MSG_DEBUG("skipping ambiguity resolution for track in hadronic ROI with m_minPtBjetROI = "<<m_minPtBjetROI<<", m_phiWidth = "<<m_phiWidth<<", m_etaWidth = "<<m_etaWidth);
    return std::make_tuple(static_cast<Trk::Track *>(nullptr),true); // keep input track
  }
  // compute the number of shared hits from the number of max shared modules
  // reset every track as could be changed for tracks within an ROI
  // ROI matching is done within decideWhichHitsToKeep. Note mulitple ROI types
  double trackEta = ptrTrack->trackParameters()->front()->eta();
  int maxSharedModules = m_etaDependentCutsSvc.name().empty() ?
    int(m_maxSharedModules) : m_etaDependentCutsSvc->getMaxSharedAtEta(trackEta);
  cache.m_maxSharedModules = 2*maxSharedModules+1; // see header for meaning
  cache.m_minNotShared = m_etaDependentCutsSvc.name().empty() ?
    int(m_minNotSharedHits) : m_etaDependentCutsSvc->getMinSiNotSharedAtEta(trackEta);
  cache.m_minSiHits = m_etaDependentCutsSvc.name().empty() ?
    int(m_minSiHitsToAllowSplitting) : m_etaDependentCutsSvc->getMinSiHitsAtEta(trackEta);
 
  // cut on TRT hits, might use eta dependent cuts here
  int  nCutTRT = m_minTRT_Hits;
  if (m_parameterization) {
    const DataVector<const Trk::TrackParameters>* vpar = ptrTrack->trackParameters();
    const Trk::TrackParameters*                    par = (*vpar)[0];
    // ME bugfix TODO ... how old is this comment??
    int expected = m_selectortool->minNumberDCs(par);
    if (expected > nCutTRT) nCutTRT = expected; 
  }
 
  // get all TSOS the track
  const Trk::TrackStates* tsos = ptrTrack->trackStateOnSurfaces();
  ATH_MSG_DEBUG ("Study new Track "<< ptrTrack<<"\t , it has "<<tsos->size()<<"\t track states");
  
  //Create structs to hold track information
  //Values in here are used to decide if a track is kept or not
  TrackHitDetails trackHitDetails;
 
  ATH_MSG_DEBUG ("Filling in TrackDetails");
  TSoS_Details    tsosDetails(tsos->size());
  
  // Fill structs with information
  fillTrackDetails( ptrTrack, splitProbContainer, prd_to_track_map, trackHitDetails, tsosDetails);
  
  //Decide which hits to keep
  //This is a major function which checks the usage of each hit on the candidate track
  ATH_MSG_DEBUG ("decideWhichHitsToKeep");
  decideWhichHitsToKeep( ptrTrack,  score,  splitProbContainer, prd_to_track_map, trackHitDetails, tsosDetails, &cache, trackId );
  
  ATH_MSG_DEBUG ("decideWhichHitsToKeep " << trackHitDetails.m_trkCouldBeAccepted );
  
  //
  // now see what to do with the track
  //
 
  ATH_MSG_DEBUG ("totalSiHits " << trackHitDetails.totalSiHits());
  ATH_MSG_DEBUG ("totalUniqueSiHits " << trackHitDetails.totalUniqueSiHits());
  ATH_MSG_DEBUG ("score " << score );
 
 
  //------------------------------------------------------------------------------------//
  //
  // All tracks must pass a minimum set of criteria 
  //
  // 1. Needs a minimum number of hits on track
  // This cut is also implmeneted in the scoring tool and usually the same values are set. 
  // A track which fails to have the minimum number of hits, gets a score of 0 
  // and will not make it this far. Might not be true for all versions of scoring tools.
  // The cut here maintains an explicit threshold
  //  
  // 2. Needs enough TRT hits. This is an important cut for back-tracking
  // 
  // 3. Needs to have enough unique hits (not shared with an accepted track)
  //
  //------------------------------------------------------------------------------------//
  bool passBasicCuts(true);
  if( trackHitDetails.totalSiHits() < m_minHits ) {
    passBasicCuts = false;
    if (m_observerTool.isEnabled()) {
      m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::notEnoughSiHits);
    }
  }
  if( trackHitDetails.m_numTRT_Unused < nCutTRT ) {
    passBasicCuts = false;
    if (m_observerTool.isEnabled()) {
      m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::notEnoughTRTHits);
    }
  }
  if( trackHitDetails.totalUniqueSiHits() < cache.m_minNotShared ) {
    passBasicCuts = false;
    if (m_observerTool.isEnabled()) {
      m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::notEnoughUniqueSiHits);
    }
  }
  if( !passBasicCuts ) {
    ATH_MSG_DEBUG ("reject track; failed basic cuts");
    return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track
  }
  //------------------------------------------------------------------------------------//
 
 
  //------------------------------------------------------------------------------------//
  //
  // Decide to keep track or not based on more complex criteria
  //  1. Check if track passes some criteria, including decision from decideWhichHitsToKeep
  //     If it passes, put the track into the output collection
  //  2. Those which fail are tested on a second set of criteria
  //     If it passes, strip off "RejectedHits" (decided in decideWhichHitsToKeep)
  //     and build new subtrack from all non-shared hits and the
  //     set of shared hits which pass some cuts.
  //       If 1. new track would have same hit content, save the original track
  //          2. if the new subtrack has less hits, and more than the min, created
  //             subtrack and reject the original
  //          3. if the new subtrack is below min hit cuts, junk it
  //  3. Those which fail are rejected with no chance for recovery
  //
  //------------------------------------------------------------------------------------//
  
  //------------------------------------------------------------------------------------//
  // Set some booleans for the up coming if/else statement
 
  // no shared hit at all
  // if shared hits, have additional requirements to check (3)
  bool noSharedHits( trackHitDetails.m_numShared == 0 );
 
  // set 2 bools for criteria placed on tracks with shared hits each criteria
  // 1/2 - too many shared modules?
  bool passSharedModulesCut( trackHitDetails.m_numWeightedShared < cache.m_maxSharedModules );
 
  // 2/2 - good quality?
  // Note, all tracks with a score of 0 are already removed
  bool passScoreCut( score > m_minScoreShareTracks );
  //------------------------------------------------------------------------------------//
 
  
  //------------------------------------------------------------------------------------//
  // Execute logic outlined above
  //
  // BEST CASE, we like this track and it passes this if statement
  // if have shared hits, not too many shared, and score ("quality") (note unique hits checked above)
  if( trackHitDetails.m_trkCouldBeAccepted && 
      ( noSharedHits || (passSharedModulesCut && passScoreCut) ) ) {
    ATH_MSG_DEBUG ("=> Suggest to keep track with "<<trackHitDetails.m_numShared<<" shared hits !");
 
 
    //  Change pixel hits property for shared hits as this track will be accepted into the final track colection
    if (!trackHitDetails.m_isPatternTrack){
      setPixelClusterSplitInformation( tsosDetails, splitProbContainer );
    }
 
    if (m_observerTool.isEnabled()){
      m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::acceptedTrack);
    }
    return std::make_tuple(static_cast<Trk::Track *>(nullptr),true); // keep input track
 
  }
  // Track failed to be accepted as is. 
  // Can we recover the track?
  else if ( passScoreCut ) {
 
    // catch, if this is cosmics, accept the incoming track
    if (m_cosmics) {
      ATH_MSG_DEBUG ("=> Cosmics, accept input track even with shared hits");
      if (m_observerTool.isEnabled()){
        m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::acceptedTrack);
      }
      return std::make_tuple(static_cast<Trk::Track *>(nullptr),true); // keep input track
    }
 
    //
    // Track is potentially ok, create a stripped down version 
    // from all hits not rejected
    // 
 
    ATH_MSG_VERBOSE ("Trying to recover track...gathering hits.");
 
    // decision on hits are already made
    // check the cleaning cuts and see if any of the rejected hits can be added back in
    // otherwise, go with what we have
    //
    // A candidate below the total hit cut will never make it this far. 
    // We are only extend tracks here if ever decide to override rejected hit decisions
     
    // loop over all TSOS (and types) and copy the good 
    // ones over to new TSOS vector
    std::vector<const Trk::TrackStateOnSurface*> newTSOS;
      
    // iterators for looping
    Trk::TrackStates::const_iterator iTsos    = tsos->begin();
    Trk::TrackStates::const_iterator iTsosEnd = tsos->end(); 
 
    for (int index = 0 ; iTsos != iTsosEnd ; ++iTsos,++index ) {
 
      // remove rejected hits
      if( tsosDetails.m_type[index] == RejectedHitOverUse || 
          tsosDetails.m_type[index] == RejectedHitInvalid || 
          tsosDetails.m_type[index] == RejectedHit ) {
        ATH_MSG_VERBOSE ("-> Dropping rejected hit");
        continue;
      }
 
      ATH_MSG_VERBOSE ("-> Copy good TSOS");
      newTSOS.push_back(*iTsos);
 
    } // loop over TSOS
 
 
    // newTSOS size would be hits on new track...how can the limit be 3? Is this backtracking?
    // Missing something? What configuration is relying on this cut? TODO
    if ( newTSOS.size() <= 3 ) {
      ATH_MSG_VERBOSE ("newTSOS.size(): "<<newTSOS.size() );
      ATH_MSG_DEBUG ("reject track; Too few hits, reject track with shared hits");
      if (m_observerTool.isEnabled()){
        m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::tooFewHits);
      }
      return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track
    }
 
    // check that this is not the input track
    if ( newTSOS.size() == tsos->size() ) {
      ATH_MSG_DEBUG ("=> Recovered input track, accept it !");
 
      //  Change pixel hits property for shared hits as this is track will be accepeted into the final track colection
      if (!trackHitDetails.m_isPatternTrack){
        setPixelClusterSplitInformation( tsosDetails, splitProbContainer ); 
      }
      ATH_MSG_DEBUG ("reject track; maybe track was mark as rejected, but we recoverd it so no rejection");
      if (m_observerTool.isEnabled()){
        m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::acceptedTrack);
      }
      return std::make_tuple(static_cast<Trk::Track *>(nullptr),true); // keep input track
    } else {
      // ok, done, create subtrack
      Trk::Track* newTrack = createSubTrack(newTSOS,ptrTrack);
      if (!newTrack) {
        ATH_MSG_DEBUG ("=> Failed to create subtrack");
        ATH_MSG_DEBUG ("reject track; Failed to create subtrack");
        if (m_observerTool.isEnabled()){
          m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::failedSubtrackCreation);
        }
        return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track
      }
 
      Trk::TrackInfo info;
      info.addPatternRecoAndProperties(ptrTrack->info());
      Trk::TrackInfo newInfo;
      newInfo.setPatternRecognitionInfo(Trk::TrackInfo::InDetAmbiTrackSelectionTool);
      info.addPatternReco(newInfo);
      newTrack->info().addPatternReco(ptrTrack->info()); 
 
      ATH_MSG_DEBUG ("=> Successfully created subtrack with shared hits recovered !");
      if (m_observerTool.isEnabled()) {
        m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::subtrackCreatedWithRecoveredShared);
        m_observerTool->addSubTrack(subtrackId, trackId, *newTrack);
      }
      return std::make_tuple(newTrack,false); // create new, cleaned track and reject input track
    }
  }
 
  // if made it this far, junk the track
  ATH_MSG_DEBUG ("=> Track is recommended to be dropped");
  ATH_MSG_DEBUG ("reject track; other");
  if (m_observerTool.isEnabled()){
    m_observerTool->rejectTrack(trackId, xAOD::RejectionStep::getCleanedOutTrack, xAOD::RejectionReason::other);
  }
  return std::make_tuple(static_cast<Trk::Track *>(nullptr),false); // reject input track
 
}

getOverlapTrackParameters()

std::pair< const Trk::TrackParameters *, const Trk::TrackParameters * > InDet::InDetDenseEnvAmbiTrackSelectionTool::getOverlapTrackParameters ( int n, const Trk::Track * track1, const Trk::Track * track2, const Trk::PRDtoTrackMap & prd_to_track_map, int splitSharedPix ) const

private

Returns the Trackparameters of the two tracks on the n'th TrackStateOnSurface of the first track.

Definition at line 1516 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  
  auto returnPair = std::make_pair<const Trk::TrackParameters*,const Trk::TrackParameters*>(0,0);
 
  // 
  // Get the TSOS in question from the candidate track since we know which one it is (index)
  // Do some basic checks
  //
  const Trk::TrackStates* track1tsos = track1->trackStateOnSurfaces();
 
  auto firstTsos    = track1tsos->begin();
  firstTsos += index;
  const auto *firstMeas = (*firstTsos)->measurementOnTrack();
 
  if (!firstMeas){
    ATH_MSG_ERROR("This is not a measurement!");
    return returnPair;
  }
  
  if (not firstMeas->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
    ATH_MSG_DEBUG("This measurement is not a ROT");
    return returnPair;
  }
  
  const auto *firstRot = static_cast <const Trk::RIO_OnTrack*> (firstMeas);
  if ( !prd_to_track_map.isUsed(*(firstRot->prepRawData()))){
    ATH_MSG_ERROR("This hist is not shared");
    return returnPair;
  }
 
 
  // 
  // now, get TSOS from 2nd track which is the one already accepted 
  // we know it was fitted so this should be possible
  const Trk::TrackStates* track2tsos = track2->trackStateOnSurfaces();
 
  auto iTsos    = track2tsos->begin(); 
  auto iTsosEnd = track2tsos->end();
  int measurementsBeforeShared = 0; 
  for (; iTsos != iTsosEnd ; ++iTsos) {
    
    // only compare to number of split hits? Why not shared also for NN inefficienicies
    if (measurementsBeforeShared > 1 + splitSharedPix ){
      ATH_MSG_DEBUG("Too many hits to before shared hit  -- unlikely they are from the same thing");
      return returnPair;  
    } 
     
    // get measurment from TSOS
    const auto *meas = (*iTsos)->measurementOnTrack();
 
    // if we do not have a measurement, we should just mark it
    if (!meas) {
      continue;
    }
    
    
    if (not meas->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
      continue;
    }
    const Trk::RIO_OnTrack* rot = static_cast <const Trk::RIO_OnTrack*> (meas);
    if (rot->prepRawData() != firstRot->prepRawData()){
      ++measurementsBeforeShared;
      continue;
    }
    
    if (!(*iTsos)->trackParameters()){
      ATH_MSG_DEBUG("There are no TrackParameters on this TSOS");
      return returnPair;  
    }
    
    returnPair.second = (*iTsos)->trackParameters();
    ATH_MSG_DEBUG("Success! track parameters for accepted track " << returnPair.second );
    break;
  }
 
 
  //
  // Now let's see if we have TPs for the candidate track
  // 
 
  if (!(*firstTsos)->trackParameters()){
    ATH_MSG_DEBUG("There are no TrackParameters on this TSOS");
    return returnPair;  
  }
 
  returnPair.first = (*firstTsos)->trackParameters();
 
  
  ATH_MSG_DEBUG("Success! track parameters for both tracks " << returnPair.first<< " " << returnPair.second );
  
  return returnPair;
  
}

increaseSharedHitCounters()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::increaseSharedHitCounters ( TrackHitDetails & trackHitDetails, bool isPix, bool isSCT )

inlinestaticprivate

Definition at line 1673 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                                                                                                                        {
  trackHitDetails.m_numShared++; // increase counter 
  trackHitDetails.m_numWeightedShared += (isPix ? 2 : 1); // increase counter
  // protect from TRT hits (needed?)
  if( isSCT ) { trackHitDetails.m_numSCT_Shared++; }
  }

inHadronicROI()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::inHadronicROI ( const Trk::Track * ptrTrack ) const

private

Does track pass criteria for hadronic ROI?

Definition at line 1481 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
 
  if (  !ptrTrack->trackParameters()->front() ){ return false; }
  // above pT for ROI?
  if (  ptrTrack->trackParameters()->front()->pT() < m_minPtBjetROI ) { return false; }
 
  return isHadCaloCompatible(*ptrTrack->trackParameters()->front());
}

initialize()

StatusCode InDet::InDetDenseEnvAmbiTrackSelectionTool::initialize ( )

overridevirtual

standard Athena-Algorithm method

Definition at line 41 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  ATH_CHECK(AlgTool::initialize());
 
  // Get segment selector tool
  ATH_CHECK(m_selectortool.retrieve(DisableTool{!m_parameterization}));
 
  ATH_CHECK(detStore()->retrieve(m_detID, "SiliconID"));
 
  if(!m_etaDependentCutsSvc.name().empty()) ATH_CHECK(m_etaDependentCutsSvc.retrieve());
 
  ATH_CHECK(m_assoTool.retrieve());
 
  ATH_CHECK(m_observerTool.retrieve(DisableTool{m_observerTool.empty()}));
 
  ATH_CHECK(m_inputHadClusterContainerName.initialize(m_useHClusSeed));
  ATH_CHECK(m_inputEmClusterContainerName.initialize(m_useEmClusSeed));
 
  return StatusCode::SUCCESS;
}

isEmCaloCompatible()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::isEmCaloCompatible ( const Trk::TrackParameters & Tp ) const

private

Check if the cluster is compatible with a EM cluster.

Definition at line 1503 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  SG::ReadHandle<ROIPhiRZContainer> calo(m_inputEmClusterContainerName);
  if (!calo.isValid())  {
     ATH_MSG_ERROR("Failed to get EM cluster container " << m_inputEmClusterContainerName);
     return false;
  }
  return calo->hasMatchingROI(Tp.momentum().phi(), Tp.momentum().eta(), Tp.position().perp(), Tp.position().z(), m_phiWidthEm, m_etaWidthEm);
}

isHadCaloCompatible()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::isHadCaloCompatible ( const Trk::TrackParameters & Tp ) const

private

Check if the cluster is compatible with a hadronic cluster.

Definition at line 1491 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  SG::ReadHandle<ROIPhiRZContainer> calo(m_inputHadClusterContainerName);
  if (!calo.isValid()) {
     ATH_MSG_ERROR("Failed to get Had Calo cluster collection " << m_inputHadClusterContainerName );
     return false;
  }
 
  return calo->hasMatchingROI(Tp.momentum().phi(), Tp.eta(), 0. /* ignore r of Tp*/, Tp.position().z(), m_phiWidth, m_etaWidth);
}

isMultiPartClus()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::isMultiPartClus ( float splitProb2 ) const

inlineprivate

Definition at line 1625 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  return ( splitProb2 >= m_sharedProbCut2 );
}

isNearbyTrackCandidate()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::isNearbyTrackCandidate ( const Trk::TrackParameters * paraA, const Trk::TrackParameters * paraB ) const

private

Check if two sets of track paremeters are compatible with being from a the same low mass particle decay.

It is assumed that the track parmeters are on the same surface.

isTwoPartClus()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::isTwoPartClus ( float splitProb1, float splitProb2 ) const

inlineprivate

Definition at line 1621 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  return ( (splitProb1 >= m_sharedProbCut) && (splitProb2 < m_sharedProbCut2) );
}

newEvent()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::newEvent ( CacheEntry * ent )

staticprivate

Fill hadronic & EM cluster map.

Definition at line 68 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
   }

performConversionCheck()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::performConversionCheck ( const Trk::Track * ptrTrack, Trk::PRDtoTrackMap & prd_to_track_map, TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails ) const

private

Specific logic for identifing conversions with the goal of passing those tracks through to the final collection with as little loss as possible.

Definition at line 1212 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  ATH_MSG_DEBUG(" Conversion Check ");
 
  // We need to have a good number of unshared SCT hits
  if ( trackHitDetails.m_numSCT_Unused < m_minUniqueSCTHits )              { return false; }
  if ( trackHitDetails.m_numPixelHoles + trackHitDetails.m_numSCTHoles >= 2) { return false; }
 
  //Find the accepted track that shares the most hits our proposed track 
  const Trk::Track*  mostOverlappingTrack(nullptr);
  int mostOverlappingNumberOfHits(0);
  int indexOfFirstOverlappingHit(0);
  for ( std::multimap<const Trk::Track*,int>::iterator it = tsosDetails.m_overlappingTracks.begin(), 
      end = tsosDetails.m_overlappingTracks.end(); it != end; 
      it = tsosDetails.m_overlappingTracks.upper_bound(it->first) ) {
    int numberOfHitsSharedWithThisTrack  = std::distance( it, tsosDetails.m_overlappingTracks.upper_bound(it->first));
    ATH_MSG_DEBUG(it->first <<" shares " << numberOfHitsSharedWithThisTrack << " hits with this track " );
    if (mostOverlappingNumberOfHits < numberOfHitsSharedWithThisTrack){
      mostOverlappingNumberOfHits = numberOfHitsSharedWithThisTrack;
      mostOverlappingTrack        = it->first;
      indexOfFirstOverlappingHit  = it->second;
    }
  } // loop over overlapping tracks
 
  if(!mostOverlappingTrack) { return false; }
 
  // criteria applied for fitted and pattern tracks
  if(mostOverlappingNumberOfHits < 2)                         { return false; }
  if(mostOverlappingNumberOfHits < trackHitDetails.m_numShared) { return false; }
 
 
  //If an overlapping track if found get the track parameters on the first shared surface
  auto tpPair = getOverlapTrackParameters(indexOfFirstOverlappingHit, ptrTrack, mostOverlappingTrack, prd_to_track_map, trackHitDetails.m_numSplitSharedPix );
 
  // If found track parameters at first overlapping track, check separation
  if (tpPair.first && tpPair.second) {
    // Check a series of criteria to see if track is a compatible with a photon conversion
    // Check if both tracks are above threshold
    if(tpPair.first->pT() <= m_minPairTrackPt || tpPair.second->pT() <= m_minPairTrackPt) {
      return false;
    }
    //Check if it is in a ROI, if requested
    if(m_useEmClusSeed) {
       if(!isEmCaloCompatible( *tpPair.first )) { return false; }
    }
    ATH_MSG_DEBUG ("Possible photon conversion");
  }
  // for pattern tracks, cannot get the track parameters at a hit position
  // Need an alternate way to find conversion, try to use the accepted track
  // Main point is to not kill the pattern track
  else if ( trackHitDetails.m_isPatternTrack ) {
    if(m_useEmClusSeed && tpPair.second ) {
       if(!isEmCaloCompatible( *tpPair.second )) { return false; }
    }
    ATH_MSG_DEBUG ("Possible photon conversion - for pattern track");
  }
  // if cannot find track parameters, and not a pattern track, then failed
  else {
    return false;
  }
 
  ATH_MSG_DEBUG ("Number of unused SCT hits:   " <<  trackHitDetails.m_numSCT_Unused);  
  if (msgLvl(MSG::DEBUG)){
    trackHitDetails.dumpInfo();
  }
  ATH_MSG_DEBUG ("Track "<< mostOverlappingTrack << " shares " << mostOverlappingNumberOfHits ); 
 
  updateSharedForCollimated(trackHitDetails, tsosDetails);
 
  return true;
} // performConversionCheck

performHadDecayCheck()

bool InDet::InDetDenseEnvAmbiTrackSelectionTool::performHadDecayCheck ( const Trk::Track * ptrTrack, Trk::PRDtoTrackMap & prd_to_track_map, TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails ) const

private

Specific logic for identifing boosted light particle decays in jet topologies (tau and b), with the goal of passing those tracks through to the final collection with as little loss as possible.

Definition at line 1293 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
  ATH_MSG_DEBUG(" Hadron decay Check ");
 
  // We need to have a good number of unshared SCT hits
  if ( trackHitDetails.m_numSCT_Unused < m_minUniqueSCTHits )              { return false; }
  if ( trackHitDetails.m_numPixelHoles + trackHitDetails.m_numSCTHoles >= 2) { return false; }
 
  //Find the accepted track that shares the most hits our proposed track 
  const Trk::Track*  mostOverlappingTrack(nullptr);
  int mostOverlappingNumberOfHits(0);
  int indexOfFirstOverlappingHit(0);
  for ( std::multimap<const Trk::Track*,int>::iterator it = tsosDetails.m_overlappingTracks.begin(), 
      end = tsosDetails.m_overlappingTracks.end(); it != end; 
      it = tsosDetails.m_overlappingTracks.upper_bound(it->first) ) {
    int numberOfHitsSharedWithThisTrack  = std::distance( it, tsosDetails.m_overlappingTracks.upper_bound(it->first));
    ATH_MSG_DEBUG(it->first <<" shares " << numberOfHitsSharedWithThisTrack << " hits with this track " );
    if (mostOverlappingNumberOfHits < numberOfHitsSharedWithThisTrack){
      mostOverlappingNumberOfHits = numberOfHitsSharedWithThisTrack;
      mostOverlappingTrack        = it->first;
      indexOfFirstOverlappingHit  = it->second;
    }
  } // loop over overlapping tracks
 
  if(!mostOverlappingTrack) { return false; }
 
  // criteria applied for fitted and pattern tracks
  if(mostOverlappingNumberOfHits < 2)                         { return false; }
  if(mostOverlappingNumberOfHits < trackHitDetails.m_numShared) { return false; }
 
 
  //If an overlapping track if found get the track parameters on the first shared surface
  auto tpPair = getOverlapTrackParameters(indexOfFirstOverlappingHit, ptrTrack, mostOverlappingTrack, prd_to_track_map, trackHitDetails.m_numSplitSharedPix );
 
  // If found track parameters at first overlapping track, check separation
  if (tpPair.first && tpPair.second) {
    // Check a series of criteria to see if track is a compatible with a boosted decay
    // Check if both tracks are above threshold
    if(tpPair.first->pT() <= m_minPairTrackPt || tpPair.second->pT() <= m_minPairTrackPt) {
      return false;
    }
    //Check if it is in a ROI, if requested
    if(m_useHClusSeed) {
       if(!isHadCaloCompatible( *tpPair.first )) { return false; }
    }
    ATH_MSG_DEBUG ("Possible boosted decay");
  }
  // for pattern tracks, cannot get the track parameters at a hit position
  else if ( trackHitDetails.m_isPatternTrack ) {
    if(m_useHClusSeed && tpPair.second ) {
       if(!isHadCaloCompatible( *tpPair.second )) { return false; }
    }
    ATH_MSG_DEBUG ("Possible boosted decay - for pattern track");
  }
  // if cannot find track parameters, and not a pattern track, then failed
  else {
    return false;
  }
 
  ATH_MSG_DEBUG ("Number of unused SCT hits:   " <<  trackHitDetails.m_numSCT_Unused);  
  if (msgLvl(MSG::DEBUG)){
    trackHitDetails.dumpInfo();
  }
  ATH_MSG_DEBUG ("Track "<< mostOverlappingTrack << " shares " << mostOverlappingNumberOfHits ); 
 
  updateSharedForCollimated(trackHitDetails, tsosDetails);
 
  return true; 
}

rejectHit()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::rejectHit ( TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails, int index )

inlinestaticprivate

Definition at line 1637 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                          {
  trackHitDetails.m_trkCouldBeAccepted = false; // we have to remove at least one PRD
  tsosDetails.m_type[index] = RejectedHit;
}

rejectHitOverUse()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::rejectHitOverUse ( TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails, int index )

inlinestaticprivate

Definition at line 1632 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                          {
  trackHitDetails.m_trkCouldBeAccepted = false; // we have to remove at least one PRD
  tsosDetails.m_type[index] = RejectedHitOverUse;
}

rejectSharedHit()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::rejectSharedHit ( TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails, int index )

inlinestaticprivate

Definition at line 1643 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                          {
  rejectHit(trackHitDetails, tsosDetails, index); // reject
  decreaseSharedHitCounters( trackHitDetails, 
      (tsosDetails.m_detType[index]%10 == 1), 
      (tsosDetails.m_detType[index]%10 == 2) );
}

rejectSharedHitInvalid()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::rejectSharedHitInvalid ( TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails, int index )

inlinestaticprivate

Definition at line 1651 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                          {
  trackHitDetails.m_trkCouldBeAccepted = false;
  tsosDetails.m_type[index] = RejectedHitInvalid; // do not use rejectHit function since use this flag
  decreaseSharedHitCounters( trackHitDetails, 
      (tsosDetails.m_detType[index]%10 == 1), 
      (tsosDetails.m_detType[index]%10 == 2) );
}

setPixelClusterSplitInformation()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::setPixelClusterSplitInformation ( TSoS_Details & tsosDetails, Trk::ClusterSplitProbabilityContainer & clusterSplitProbMap ) const

private

Update the pixel clusters split information.

Definition at line 1454 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

{
 
  for (unsigned int index(0);  index  < tsosDetails.m_nTSoS; ++index ){
    //Only consider split shared hits 
    if (tsosDetails.m_type[index] != SplitSharedHit)
      continue;
 
    // And the hit is a pixel hit
    if (tsosDetails.m_detType[index]%10 == 1){
      if (const auto * pThisPrd(tsosDetails.m_RIO[index]->prepRawData());pThisPrd->type(Trk::PrepRawDataType::PixelCluster)){
        const InDet::PixelCluster* pixelCluster = static_cast<const InDet::PixelCluster*> ( pThisPrd  );
        Trk::ClusterSplitProbabilityContainer::ProbabilityInfo *splitProb = splitProbContainer.getSplitProbability(pixelCluster);
        if (!splitProb) {
           splitProb = &(splitProbContainer.setSplitInformation(pixelCluster,0.f,0.f));
        }
        splitProb->setSplit(true);
      } else {
        ATH_MSG_WARNING("Cast of a pixel cluster failed????");
      }
    }
  }
}

sharedToSplitPix()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::sharedToSplitPix ( TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails, int index )

inlinestaticprivate

Definition at line 1660 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                          {
  // from shared
  decreaseSharedHitCounters( trackHitDetails, true, false ); // isPix=true
  // to split
  tsosDetails.m_type[index] = SplitSharedHit;
  trackHitDetails.m_numSplitSharedPix++;
}

updateSharedForCollimated()

void InDet::InDetDenseEnvAmbiTrackSelectionTool::updateSharedForCollimated ( TrackHitDetails & trackHitDetails, TSoS_Details & tsosDetails ) const

private

Handle update of the shared hit counts if either a conversion or a dense hadronic decay was identified using one of the methods above.

Definition at line 1366 of file InDetDenseEnvAmbiTrackSelectionTool.cxx.

                                          {
  //Change all shared SCT to SplitSharedHit
  ATH_MSG_VERBOSE ("Updating SCT hit information");
  
  trackHitDetails.m_numSplitSharedPix = 0;          // reset counter
  trackHitDetails.m_numSplitSharedSCT = 0;          // reset counter
  trackHitDetails.m_numShared         = 0;          // reset counter 
  trackHitDetails.m_numSCT_Shared     = 0;          // reset counter 
  trackHitDetails.m_numWeightedShared = 0;          // reset counter
 
  trackHitDetails.m_hasSharedIBLHit = false;        // reset flag
  trackHitDetails.m_hasSharedPixel  = false;        // reset flag
 
  //Update counts but only allow 1 pixel hit to be updated free of charge 
  int noUpdatedPixels = 0;
 
  for (unsigned int index(0);  index  < tsosDetails.m_nTSoS; ++index ){    
    // Dont change blayer only pixel hits --  all other shared hits become splitshared
    if ( noUpdatedPixels < 1 && tsosDetails.m_detType[index]==1 && tsosDetails.m_type[index] == SharedHit ){
      ++noUpdatedPixels;
      tsosDetails.m_type[index] = SplitSharedHit;
    } 
 
    if ( tsosDetails.m_detType[index]==1 && tsosDetails.m_type[index] == SplitSharedHit ){
      ++trackHitDetails.m_numSplitSharedPix;
    } 
 
    if ( tsosDetails.m_detType[index]==2 && tsosDetails.m_type[index] == SharedHit ){
      tsosDetails.m_type[index] = SplitSharedHit;
    }
 
    if ( tsosDetails.m_detType[index]==2 && tsosDetails.m_type[index] == SplitSharedHit ){
      ++trackHitDetails.m_numSplitSharedSCT;
    }
 
    // only change shared hits
    // m_numUnused and m_numSCT_Unused are not changed from this
    if (tsosDetails.m_type[index] != SharedHit){ continue; }
 
    increaseSharedHitCounters( trackHitDetails, 
        (tsosDetails.m_detType[index]%10 == 1), 
        (tsosDetails.m_detType[index]%10 == 2) );
 
    // set flags
    if (tsosDetails.m_detType[index]  == 11){
      trackHitDetails.m_hasSharedIBLHit = true;
    } else if ( tsosDetails.m_detType[index] == 1 ){
      trackHitDetails.m_hasSharedPixel  = true;
    }
    
  } // loop over TSOS
} 

Member Data Documentation

ATLAS_THREAD_SAFE

SG::SlotSpecificObj<CacheEntry> m_cache InDet::InDetDenseEnvAmbiTrackSelectionTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 319 of file InDetDenseEnvAmbiTrackSelectionTool.h.

m_assoTool

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

private

Definition at line 436 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "AssociationTool", "InDet::InDetPRDtoTrackMapToolGangedPixels" };

m_cosmics

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_cosmics {this, "Cosmics", false, "Trying to reco cosmics?"}

private

Definition at line 449 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "Cosmics", false, "Trying to reco cosmics?"};

m_detID

const SiliconID* InDet::InDetDenseEnvAmbiTrackSelectionTool::m_detID {nullptr}

private

atlas id helper

Definition at line 434 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{nullptr};

m_doPairSelection

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_doPairSelection {this, "doPairSelection", true}

private

Definition at line 480 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "doPairSelection", true};

m_doPixelClusterSplitting

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_doPixelClusterSplitting {this, "doPixelSplitting", false, "Split pixel clusters"}

private

Definition at line 451 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "doPixelSplitting", false, "Split pixel clusters"};

m_etaDependentCutsSvc

ServiceHandle<IInDetEtaDependentCutsSvc> InDet::InDetDenseEnvAmbiTrackSelectionTool::m_etaDependentCutsSvc {this, "InDetEtaDependentCutsSvc", ""}

private

ITk eta-dependet cuts.

Definition at line 431 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "InDetEtaDependentCutsSvc", ""};

m_etaWidth

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_etaWidth {this, "etaWidth", 0.2}

private

Definition at line 470 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "etaWidth", 0.2};

m_etaWidthEm

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_etaWidthEm {this, "etaWidthEM", 0.05}

private

Definition at line 475 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "etaWidthEM", 0.05};

m_inputEmClusterContainerName

SG::ReadHandleKey<ROIPhiRZContainer> InDet::InDetDenseEnvAmbiTrackSelectionTool::m_inputEmClusterContainerName {this, "EMROIPhiRZContainer", ""}

private

Definition at line 477 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "EMROIPhiRZContainer", ""};

m_inputHadClusterContainerName

SG::ReadHandleKey<ROIPhiRZContainer> InDet::InDetDenseEnvAmbiTrackSelectionTool::m_inputHadClusterContainerName {this, "HadROIPhiRZContainer", ""}

private

Definition at line 471 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "HadROIPhiRZContainer", ""};

m_maxPixMultiCluster

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_maxPixMultiCluster {this, "maxPixMultiCluster", 4, "Max number of tracks that can be associated to a >= 3 particle cluster"}

private

Definition at line 460 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "maxPixMultiCluster", 4, "Max number of tracks that can be associated to a >= 3 particle cluster"};

m_maxPixOnePartCluster

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_maxPixOnePartCluster {this, "maxPixOnePartCluster", 2, "Max number of tracks that can be associated to a 1 particle cluster"}

private

Definition at line 458 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "maxPixOnePartCluster", 2, "Max number of tracks that can be associated to a 1 particle cluster"};

m_maxPixTwoPartCluster

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_maxPixTwoPartCluster {this, "maxPixTwoPartCluster", 2, "Max number of tracks that can be associated to a 2 particle cluster"}

private

Definition at line 459 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "maxPixTwoPartCluster", 2, "Max number of tracks that can be associated to a 2 particle cluster"};

m_maxSharedModules

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_maxSharedModules {this, "maxShared", 1, "Max number of shared modules"}

private

Definition at line 445 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "maxShared", 1, "Max number of shared modules"};

m_maxTracksPerPRD

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_maxTracksPerPRD {this, "maxTracksPerSharedPRD", 2, "Max number of tracks per hit. When NN is used, other flags set the limits."}

private

Definition at line 446 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "maxTracksPerSharedPRD", 2, "Max number of tracks per hit. When NN is used, other flags set the limits."};

m_minHits

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minHits {this, "minHits", 5, "Min Number of hits on track"}

private

some cut values

Definition at line 443 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minHits", 5, "Min Number of hits on track"};

m_minNotSharedHits

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minNotSharedHits {this, "minNotShared", 6, "Min number of non shared hits"}

private

Definition at line 447 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minNotShared", 6, "Min number of non shared hits"};

m_minPairTrackPt

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minPairTrackPt {this, "minPairTrackPt", 1000., "In MeV"}

private

Definition at line 481 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minPairTrackPt", 1000., "In MeV"};

m_minPixHitAccepted

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minPixHitAccepted {this, "minPixHitAccepted", 2, "Min number of pixel hits needed to be allowed to push accepted tracks over shared module limits"}

private

Definition at line 462 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minPixHitAccepted", 2, "Min number of pixel hits needed to be allowed to push accepted tracks over shared module limits"};

m_minPtBjetROI

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minPtBjetROI {this, "minPtBjetROI", 15000., "in MeV"}

private

Definition at line 468 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minPtBjetROI", 15000., "in MeV"};

m_minPtSplit

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minPtSplit {this, "minPtSplit", 0.}

private

Definition at line 467 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minPtSplit", 0.};

m_minScoreShareTracks

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minScoreShareTracks {this, "minScoreShareTracks", 0.0, "Min track score to alow it to share hits"}

private

Definition at line 448 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minScoreShareTracks", 0.0, "Min track score to alow it to share hits"};

m_minSiHitsToAllowSplitting

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minSiHitsToAllowSplitting {this, "minSiHitsToAllowSplitting", 9, "Min number of hits before we allow split sharing of hits"}

private

Definition at line 457 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minSiHitsToAllowSplitting", 9, "Min number of hits before we allow split sharing of hits"};

m_minTrackChi2ForSharedHits

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minTrackChi2ForSharedHits {this, "minTrackChi2ForSharedHits", 3, "Min track chi2 to split share hits"}

private

Definition at line 455 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minTrackChi2ForSharedHits", 3, "Min track chi2 to split share hits"};

m_minTRT_Hits

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minTRT_Hits {this, "minTRTHits", 0, "Min Number of TRT hits on track"}

private

Definition at line 444 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minTRTHits", 0, "Min Number of TRT hits on track"};

m_minUniqueSCTHits

IntegerProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_minUniqueSCTHits {this, "minUniqueSCTHits", 2, "Min number of hits in the SCT that we need before we allow hit sharing in the SCT"}

private

Definition at line 456 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "minUniqueSCTHits", 2, "Min number of hits in the SCT that we need before we allow hit sharing in the SCT"};

m_monitorTracks

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_monitorTracks {this, "MonitorAmbiguitySolving", false, "to track observeration/monitoring (default is false)"}

private

Definition at line 483 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "MonitorAmbiguitySolving", false, "to track observeration/monitoring (default is false)"};

m_mutex

std::mutex InDet::InDetDenseEnvAmbiTrackSelectionTool::m_mutex

mutableprivate

Definition at line 293 of file InDetDenseEnvAmbiTrackSelectionTool.h.

m_observerTool

PublicToolHandle<Trk::ITrkObserverTool> InDet::InDetDenseEnvAmbiTrackSelectionTool::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 440 of file InDetDenseEnvAmbiTrackSelectionTool.h.

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

m_parameterization

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_parameterization {this, "UseParameterization", true, "Use table of min number DCs"}

private

Definition at line 450 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "UseParameterization", true, "Use table of min number DCs"};

m_phiWidth

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_phiWidth {this, "phiWidth", 0.2}

private

Definition at line 469 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "phiWidth", 0.2};

m_phiWidthEm

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_phiWidthEm {this, "phiWidthEM", 0.05}

private

Definition at line 474 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "phiWidthEM", 0.05};

m_selectortool

PublicToolHandle<ITrtDriftCircleCutTool> InDet::InDetDenseEnvAmbiTrackSelectionTool::m_selectortool {this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"}

private

TRT minimum number of drift circles tool- returns allowed minimum number of TRT drift circles.

Definition at line 428 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "DriftCircleCutTool", "InDet::InDetTrtDriftCircleCutTool"};

m_sharedProbCut

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_sharedProbCut {this, "sharedProbCut", 0.3, "Min split prob to break a cluster into two parts"}

private

Definition at line 452 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "sharedProbCut", 0.3, "Min split prob to break a cluster into two parts"};

m_sharedProbCut2

FloatProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_sharedProbCut2 {this, "sharedProbCut2", 0.3, "Min split prob to break a clsuter into three parts"}

private

Definition at line 453 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "sharedProbCut2", 0.3, "Min split prob to break a clsuter into three parts"};

m_shareSplitHits

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_shareSplitHits {this, "shareSplitHits", false, "Allow shared hits to be shared on 1 more track"}

private

Definition at line 461 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "shareSplitHits", false, "Allow shared hits to be shared on 1 more track"};

m_skipAmbiInROI

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_skipAmbiInROI {this, "doSkipAmbiInROI", false}

private

Definition at line 466 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "doSkipAmbiInROI", false};

m_useEmClusSeed

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_useEmClusSeed {this, "doEmCaloSeed", false}

private

Definition at line 473 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "doEmCaloSeed", false};

m_useHClusSeed

BooleanProperty InDet::InDetDenseEnvAmbiTrackSelectionTool::m_useHClusSeed {this, "doHadCaloSeed", false}

private

Definition at line 465 of file InDetDenseEnvAmbiTrackSelectionTool.h.

{this, "doHadCaloSeed", false};

---

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

• InDetDenseEnvAmbiTrackSelectionTool.h
• InDetDenseEnvAmbiTrackSelectionTool.cxx