InDet::InDetPRD_AssociationToolGangedPixels Class Reference

Concrete Implementation of the IPRD_AssociationTool interface. More...

#include <InDetPRD_AssociationToolGangedPixels.h>

Inheritance diagram for InDet::InDetPRD_AssociationToolGangedPixels:

Collaboration diagram for InDet::InDetPRD_AssociationToolGangedPixels:

Public Types
typedef Trk::IPRD_AssociationTool::Maps	Maps

Public Member Functions
	InDetPRD_AssociationToolGangedPixels (const std::string &, const std::string &, const IInterface *)
virtual	~InDetPRD_AssociationToolGangedPixels ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	addPRDs (const Trk::Track &track) override
	add the PRDs from this track to the store
virtual StatusCode	addPRDs (Maps &maps, const Trk::Track &track) const override
	add the PRDs from this track to maps.
virtual StatusCode	removePRDs (Maps &maps, const Trk::Track &track) const override
	remove the PRDs from this track from maps
virtual StatusCode	removePRDs (const Trk::Track &track) override
	remove the PRDs from this track from the store
virtual bool	isUsed (const Maps &maps, const Trk::PrepRawData &prd) const override final
	does this PRD belong to at least one track in maps?
virtual bool	isUsed (const Trk::PrepRawData &prd) const override
	does this PRD belong to at least one track?
virtual bool	isShared (const Maps &maps, const Trk::PrepRawData &prd) const override final
	does this PRD belong to more than one track in maps?
virtual bool	isShared (const Trk::PrepRawData &prd) const override
	does this PRD belong to more than one track?
virtual std::vector< const Trk::PrepRawData * >	getPrdsOnTrack (const Trk::Track &track) const override
	returns a vector of PRDs belonging to the passed track.
virtual std::vector< const Trk::PrepRawData * >	getPrdsOnTrack (const Maps &maps, const Trk::Track &track) const override
virtual Trk::IPRD_AssociationTool::TrackSet	findConnectedTracks (const Trk::Track &track) const override
	returns set of tracks which share PRD with this one
virtual IPRD_AssociationTool::TrackSet	findConnectedTracks (const Maps &maps, const Trk::Track &track) const override
virtual Trk::IPRD_AssociationTool::PrepRawDataTrackMapRange	onTracks (const Trk::PrepRawData &prd) const override
	get the Tracks associated with this Trk::PrepRawData.
virtual IPRD_AssociationTool::PrepRawDataTrackMapRange	onTracks (const Maps &maps, const Trk::PrepRawData &prd) const override
virtual void	reset () override
	resets the tool - should be called before using tool (and maybe afterwards to free up memory)

Private Attributes
Maps	m_maps
SG::ReadHandleKey< PixelGangedClusterAmbiguities >	m_pixelClusterAmbiguitiesMapName {this, "PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMap"}
BooleanProperty	m_addTRToutliers {this, "addTRToutliers", false}
	add TRT outliers in the addTrack method to avoid splits due to rejected extensions

Detailed Description

Concrete Implementation of the IPRD_AssociationTool interface.

Definition at line 20 of file InDetPRD_AssociationToolGangedPixels.h.

Member Typedef Documentation

Maps

typedef Trk::IPRD_AssociationTool::Maps InDet::InDetPRD_AssociationToolGangedPixels::Maps

Definition at line 24 of file InDetPRD_AssociationToolGangedPixels.h.

Constructor & Destructor Documentation

InDetPRD_AssociationToolGangedPixels()

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

Definition at line 16 of file InDetPRD_AssociationToolGangedPixels.cxx.

                                                                                                                                             :
  base_class(t,n,p)
{ }

~InDetPRD_AssociationToolGangedPixels()

InDet::InDetPRD_AssociationToolGangedPixels::~InDetPRD_AssociationToolGangedPixels ( )

virtualdefault

Member Function Documentation

addPRDs() [1/2]

StatusCode InDet::InDetPRD_AssociationToolGangedPixels::addPRDs ( const Trk::Track & track )

overridevirtual

add the PRDs from this track to the store

Parameters

track

all PRDs from 'track' will be added to PRD_AssociationTool's internal store.

Definition at line 34 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  return addPRDs (m_maps, track);
}

