Concrete Implementation of the IPRD_AssociationTool interface. More...

#include <InDetPRDtoTrackMapToolGangedPixels.h>

Inheritance diagram for InDet::InDetPRDtoTrackMapToolGangedPixels:

Collaboration diagram for InDet::InDetPRDtoTrackMapToolGangedPixels:

Classes
class	PRDtoTrackMap

Public Member Functions
	InDetPRDtoTrackMapToolGangedPixels (const std::string &, const std::string &, const IInterface *)
virtual	~InDetPRDtoTrackMapToolGangedPixels ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::unique_ptr< Trk::PRDtoTrackMap >	createPRDtoTrackMap () const override
virtual std::unique_ptr< Trk::PRDtoTrackMap >	reduceToStorableMap (std::unique_ptr< Trk::PRDtoTrackMap > &&obj_in) const override
virtual StatusCode	addPRDs (Trk::PRDtoTrackMap &virt_prd_to_track_map, const Trk::Track &track) const override
	add the PRDs from this track to the store
virtual std::vector< const Trk::PrepRawData * >	getPrdsOnTrack (Trk::PRDtoTrackMap &virt_prd_to_track_map, const Trk::Track &track) const override
	returns a vector of PRDs belonging to the passed track.
virtual Trk::IPRDtoTrackMapTool::TrackSet	findConnectedTracks (Trk::PRDtoTrackMap &virt_prd_to_track_map, const Trk::Track &track) const override
	returns set of tracks which share PRD with this one

Private Member Functions
void	ensureType (Trk::PRDtoTrackMap &virt_prd_to_track_map) const

Private Attributes
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 InDetPRDtoTrackMapToolGangedPixels.h.

Constructor & Destructor Documentation

◆ InDetPRDtoTrackMapToolGangedPixels()

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

Definition at line 19 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

22 : base_class(t,n,p)

23{ }

◆ ~InDetPRDtoTrackMapToolGangedPixels()

InDet::InDetPRDtoTrackMapToolGangedPixels::~InDetPRDtoTrackMapToolGangedPixels ( )

virtualdefault

Member Function Documentation

◆ addPRDs()

StatusCode InDet::InDetPRDtoTrackMapToolGangedPixels::addPRDs	(	Trk::PRDtoTrackMap &	virt_prd_to_track_map,
		const Trk::Track &	track ) const

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 79 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

