Trk::PRDtoTrackMapTool Class Reference

Concrete Implementation of the IPRD_AssociationTool interface. More...

#include <PRDtoTrackMapTool.h>

Inheritance diagram for Trk::PRDtoTrackMapTool:

Collaboration diagram for Trk::PRDtoTrackMapTool:

Classes
class	PRDtoTrackMap

Public Member Functions
	PRDtoTrackMapTool (const std::string &, const std::string &, const IInterface *)
virtual	~PRDtoTrackMapTool ()=default
virtual StatusCode	initialize () 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
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 PrepRawData * >	getPrdsOnTrack (Trk::PRDtoTrackMap &virt_prd_to_track_map, const Track &track) const override
	returns a vector of PRDs belonging to the passed track.
virtual IPRDtoTrackMapTool::TrackSet	findConnectedTracks (Trk::PRDtoTrackMap &virt_prd_to_track_map, const Track &track) const override

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

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

Detailed Description

Concrete Implementation of the IPRD_AssociationTool interface.

Definition at line 24 of file PRDtoTrackMapTool.h.

Constructor & Destructor Documentation

PRDtoTrackMapTool()

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

Definition at line 16 of file PRDtoTrackMapTool.cxx.

  : base_class(t,n,p)
{
}

~PRDtoTrackMapTool()

virtual Trk::PRDtoTrackMapTool::~PRDtoTrackMapTool ( )

virtualdefault

Member Function Documentation

addPRDs()

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

override

add the PRDs from this track to the store

Parameters

track

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

Definition at line 47 of file PRDtoTrackMapTool.cxx.