addPRDs() [2/2]

StatusCode InDet::InDetPRD_AssociationToolGangedPixels::addPRDs ( Maps & maps, const Trk::Track & track ) const

overridevirtual

add the PRDs from this track to maps.

Parameters

track

all PRDs from 'track' will be added to PRD_AssociationTool's internal store.

Definition at line 39 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  // test caching
  TrackPrepRawDataMap::const_iterator itvec = maps.m_trackPrepRawDataMap.find(&track);
  if (itvec!=maps.m_trackPrepRawDataMap.end())
  {
    ATH_MSG_ERROR("track already found in cache, should not happen");
    return StatusCode::FAILURE;
  }
  // get all prds on 'track'
  std::vector< const Trk::PrepRawData* > prds = getPrdsOnTrack( maps, track );
 
  SG::ReadHandle<PixelGangedClusterAmbiguities> gangedAmbis (m_pixelClusterAmbiguitiesMapName);
 
  // loop over PRD
  for (const Trk::PrepRawData* prd : prds) {
     maps.m_prepRawDataTrackMap.emplace(prd, &track);
     // test ganged ambiguity
     if (prd->type(Trk::PrepRawDataType::PixelCluster)) {
       const PixelCluster* pixel = static_cast<const PixelCluster*> (prd);
       if (pixel->gangedPixel()) {
           ATH_MSG_DEBUG( "Found ganged pixel, search for mirror" );
           std::pair<PixelGangedClusterAmbiguities::const_iterator,
               PixelGangedClusterAmbiguities::const_iterator> ambi = gangedAmbis->equal_range(pixel);
           for (; ambi.first != ambi.second ; ++(ambi.first) ) {
           // add ambiguity as used by this track as well
             ATH_MSG_DEBUG( "Found mirror pixel, add mirror to association map" );
             maps.m_prepRawDataTrackMap.emplace(ambi.first->second, &track);
           }
       }
     }
  }
 
  // cache this using maps.m_trackPrepRawDataMap
  maps.m_trackPrepRawDataMap.emplace(&track, prds);
    
  ATH_MSG_DEBUG("Added PRDs from Track at ("<<&track<<") - map now has size: \t"
                   <<maps.m_prepRawDataTrackMap.size());
  return StatusCode::SUCCESS;
}

finalize()

StatusCode InDet::InDetPRD_AssociationToolGangedPixels::finalize ( )

overridevirtual

Definition at line 29 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  return StatusCode::SUCCESS;
}

findConnectedTracks() [1/2]

Trk::IPRD_AssociationTool::TrackSet InDet::InDetPRD_AssociationToolGangedPixels::findConnectedTracks ( const Maps & maps, const Trk::Track & track ) const

overridevirtual

Definition at line 170 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  TrackSet connectedTracks;
  
  SG::ReadHandle<PixelGangedClusterAmbiguities> gangedAmbis (m_pixelClusterAmbiguitiesMapName);
 
  std::vector< const Trk::PrepRawData* > prds = getPrdsOnTrack(maps, track);
  for (const Trk::PrepRawData* prd : prds) {
    Trk::IPRD_AssociationTool::PrepRawDataTrackMapRange range = onTracks(maps, *prd);
    // add them into the list
    for ( ; range.first!=range.second; ++(range.first) )
      connectedTracks.insert((range.first)->second);
 
    // test ganged ambiguity
    
    if (prd->type(Trk::PrepRawDataType::PixelCluster)) {
      const PixelCluster* pixel = static_cast<const PixelCluster*> (prd);
      if (pixel->gangedPixel()) {
          std::pair<PixelGangedClusterAmbiguities::const_iterator,
              PixelGangedClusterAmbiguities::const_iterator> ambi = gangedAmbis->equal_range(pixel);
        for (; ambi.first != ambi.second ; ++(ambi.first) ) {
          range = onTracks( maps, *(ambi.first->second) );
          // add them into the list
          for ( ; range.first!=range.second; ++(range.first) )
            connectedTracks.insert((range.first)->second);
        }
      }
    }
  }
 
  // don't forget to remove the input track
  connectedTracks.erase(&track);
 
  ATH_MSG_VERBOSE("Added in connected tracks for track "<<&track
                 << "\tsize of list is "<<connectedTracks.size());
 
  return connectedTracks;
}