{
  ensureType(virt_prd_to_track_map);
  PRDtoTrackMap &prd_to_track_map = static_cast<PRDtoTrackMap&>(virt_prd_to_track_map);
  // test caching
  Trk::PRDtoTrackMap::TrackPrepRawDataMap::const_iterator itvec = prd_to_track_map.m_trackPrepRawDataMap.find(&track);
  if (itvec!=prd_to_track_map.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(prd_to_track_map, track );
  // loop over PRD
  for (const Trk::PrepRawData* prd : prds) {
     prd_to_track_map.m_prepRawDataTrackMap.insert(std::make_pair(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 = prd_to_track_map.m_gangedAmbis->equal_range(pixel);
         for (; ambi.first != ambi.second ; ++(ambi.first) ) {
           // add ambiguity as used by this track as well
           if (msgLvl(MSG::DEBUG)) msg() << "Found mirror pixel, add mirror to association map" << endmsg;
           prd_to_track_map.m_prepRawDataTrackMap.insert(std::make_pair(ambi.first->second, &track) );
         }
       }
     }
  }
 
  // cache this using m_trackPrepRawDataMap
  prd_to_track_map.m_trackPrepRawDataMap.insert( std::make_pair(&track, prds) );
 
  ATH_MSG_DEBUG("Added PRDs from Track at ("<<&track<<") - map now has size: \t"
                <<prd_to_track_map.m_prepRawDataTrackMap.size() );
  return StatusCode::SUCCESS;
}

◆ createPRDtoTrackMap()

std::unique_ptr< Trk::PRDtoTrackMap > InDet::InDetPRDtoTrackMapToolGangedPixels::createPRDtoTrackMap ( ) const

overridevirtual

Definition at line 44 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

                                                                                                   {
  std::unique_ptr<PRDtoTrackMap> prd_to_track_map( new PRDtoTrackMap(m_pixelClusterAmbiguitiesMapName ) );
 
  ATH_MSG_DEBUG("Retrieved " << m_pixelClusterAmbiguitiesMapName.key()
                << ", number of entries for this event:"
                << (prd_to_track_map->m_gangedAmbis.isValid()  ? prd_to_track_map->m_gangedAmbis->size() : -1) );
  return std::unique_ptr<Trk::PRDtoTrackMap>(prd_to_track_map.release());
}

◆ ensureType()

void InDet::InDetPRDtoTrackMapToolGangedPixels::ensureType ( Trk::PRDtoTrackMap & virt_prd_to_track_map ) const

private

Definition at line 67 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

{
  if (virt_prd_to_track_map.getType() != typeid(InDetPRDtoTrackMapToolGangedPixels::PRDtoTrackMap)) {
    ATH_MSG_FATAL( "Type mismap between tool and map. Expecting " << typeid(InDetPRDtoTrackMapToolGangedPixels).name()
                   << " but got " << virt_prd_to_track_map.getType().name()
                   << " . The tool can only handle a map created by the same tool. ");
    throw std::logic_error("Type mismap between tool and map");
  }
  assert( dynamic_cast<InDetPRDtoTrackMapToolGangedPixels::PRDtoTrackMap *>(&virt_prd_to_track_map) != nullptr );
}

◆ finalize()

StatusCode InDet::InDetPRDtoTrackMapToolGangedPixels::finalize ( )

overridevirtual

Definition at line 39 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

{
  return StatusCode::SUCCESS;
}

◆ findConnectedTracks()

Trk::IPRDtoTrackMapTool::TrackSet InDet::InDetPRDtoTrackMapToolGangedPixels::findConnectedTracks	(	Trk::PRDtoTrackMap &	virt_prd_to_track_map,
		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 121 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

{
  ensureType(virt_prd_to_track_map);
  PRDtoTrackMap &prd_to_track_map = static_cast<PRDtoTrackMap&>(virt_prd_to_track_map);
  
  TrackSet connectedTracks;
  
  std::vector< const Trk::PrepRawData* > prds = getPrdsOnTrack(virt_prd_to_track_map, track);
  for (const Trk::PrepRawData* prd : prds) {
    Trk::PRDtoTrackMap::ConstPrepRawDataTrackMapRange range = prd_to_track_map.onTracks(*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 = prd_to_track_map.m_gangedAmbis->equal_range(pixel);
        for (; ambi.first != ambi.second ; ++(ambi.first) ) {
          range = prd_to_track_map.onTracks( *(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;
}

◆ getPrdsOnTrack()

std::vector< const Trk::PrepRawData * > InDet::InDetPRDtoTrackMapToolGangedPixels::getPrdsOnTrack	(	Trk::PRDtoTrackMap &	virt_prd_to_track_map,
		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 164 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

{
  ensureType(virt_prd_to_track_map);
  PRDtoTrackMap &prd_to_track_map = static_cast<PRDtoTrackMap&>(virt_prd_to_track_map);
  using PRDs_t = std::vector<const Trk::PrepRawData *>;
 
  // test caching
  Trk::PRDtoTrackMap::TrackPrepRawDataMap::const_iterator itvec = prd_to_track_map.m_trackPrepRawDataMap.find(&track);
  if (itvec!=prd_to_track_map.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
   }
 
  // FIXME can I do this without copying the vector?
  /*  transform(
      track.measurementsOnTrack()->begin(), 
      track.measurementsOnTrack()->end() ,
      back_inserter(vec), 
      bind2nd(CreatePRD_VectorFromTrack(), &track) );*/
 
  // output vector
  PRDs_t vec;
  // size it
  vec.reserve(track.measurementsOnTrack()->size());
 
  // get the PRDs for the measurements 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 meas{*it};
    if (meas->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
      const Trk::RIO_OnTrack* rot = static_cast<const Trk::RIO_OnTrack*>(meas);
      if(rot->prepRawData()) 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 measurements on track
    for (const Trk::MeasurementBase* meas : *track.outliersOnTrack()){
      // get the ROT, make sure it is not a pseudo measurement
      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
          if(rot->prepRawData()) vec.push_back(rot->prepRawData());
        }
      }
    }
    ATH_MSG_DEBUG(" Getting "<<vec.size()<<" PRDs including TRT outlier from track at:"<<&track);
  }
 
  return vec;
}

◆ initialize()

StatusCode InDet::InDetPRDtoTrackMapToolGangedPixels::initialize ( )

overridevirtual

Definition at line 28 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

{
  bool has_ambi_map = m_pixelClusterAmbiguitiesMapName.initialize(!m_pixelClusterAmbiguitiesMapName.key().empty()).isSuccess();
  if (!has_ambi_map && !m_pixelClusterAmbiguitiesMapName.key().empty()) {
    ATH_MSG_WARNING("Could not retrieve "<< m_pixelClusterAmbiguitiesMapName.key() << " this is ok if pixel is off");
    // @TODO introduce more robust method  e.g. dummy tool  if pixel is off ?
  }
 
  return StatusCode::SUCCESS;
}

◆ reduceToStorableMap()

std::unique_ptr< Trk::PRDtoTrackMap > InDet::InDetPRDtoTrackMapToolGangedPixels::reduceToStorableMap ( std::unique_ptr< Trk::PRDtoTrackMap > && obj_in ) const

overridevirtual

Definition at line 53 of file InDetPRDtoTrackMapToolGangedPixels.cxx.

                                                                                                                                           {
  if (obj_in->getType()!=typeid(Trk::PRDtoTrackMap)) {
    return std::move(obj_in);
  }
  if (obj_in->getType()!=typeid(InDet::InDetPRDtoTrackMapToolGangedPixels)) {
    ATH_MSG_FATAL( "Type mismap between tool and map. Expecting " << typeid(InDet::InDetPRDtoTrackMapToolGangedPixels).name()
                   << " but got " << obj_in->getType().name()
                   << " . The tool can only handle a map created by the same tool. ");
  }
  Trk::PRDtoTrackMap *the_obj=static_cast<PRDtoTrackMap *>(obj_in.get());
  return std::make_unique<Trk::PRDtoTrackMap>(std::move(*the_obj));
}

Member Data Documentation

◆ m_addTRToutliers

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

private

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

Definition at line 62 of file InDetPRDtoTrackMapToolGangedPixels.h.

62{this, "addTRToutliers", false};

◆ m_pixelClusterAmbiguitiesMapName

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

private

Definition at line 59 of file InDetPRDtoTrackMapToolGangedPixels.h.

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

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

Classes

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ InDetPRDtoTrackMapToolGangedPixels()

◆ ~InDetPRDtoTrackMapToolGangedPixels()

Member Function Documentation

◆ addPRDs()

◆ createPRDtoTrackMap()

◆ ensureType()

◆ finalize()

◆ findConnectedTracks()

◆ getPrdsOnTrack()

◆ initialize()

◆ reduceToStorableMap()

Member Data Documentation

◆ m_addTRToutliers

◆ m_pixelClusterAmbiguitiesMapName