{
  ensureType(virt_prd_to_track_map);
  PRDtoTrackMap &prd_to_track_map = static_cast<PRDtoTrackMap&>(virt_prd_to_track_map);
 
  // test caching
  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;
  }
  // add all prds on track to map
  std::vector< const Trk::PrepRawData* > prds = getPrdsOnTrack(prd_to_track_map, track );
  for(const Trk::PrepRawData*a_prd : prds) {
    if (prd_to_track_map.m_prepRawDataTrackMap.insert(std::make_pair(a_prd, &track) ) == prd_to_track_map.m_prepRawDataTrackMap.end()) {
      ATH_MSG_ERROR ("failed to associate track to prd.");
    }
  }
 
  // cache this using m_trackPrepRawDataMap
  prd_to_track_map.m_trackPrepRawDataMap.insert( std::make_pair(&track, std::move(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 > Trk::PRDtoTrackMapTool::createPRDtoTrackMap ( ) const

overridevirtual

Definition at line 28 of file PRDtoTrackMapTool.cxx.

                                                                                {
  return std::make_unique<Trk::PRDtoTrackMapTool::PRDtoTrackMap>();
}

ensureType()

void Trk::PRDtoTrackMapTool::ensureType ( Trk::PRDtoTrackMap & virt_prd_to_track_map ) const

protected

Definition at line 36 of file PRDtoTrackMapTool.cxx.

{
  if (virt_prd_to_track_map.getType() != typeid(PRDtoTrackMapTool::PRDtoTrackMap)) {
    ATH_MSG_FATAL( "Type mismap between tool and map. Expecting " << typeid(PRDtoTrackMap).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<PRDtoTrackMap *>(&virt_prd_to_track_map) != nullptr );
}

findConnectedTracks()

Trk::PRDtoTrackMapTool::TrackSet Trk::PRDtoTrackMapTool::findConnectedTracks ( Trk::PRDtoTrackMap & virt_prd_to_track_map, const Track & track ) const

overridevirtual

Definition at line 77 of file PRDtoTrackMapTool.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(prd_to_track_map, track);
  for (const Trk::PrepRawData* a_prd : prds )
  {
    PRDtoTrackMap::PrepRawDataTrackMapRange range = prd_to_track_map.onTracks(*a_prd);
 
    // TODO use remove_copy_if instead.
    for ( ; range.first!=range.second; ++(range.first) )
    {
      const Track* conTrack = (range.first)->second;
      // don't copy this track!
      if (conTrack!=&track) {
        // this does actually not allow for double entries
        connectedTracks.insert(conTrack);
        ATH_MSG_VERBOSE ("Track "<<&track<<" \tshares PRD "<<a_prd<<" \twith track:"<<conTrack);
      }
    }
    ATH_MSG_VERBOSE ("Added in connected tracks for PRD:"<<a_prd<<
                     "\tsize of list now:"<<connectedTracks.size());
  }
 
  return connectedTracks;
}

getPrdsOnTrack()

std::vector< const Trk::PrepRawData * > Trk::PRDtoTrackMapTool::getPrdsOnTrack ( Trk::PRDtoTrackMap & virt_prd_to_track_map, const 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).

Accept only non muon hits or muon precision hits

Definition at line 109 of file PRDtoTrackMapTool.cxx.

{
  using PRDs_t = std::vector<const Trk::PrepRawData *>;
 
  ensureType(virt_prd_to_track_map);
  PRDtoTrackMap &prd_to_track_map = static_cast<PRDtoTrackMap&>(virt_prd_to_track_map);
 
  // test caching
  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()) {
    ATH_MSG_WARNING ("Track has no RoTs");
    return {};
  }
 
  // FIXME can I do this without copying the vector?
  /*  transform(
      track.measurementsOnTrack()->begin(),
      track.measurementsOnTrack()->end() ,
      back_inserter(vec),
      bind2nd(CreatePRD_VectorFromTrack(), &track) );*/
 
  PRDs_t vec;
  vec.reserve(track.measurementsOnTrack()->size());
 
  auto add_prd = [&vec, this] (const Trk::RIO_OnTrack* rot) {
    if (!rot) return;
    const PrepRawData* prd = rot->prepRawData();
    if (!prd) return;
    const Identifier rot_id = prd->identify();
    if ( m_idHelperSvc->isMuon(rot_id) && !m_idHelperSvc->isMdt(rot_id) && !m_idHelperSvc->isMM(rot_id) && !m_idHelperSvc->issTgc(rot_id) &&
          (!m_idHelperSvc->isCsc(rot_id) || m_idHelperSvc->measuresPhi(rot_id)) ) return;
    vec.push_back(prd);
  };
  for (const MeasurementBase* meas : *track.measurementsOnTrack()) {
    const Trk::RIO_OnTrack* rot = nullptr;
    if (meas->type(Trk::MeasurementBaseType::RIO_OnTrack)) {
      rot = static_cast<const RIO_OnTrack*>(meas);
    }
    if (rot) {
      add_prd(rot);
      continue;
    } 
    const Trk::CompetingRIOsOnTrack* competingROT = nullptr;
    if (meas->type(Trk::MeasurementBaseType::CompetingRIOsOnTrack)) {
        competingROT = static_cast<const Trk::CompetingRIOsOnTrack*>(meas);
    }
    if (!competingROT) { continue;}
    const unsigned int numROTs = competingROT->numberOfContainedROTs();
    for( unsigned int i=0;i<numROTs;++i ){
        const Trk::RIO_OnTrack* rot = &competingROT->rioOnTrack(i);
        add_prd(rot);            
    }
  }
  ATH_MSG_DEBUG (" Getting "<<vec.size()<<" PRDs from track at:"<<&track);
 
  return vec;
}

initialize()

StatusCode Trk::PRDtoTrackMapTool::initialize ( )

overridevirtual

Definition at line 23 of file PRDtoTrackMapTool.cxx.

                                            {
  ATH_CHECK(m_idHelperSvc.retrieve());
  return StatusCode::SUCCESS;
}

reduceToStorableMap()

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

overridevirtual

Definition at line 32 of file PRDtoTrackMapTool.cxx.

                                                                                                                        {
  return std::move(obj_in);
}

Member Data Documentation

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> Trk::PRDtoTrackMapTool::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

Definition at line 63 of file PRDtoTrackMapTool.h.

{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

---

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

• PRDtoTrackMapTool.h
• PRDtoTrackMapTool.cxx