findConnectedTracks() [2/2]

Trk::IPRD_AssociationTool::TrackSet InDet::InDetPRD_AssociationToolGangedPixels::findConnectedTracks ( const Trk::Track & track ) const

overridevirtual

returns set of tracks which share PRD with this one

Parameters

track

this Track must be known to this tool.

Returns

a set of tracks which share PRD/hits with the passed 'track'

Definition at line 164 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  return findConnectedTracks (m_maps, track);
}

getPrdsOnTrack() [1/2]

std::vector< const Trk::PrepRawData * > InDet::InDetPRD_AssociationToolGangedPixels::getPrdsOnTrack ( const Maps & maps, const Trk::Track & track ) const

overridevirtual

Definition at line 219 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  using PRDs_t = std::vector<const Trk::PrepRawData *>;
 
  // test caching
  TrackPrepRawDataMap::const_iterator itvec = maps.m_trackPrepRawDataMap.find(&track);
  if (itvec!=maps.m_trackPrepRawDataMap.end())
  {
    ATH_MSG_VERBOSE("found track in cache, return cached PRD vector for track");
    return itvec->second;
  }
 
  if (track.measurementsOnTrack()==nullptr) {
    ATH_MSG_WARNING("Track has no RoTs");
    return {}; // return vector optimization
   }
 
 
  // output vector
  PRDs_t vec;
  // size it
  vec.reserve(track.measurementsOnTrack()->size());
 
  // get the PRDs for the measuremenst on track
  DataVector<const Trk::MeasurementBase>::const_iterator it    = track.measurementsOnTrack()->begin();
  DataVector<const Trk::MeasurementBase>::const_iterator itEnd = track.measurementsOnTrack()->end();
  for (;it!=itEnd;++it){
    const auto *const   pThisMeasurement(*it);
    if (pThisMeasurement->type(Trk::MeasurementBaseType::RIO_OnTrack)){
      const Trk::RIO_OnTrack* rot = static_cast<const Trk::RIO_OnTrack*>(pThisMeasurement);
      vec.push_back(rot->prepRawData());
    }
  }
  ATH_MSG_DEBUG(" Getting "<<vec.size()<<" PRDs from track at:"<<&track);
  // new mode, we add the outliers in the TRT
  if (m_addTRToutliers) {
    // get the PRDs for the measuremenst on track
    for (const Trk::MeasurementBase* meas : *track.outliersOnTrack()){
      // get the ROT, make sure it is not a pseudo measurment
      if (meas->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
        const Trk::RIO_OnTrack* rot = static_cast<const Trk::RIO_OnTrack*>(meas);
        // check if outlier is TRT ?
        if (rot->rioType(Trk::RIO_OnTrackType::TRT_DriftCircle)) {
          // add to the list, it is TRT
          vec.push_back(rot->prepRawData());
        }
      }
    }
    ATH_MSG_DEBUG(" Getting "<<vec.size()<<" PRDs including TRT outlier from track at:"<<&track);
  }
 
  return vec;
}

getPrdsOnTrack() [2/2]

std::vector< const Trk::PrepRawData * > InDet::InDetPRD_AssociationToolGangedPixels::getPrdsOnTrack ( const Trk::Track & track ) const

overridevirtual

returns a vector of PRDs belonging to the passed track.

It's basically for the convenience of users and is created purely from the passed track. i.e. there is no caching if you do it multiple times on the same track, you're being inefficient!!

Parameters

track

this Track will be iterated through and all PrepRawData added to a vector

Returns

vector of PrepRawData* belonging to 'track'. The PrepRawData should NOT be deleted

• they belong to the Track (and thus the event).

Definition at line 212 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  return getPrdsOnTrack (m_maps, track);
}

initialize()

StatusCode InDet::InDetPRD_AssociationToolGangedPixels::initialize ( )

overridevirtual

Definition at line 23 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  ATH_CHECK( m_pixelClusterAmbiguitiesMapName.initialize() );
  return StatusCode::SUCCESS;
}

isShared() [1/2]

bool InDet::InDetPRD_AssociationToolGangedPixels::isShared ( const Maps & maps, const Trk::PrepRawData & prd ) const

inlinefinaloverridevirtual

does this PRD belong to more than one track in maps?

Parameters

prd	the PrepRawData in question

Returns

true if 'prd' exists on more than one track (of course PRD_AssociationTool can only give information about tracks it knows about i.e. that were added to maps with addPRDs()

Definition at line 131 of file InDetPRD_AssociationToolGangedPixels.h.

{
  return (maps.m_prepRawDataTrackMap.count(&prd)>1);
}

isShared() [2/2]

bool InDet::InDetPRD_AssociationToolGangedPixels::isShared ( const Trk::PrepRawData & prd ) const

inlineoverridevirtual

does this PRD belong to more than one track?

Parameters

prd	the PrepRawData in question

Returns

true if 'prd' exists on more than one track (of course PRD_AssociationTool can only give information about tracks it knows about i.e. that were added with addPRDs()

Definition at line 138 of file InDetPRD_AssociationToolGangedPixels.h.

{
  return isShared (m_maps, prd);
}

isUsed() [1/2]

bool InDet::InDetPRD_AssociationToolGangedPixels::isUsed ( const Maps & maps, const Trk::PrepRawData & prd ) const

inlinefinaloverridevirtual

does this PRD belong to at least one track in maps?

Parameters

prd	the PrepRawData in question

Returns

true if 'prd' exists in at least one track (of course PRD_AssociationTool can only give information about tracks it knows about i.e. that were added to maps with addPRDs()

Definition at line 118 of file InDetPRD_AssociationToolGangedPixels.h.

{
  return (maps.m_prepRawDataTrackMap.count(&prd)>0);
}

isUsed() [2/2]

bool InDet::InDetPRD_AssociationToolGangedPixels::isUsed ( const Trk::PrepRawData & prd ) const

inlineoverridevirtual

does this PRD belong to at least one track?

Parameters

prd	the PrepRawData in question

Returns

true if 'prd' exists in at least one track (of course PRD_AssociationTool can only give information about tracks it knows about i.e. that were added with addPRDs()

Definition at line 125 of file InDetPRD_AssociationToolGangedPixels.h.

{
  return isUsed (m_maps, prd);
}

onTracks() [1/2]

Trk::IPRD_AssociationTool::PrepRawDataTrackMapRange InDet::InDetPRD_AssociationToolGangedPixels::onTracks ( const Maps & maps, const Trk::PrepRawData & prd ) const

overridevirtual

Definition at line 281 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  return maps.m_prepRawDataTrackMap.equal_range(&prd);
}

onTracks() [2/2]

Trk::IPRD_AssociationTool::PrepRawDataTrackMapRange InDet::InDetPRD_AssociationToolGangedPixels::onTracks ( const Trk::PrepRawData & prd ) const

overridevirtual

get the Tracks associated with this Trk::PrepRawData.

IMPORTANT: Please use the typedefs IPRD_AssociationTool::PrepRawDataRange and IPRD_AssociationTool::ConstPRD_MapIt (defined in the interface) to access the tracks, as the way the data is stored internally may change.

Definition at line 275 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  return onTracks (m_maps, prd);
}

removePRDs() [1/2]

StatusCode InDet::InDetPRD_AssociationToolGangedPixels::removePRDs ( const Trk::Track & track )

overridevirtual

remove the PRDs from this track from the store

Parameters

track

all PRDs from 'track' will be removed from the PRD_AssociationTool's internal store.

Definition at line 81 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  return removePRDs (m_maps, track);
}

removePRDs() [2/2]

StatusCode InDet::InDetPRD_AssociationToolGangedPixels::removePRDs ( Maps & maps, const Trk::Track & track ) const

overridevirtual

remove the PRDs from this track from maps

Parameters

track

all PRDs from 'track' will be removed from maps

Definition at line 86 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  // This is NOT pretty code!
  // At the moment I'm brute-forcing, but maybe I need a second map, containing <Track*, iterator>
  // The problem is that I think filling such a map is also time-consuming.
  // Since removes happen much less frequently than add, then the slow bit should be here. 
  // EJWM
 
  // save for debugging purposes
  int oldSize = maps.m_prepRawDataTrackMap.size();//used in debug output at end.
 
  // test caching
  TrackPrepRawDataMap::iterator itvec = maps.m_trackPrepRawDataMap.find(&track);
  if (itvec==maps.m_trackPrepRawDataMap.end())
  {
    ATH_MSG_ERROR("Track not found in cache, this should not happen");
    return StatusCode::FAILURE;
  }
 
  SG::ReadHandle<PixelGangedClusterAmbiguities> gangedAmbis (m_pixelClusterAmbiguitiesMapName);
 
  // get all prds on 'track'
  std::vector< const Trk::PrepRawData* > prds = itvec->second;
  for (const Trk::PrepRawData* prd : prds)
  {
    // now get all map elements (i.e. Tracks) that contain this PRD
    Trk::IPRD_AssociationTool::PrepRawDataTrackMapRange 
        range = maps.m_prepRawDataTrackMap.equal_range(prd);
    // get iterators for range
    ConstPRD_MapIt mapIt    = range.first;
    ConstPRD_MapIt mapItEnd = range.second;
    // simple for loop instead of fancier remove_if above
    for ( ;mapIt!=mapItEnd; ++mapIt) {
      if ( mapIt->second==&track ) {
        maps.m_prepRawDataTrackMap.erase( mapIt );
        break;//should only ever be one Track
      }
    }
 
    // test ganged ambiguity
    
    if (prd->type(Trk::PrepRawDataType::PixelCluster)) {
      const PixelCluster* pixel = static_cast<const PixelCluster*> (prd);
      if (pixel->gangedPixel()) {
          std::pair<PixelGangedClusterAmbiguities::const_iterator,
              PixelGangedClusterAmbiguities::const_iterator> ambi = gangedAmbis->equal_range(pixel);
        for (; ambi.first != ambi.second ; ++(ambi.first) ) {
          // add ambiguity as used by this track as well
          ATH_MSG_DEBUG("Found ganged pixel, remove also mirror from association map");
 
          range = maps.m_prepRawDataTrackMap.equal_range(ambi.first->second);
          // get iterators for range
          mapIt    = range.first;
          mapItEnd = range.second;
          // simple for loop instead of fancier remove_if above
          for ( ;mapIt!=mapItEnd; ++mapIt) {
            if ( mapIt->second==&track ) {
              maps.m_prepRawDataTrackMap.erase( mapIt );
              break;//should only ever be one Track
            }
          }
        }
      }
    }
 
  }
 
  // remove cached PRD vector
  maps.m_trackPrepRawDataMap.erase( itvec );
 
  ATH_MSG_DEBUG("Removed  PRDs from track ("
                   <<&track<<") \t- map has changed size from \t"
                   <<oldSize <<" \tto "<<maps.m_prepRawDataTrackMap.size());
  return StatusCode::SUCCESS;
}

reset()

void InDet::InDetPRD_AssociationToolGangedPixels::reset ( )

overridevirtual

resets the tool - should be called before using tool (and maybe afterwards to free up memory)

Definition at line 287 of file InDetPRD_AssociationToolGangedPixels.cxx.

{
  m_maps.m_prepRawDataTrackMap.clear();
  m_maps.m_trackPrepRawDataMap.clear();
}

Member Data Documentation

m_addTRToutliers

BooleanProperty InDet::InDetPRD_AssociationToolGangedPixels::m_addTRToutliers {this, "addTRToutliers", false}

private

add TRT outliers in the addTrack method to avoid splits due to rejected extensions

Definition at line 113 of file InDetPRD_AssociationToolGangedPixels.h.

{this, "addTRToutliers", false};

m_maps

Maps InDet::InDetPRD_AssociationToolGangedPixels::m_maps

private

Definition at line 108 of file InDetPRD_AssociationToolGangedPixels.h.

m_pixelClusterAmbiguitiesMapName

SG::ReadHandleKey<PixelGangedClusterAmbiguities> InDet::InDetPRD_AssociationToolGangedPixels::m_pixelClusterAmbiguitiesMapName {this, "PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMap"}

private

Definition at line 110 of file InDetPRD_AssociationToolGangedPixels.h.

{this, "PixelClusterAmbiguitiesMapName", "PixelClusterAmbiguitiesMap"};

---

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

• InDetPRD_AssociationToolGangedPixels.h
• InDetPRD_AssociationToolGangedPixels.cxx