Trk::TrkObserverTool Class Reference

#include <TrkObserverTool.h>

Inheritance diagram for Trk::TrkObserverTool:

Collaboration diagram for Trk::TrkObserverTool:

Classes
struct	CacheEntry

Public Member Functions
	TrkObserverTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TrkObserverTool ()
virtual StatusCode	initialize ()
virtual StatusCode	finalize ()
void	updateTrackMap (int uid, double score, xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason) const
void	updateScore (int uid, double score) const
void	rejectTrack (int uid, xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason) const
void	addInputTrack (int uid, const Trk::Track &track) const
void	addSubTrack (int track_uid, int parent_uid, const Trk::Track &track) const
ObservedTrackMap *	getTrackMap (const EventContext &ctx) const
int	saveTracksToStore (const EventContext &ctx, const ObservedTrackMap *trk_map) const
void	updateHolesSharedHits (int uid, int numPixelHoles, int numSCTHoles, int numSplitSharedPixel, int numSplitSharedSCT, int numSharedOrSplit, int numSharedOrSplitPixels, int numShared, int isPatternTrack, int totalSiHits, int inROI, int hasIBLHit, int hasSharedIBLHit, int hasSharedPixel, int firstPixIsShared, int numPixelDeadSensor, int numSCTDeadSensor, int numPixelHits, int numSCTHits, int numUnused, int numTRT_Unused, int numSCT_Unused, int numPseudo, float averageSplit1, float averageSplit2, int numWeightedShared) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Private Member Functions
void	newEvent (CacheEntry *ent) const
void	dumpTrackMap (const ObservedTrackMap *trk_map) const

Static Private Member Functions
static std::string	dumpRejection (xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason)
static int	getNFinalTracks (const ObservedTrackMap *trk_map)
static int	getNObservedTracks (const ObservedTrackMap *trk_map)

Private Attributes
SG::WriteHandleKey< TrackCollection >	m_savedTracksWriteKey
SG::WriteHandleKey< ObservedTrackMap >	m_savedTracksMapWriteKey
std::mutex	m_mutex
SG::SlotSpecificObj< CacheEntry > m_cache	ATLAS_THREAD_SAFE

Static Private Attributes
static const std::map< xAOD::RejectionStep, std::string >	m_rejectStep_descriptions
static const std::map< xAOD::RejectionReason, std::string >	m_rejectReason_descriptions

Detailed Description

Definition at line 40 of file TrkObserverTool.h.

Constructor & Destructor Documentation

TrkObserverTool()

Trk::TrkObserverTool::TrkObserverTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 61 of file TrkObserverTool.cxx.

    : AthAlgTool(type, name, parent){
            declareInterface< ITrkObserverTool >(this);
            declareProperty("ObsTrackCollection", m_savedTracksWriteKey);
            declareProperty("ObsTrackCollectionMap", m_savedTracksMapWriteKey);
}

~TrkObserverTool()

Trk::TrkObserverTool::~TrkObserverTool ( )

virtualdefault

Member Function Documentation

addInputTrack()

void Trk::TrkObserverTool::addInputTrack ( int uid, const Trk::Track & track ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 168 of file TrkObserverTool.cxx.

                                                                           {
 
    ATH_MSG_DEBUG("addInputTrack: track "<<uid);
    // test to see if we have a new event
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    std::lock_guard<std::mutex> lock{m_mutex};
    CacheEntry* ent{m_cache.get(ctx)};
    if (ent->m_evt!=ctx.evt()) {
        // New event in this slot
        newEvent(ent);
        ent->m_evt = ctx.evt();
    }
    // add input track to cache map
    std::unique_ptr<Trk::Track> copiedTrack = std::make_unique<Trk::Track>(track);
    std::vector<xAOD::RejectionStep> v_rejectStep = {xAOD::RejectionStep::solveTracks};
    std::vector<xAOD::RejectionReason> v_rejectReason = {xAOD::RejectionReason::acceptedTrack};
    ent->m_observedTrkMap->insert( std::make_pair(uid, std::make_tuple(copiedTrack.release(), // Id, track
                                             -1, // score
                                             xAOD::RejectionStep::solveTracks, // rejection step
                                             xAOD::RejectionReason::acceptedTrack, // rejection reason
                                             0, // unique parentId
                                             // holes/shared/split hits information (-2 means not filled yet)
                                             -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2.0f, -2.0f, -2,
                                             v_rejectStep, v_rejectReason)));
}

addSubTrack()

void Trk::TrkObserverTool::addSubTrack ( int track_uid, int parent_uid, const Trk::Track & track ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 194 of file TrkObserverTool.cxx.

                                                                                               {
 
    ATH_MSG_DEBUG("addSubTrack: subtrack "<<track_uid);
    // get event context and map from cache
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    std::lock_guard<std::mutex> lock{m_mutex};
    ObservedTrackMap* trk_map = getTrackMap(ctx);
 
    // deep copy of the track (because some subtracks get deleted), information has to be available later
    std::unique_ptr<Trk::Track> copiedTrack = std::make_unique<Trk::Track>(track);
    // get score and rejection step from parent element
    double score = -1;
    xAOD::RejectionStep rejectStep = xAOD::RejectionStep::solveTracks;
    if ( trk_map->find(parent_uid) == trk_map->end() ) {
        // not found
        ATH_MSG_WARNING("addSubTrack: parent " << parent_uid << " not found in observedTrkMap");
    }
    else {
        // found
        score = std::get<xAOD::ObserverToolIndex::score>(trk_map->at(parent_uid));
        rejectStep = std::get<xAOD::ObserverToolIndex::rejectStep>(trk_map->at(parent_uid));
        ATH_MSG_DEBUG("addSubTrack: track "<<track_uid<<" with parent "<<parent_uid<<", score "<<score);
    }
    // add subtrack to cache map
    std::vector<xAOD::RejectionStep> v_rejectStep = {rejectStep};
    std::vector<xAOD::RejectionReason> v_rejectReason = {xAOD::RejectionReason::acceptedTrack};
    trk_map->insert( std::make_pair(track_uid, std::make_tuple(copiedTrack.release(), // Id, track
                                             score, // score
                                             rejectStep, // rejection step
                                             xAOD::RejectionReason::acceptedTrack, // rejection reason
                                             parent_uid, // unique parentId
                                             // holes/shared/split hits information (-2 means not filled yet)
                                             -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2.0f, -2.0f, -2,
                                             v_rejectStep, v_rejectReason)));
}

dumpRejection()

std::string Trk::TrkObserverTool::dumpRejection ( xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason )

staticprivate

Definition at line 391 of file TrkObserverTool.cxx.

                                                                                                          {
    // Generate rejection description
    std::string rejection_step = "";
    std::string rejection_reason = "";
    std::string rejection_description = "";
    const auto istep = m_rejectStep_descriptions.find(rejectStep);
    if ( istep == m_rejectStep_descriptions.end() ) {
        // not found
        rejection_step = "REJECTION STEP DESCRIPTION NOT FOUND: " + std::to_string(rejectStep);
    }
    else {
        // found
        rejection_step = istep->second;
    }
    const auto ireason = m_rejectReason_descriptions.find(rejectReason);
    if ( ireason == m_rejectReason_descriptions.end() ) {
        // not found
        rejection_reason = "REJECTION REASON DESCRIPTION NOT FOUND: " + std::to_string(rejectReason);
    }
    else {
        // found
        rejection_reason = ireason->second;
    }
    rejection_description = rejection_step + " (" + rejection_reason + ")";
    return rejection_description;
}

dumpTrackMap()

void Trk::TrkObserverTool::dumpTrackMap ( const ObservedTrackMap * trk_map ) const

private

Definition at line 349 of file TrkObserverTool.cxx.

                                                                           {
 
    // prints out/dumps all entries in m_observedTrkMap
 
    std::lock_guard<std::mutex> lock{m_mutex};
 
    ATH_MSG_INFO ("Dump observedTrkMap (size = " << getNObservedTracks(trk_map) << ")");
    for (const auto& itrMap : *trk_map) {
        ATH_MSG_DEBUG("Id: " << itrMap.first);
        ATH_MSG_DEBUG("\tscore:                  " << std::get<xAOD::ObserverToolIndex::score>(itrMap.second));
        ATH_MSG_DEBUG("\trejectStep:             " << std::get<xAOD::ObserverToolIndex::rejectStep>(itrMap.second));
        ATH_MSG_DEBUG("\trejectReason:           " << std::get<xAOD::ObserverToolIndex::rejectReason>(itrMap.second));
        ATH_MSG_DEBUG("\tparentId:               " << std::get<xAOD::ObserverToolIndex::parentId>(itrMap.second));
        ATH_MSG_DEBUG("\tnumPixelHoles:          " << std::get<xAOD::ObserverToolIndex::numPixelHoles>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSCTHoles:            " << std::get<xAOD::ObserverToolIndex::numSCTHoles>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSplitSharedPixel:    " << std::get<xAOD::ObserverToolIndex::numSplitSharedPixel>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSplitSharedSCT:      " << std::get<xAOD::ObserverToolIndex::numSplitSharedSCT>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSharedOrSplit:       " << std::get<xAOD::ObserverToolIndex::numSharedOrSplit>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSharedOrSplitPixels: " << std::get<xAOD::ObserverToolIndex::numSharedOrSplitPixels>(itrMap.second));
        ATH_MSG_DEBUG("\tnumShared:              " << std::get<xAOD::ObserverToolIndex::numShared>(itrMap.second));
        ATH_MSG_DEBUG("\tisPatternTrack:         " << std::get<xAOD::ObserverToolIndex::isPatternTrack>(itrMap.second));
        ATH_MSG_DEBUG("\ttotalSiHits:            " << std::get<xAOD::ObserverToolIndex::totalSiHits>(itrMap.second));
        ATH_MSG_DEBUG("\tinROI:                  " << std::get<xAOD::ObserverToolIndex::inROI>(itrMap.second));
        ATH_MSG_DEBUG("\thasIBLHit:              " << std::get<xAOD::ObserverToolIndex::hasIBLHit>(itrMap.second));
        ATH_MSG_DEBUG("\thasSharedIBLHit:        " << std::get<xAOD::ObserverToolIndex::hasSharedIBLHit>(itrMap.second));
        ATH_MSG_DEBUG("\thasSharedPixel:         " << std::get<xAOD::ObserverToolIndex::hasSharedPixel>(itrMap.second));
        ATH_MSG_DEBUG("\tfirstPixIsShared:       " << std::get<xAOD::ObserverToolIndex::firstPixIsShared>(itrMap.second));
        ATH_MSG_DEBUG("\tnumPixelDeadSensor:     " << std::get<xAOD::ObserverToolIndex::numPixelDeadSensor>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSCTDeadSensor:       " << std::get<xAOD::ObserverToolIndex::numSCTDeadSensor>(itrMap.second));
        ATH_MSG_DEBUG("\tnumPixelHits:           " << std::get<xAOD::ObserverToolIndex::numPixelHits>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSCTHits:             " << std::get<xAOD::ObserverToolIndex::numSCTHits>(itrMap.second));
        ATH_MSG_DEBUG("\tnumUnused:              " << std::get<xAOD::ObserverToolIndex::numUnused>(itrMap.second));
        ATH_MSG_DEBUG("\tnumTRT_Unused:          " << std::get<xAOD::ObserverToolIndex::numTRT_Unused>(itrMap.second));
        ATH_MSG_DEBUG("\tnumSCT_Unused:          " << std::get<xAOD::ObserverToolIndex::numSCT_Unused>(itrMap.second));
        ATH_MSG_DEBUG("\tnumPseudo:              " << std::get<xAOD::ObserverToolIndex::numPseudo>(itrMap.second));
        ATH_MSG_DEBUG("\taverageSplit1:          " << std::get<xAOD::ObserverToolIndex::averageSplit1>(itrMap.second));
        ATH_MSG_DEBUG("\taverageSplit2:          " << std::get<xAOD::ObserverToolIndex::averageSplit2>(itrMap.second));
        ATH_MSG_DEBUG("\tnumWeightedShared:      " << std::get<xAOD::ObserverToolIndex::numWeightedShared>(itrMap.second));
    }
    ATH_MSG_DEBUG("Number of RejectionReason = acceptedTrack (should equal final tracks): " << getNFinalTracks(trk_map));
}

finalize()

StatusCode Trk::TrkObserverTool::finalize ( )

virtual

Definition at line 85 of file TrkObserverTool.cxx.

                                        {
    ATH_MSG_INFO("Finalizing " << name() << "...");
    return StatusCode::SUCCESS;
}

getNFinalTracks()

int Trk::TrkObserverTool::getNFinalTracks ( const ObservedTrackMap * trk_map )

staticprivate

Definition at line 418 of file TrkObserverTool.cxx.

                                                                       {
    // counts the tracks which did not get rejected (this number should equal finalTracks)
    int nFinalTracks = 0;
    for (const auto& itrMap : *trk_map) {
        if (std::get<xAOD::ObserverToolIndex::rejectReason>(itrMap.second) == xAOD::RejectionReason::acceptedTrack) nFinalTracks++;
    }
    return nFinalTracks;
}

getNObservedTracks()

int Trk::TrkObserverTool::getNObservedTracks ( const ObservedTrackMap * trk_map )

staticprivate

Definition at line 427 of file TrkObserverTool.cxx.

                                                                          {
    // check the number of tracks in the observer tool map
    return trk_map->size();
}

getTrackMap()

ObservedTrackMap * Trk::TrkObserverTool::getTrackMap ( const EventContext & ctx ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 230 of file TrkObserverTool.cxx.

                                                                               {
 
    ATH_MSG_DEBUG("Get track map from cache");
    // get cache
    CacheEntry* ent{m_cache.get(ctx)};
    // sanity check
    if (ent->m_evt!=ctx.evt()) { 
        ATH_MSG_ERROR("Different event context in getTrackMap!!");
    }
    return ent->m_observedTrkMap;
}

initialize()

StatusCode Trk::TrkObserverTool::initialize ( )

virtual

Definition at line 74 of file TrkObserverTool.cxx.

                                          {
    ATH_MSG_INFO("Initializing TrkObserverTool with name: " << name());
    ATH_MSG_INFO("\tm_savedTracksWriteKey: " << m_savedTracksWriteKey.key());
    ATH_MSG_INFO("\tm_savedTracksMapWriteKey: " << m_savedTracksMapWriteKey.key());
    ATH_CHECK(AthAlgTool::initialize());
    ATH_CHECK(m_savedTracksWriteKey.initialize(!m_savedTracksWriteKey.key().empty()));
    ATH_CHECK(m_savedTracksMapWriteKey.initialize(!m_savedTracksMapWriteKey.key().empty()));
    ATH_MSG_INFO("Initialized TrkObserverTool");
    return StatusCode::SUCCESS;
}

interfaceID()

const InterfaceID & Trk::ITrkObserverTool::interfaceID ( )

inlinestaticinherited

Definition at line 49 of file ITrkObserverTool.h.

                                                               { 
        return IID_ITrkObserverTool; 
    }

newEvent()

void Trk::TrkObserverTool::newEvent ( CacheEntry * ent ) const

private

Definition at line 93 of file TrkObserverTool.cxx.

                                                       {
    ATH_MSG_DEBUG("Starting new event");
    if (ent->m_observedTrkMap) {
        ent->m_observedTrkMap->clear();
        delete ent->m_observedTrkMap;
    }
    ent->m_observedTrkMap = new ObservedTrackMap;
}

rejectTrack()

void Trk::TrkObserverTool::rejectTrack ( int uid, xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 145 of file TrkObserverTool.cxx.

                                                                                                                  {
 
    ATH_MSG_DEBUG("rejectTrack: track "<<uid);
    // get event context and map from cache
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    std::lock_guard<std::mutex> lock{m_mutex};
    ObservedTrackMap* trk_map = getTrackMap(ctx);
    // find track and update rejection location
    if ( trk_map->find(uid) == trk_map->end() ) {
        // not found
        ATH_MSG_WARNING("rejectTrack: track "<<uid<<" not found in observedTrkMap");
    }
    else {
        // found
        std::get<xAOD::ObserverToolIndex::rejectStep>(trk_map->at(uid)) = rejectStep;
        std::get<xAOD::ObserverToolIndex::rejectReason>(trk_map->at(uid)) = rejectReason;
        // Keep track of cumulative rejection steps/reasons
        std::get<xAOD::ObserverToolIndex::rejectStep_full>(trk_map->at(uid)).push_back(rejectStep);
        std::get<xAOD::ObserverToolIndex::rejectReason_full>(trk_map->at(uid)).push_back(rejectReason);
        ATH_MSG_DEBUG("rejectTrack: track "<<uid<<" with rejection in "<<dumpRejection(rejectStep, rejectReason));
    }
}

saveTracksToStore()

int Trk::TrkObserverTool::saveTracksToStore ( const EventContext & ctx, const ObservedTrackMap * trk_map ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 242 of file TrkObserverTool.cxx.

                                                                                                        {
 
    std::lock_guard<std::mutex> lock{m_mutex};
    // Save tracks and map to store
    ATH_MSG_INFO ("saveTracksToStore: Recording empty observed track containers to event store");
    ATH_MSG_DEBUG("\tm_savedTracksWriteKey: "<<m_savedTracksWriteKey.key());
    ATH_MSG_DEBUG("\tm_savedTracksMapWriteKey: "<<m_savedTracksMapWriteKey.key());
 
    SG::WriteHandle<TrackCollection> wh_tracks{m_savedTracksWriteKey, ctx};
    SG::WriteHandle<ObservedTrackMap> wh_tracksMap{m_savedTracksMapWriteKey, ctx};
 
    // Tracks write handle
    StatusCode sc = wh_tracks.record(std::make_unique<TrackCollection>());
    if (sc.isFailure()) {
        ATH_MSG_ERROR("saveTracksToStore: Could not record input tracks: "<<m_savedTracksWriteKey.key());
    }
    else {
        ATH_MSG_INFO("saveTracksToStore: Recorded empty container for input tracks to: "<<m_savedTracksWriteKey.key());
    }
    if (!wh_tracks.isValid()) {
        ATH_MSG_DEBUG ("saveTracksToStore: Invalid key: "<<m_savedTracksWriteKey.key());
    }
    else {
        ATH_MSG_DEBUG ("saveTracksToStore: Valid key: "<<m_savedTracksWriteKey.key());
    }
 
    // Tracks map write handle
    sc = wh_tracksMap.record(std::make_unique<ObservedTrackMap>());
    if (sc.isFailure()) {
        ATH_MSG_ERROR("saveTracksToStore: Could not record tracks map: "<<m_savedTracksMapWriteKey.key());
    }
    else {
        ATH_MSG_INFO("saveTracksToStore: Recorded empty container for tracks map to: "<<m_savedTracksMapWriteKey.key());
    }
    if (!wh_tracksMap.isValid()) {
        ATH_MSG_DEBUG ("saveTracksToStore: Invalid key: "<<m_savedTracksMapWriteKey.key());
    }
    else {
        ATH_MSG_DEBUG ("saveTracksToStore: Valid key: "<<m_savedTracksMapWriteKey.key());
    }
    if (!trk_map){
        return 0;
    }
    else {
        ATH_MSG_INFO ("saveTracksToStore: Recording "<<trk_map->size() << " observed track candidates to event store");
    }
    for (const auto& itrMap : *trk_map) {
        ATH_MSG_DEBUG("saveTracksToStore: Writing track with id "<<itrMap.first<<", rejection step "<<std::get<xAOD::ObserverToolIndex::rejectStep>(itrMap.second)<<", rejection reason "<<std::get<xAOD::ObserverToolIndex::rejectReason>(itrMap.second));
        wh_tracks->push_back(std::get<xAOD::ObserverToolIndex::track>(itrMap.second));
        wh_tracksMap->insert(std::make_pair(itrMap.first, itrMap.second));
    }
 
    ATH_MSG_DEBUG("saveTracksToStore: Pushed "<<wh_tracks->size()<<" observed tracks to store");
    ATH_MSG_DEBUG("saveTracksToStore: Pushed "<<wh_tracksMap->size()<<" pairs to track map in store");
    // Keep track of "good" tracks as a sanity check
    int nFinalTracks = getNFinalTracks(trk_map);
    ATH_MSG_DEBUG ("saveTracksToStore: Number of RejectionReason = acceptedTrack (should equal final tracks): " << nFinalTracks);
    return nFinalTracks;
}

updateHolesSharedHits()

void Trk::TrkObserverTool::updateHolesSharedHits ( int uid, int numPixelHoles, int numSCTHoles, int numSplitSharedPixel, int numSplitSharedSCT, int numSharedOrSplit, int numSharedOrSplitPixels, int numShared, int isPatternTrack, int totalSiHits, int inROI, int hasIBLHit, int hasSharedIBLHit, int hasSharedPixel, int firstPixIsShared, int numPixelDeadSensor, int numSCTDeadSensor, int numPixelHits, int numSCTHits, int numUnused, int numTRT_Unused, int numSCT_Unused, int numPseudo, float averageSplit1, float averageSplit2, int numWeightedShared ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 302 of file TrkObserverTool.cxx.

                                                                                                                                                                   {
 
    ATH_MSG_DEBUG("updateHolesSharedHits: track "<<uid);
    // get event context and map from cache
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    std::lock_guard<std::mutex> lock{m_mutex};
    ObservedTrackMap* trk_map = getTrackMap(ctx);
 
    // find track and update rejection location
    if ( trk_map->find(uid) == trk_map->end() ) {
        // not found
        ATH_MSG_WARNING("updateHolesSharedHits: track "<<uid<<" not found in observedTrkMap");
    }
    else {
        // found
        std::get<xAOD::ObserverToolIndex::numPixelHoles>(trk_map->at(uid))  = numPixelHoles;   
        std::get<xAOD::ObserverToolIndex::numSCTHoles>(trk_map->at(uid))  = numSCTHoles; 
        std::get<xAOD::ObserverToolIndex::numSplitSharedPixel>(trk_map->at(uid))  = numSplitSharedPixel; // Number of Pixel clusters comptaible with being split that are also shared
        std::get<xAOD::ObserverToolIndex::numSplitSharedSCT>(trk_map->at(uid))  = numSplitSharedSCT; // Number of SCT clusters comptaible with being split that are also shared
        std::get<xAOD::ObserverToolIndex::numSharedOrSplit>(trk_map->at(uid))  = numSharedOrSplit; // Number of split + shared clusters
        std::get<xAOD::ObserverToolIndex::numSharedOrSplitPixels>(trk_map->at(uid)) = numSharedOrSplitPixels; // Number of pixel clusters that are either split or shared
        std::get<xAOD::ObserverToolIndex::numShared>(trk_map->at(uid)) = numShared; // Number of shared hits on track
        std::get<xAOD::ObserverToolIndex::isPatternTrack>(trk_map->at(uid)) = isPatternTrack; // Pattern Track or Fitted track
        std::get<xAOD::ObserverToolIndex::totalSiHits>(trk_map->at(uid)) = totalSiHits; // totalSiHits
        std::get<xAOD::ObserverToolIndex::inROI>(trk_map->at(uid)) = inROI;
        std::get<xAOD::ObserverToolIndex::hasIBLHit>(trk_map->at(uid)) = hasIBLHit;
        std::get<xAOD::ObserverToolIndex::hasSharedIBLHit>(trk_map->at(uid)) = hasSharedIBLHit;
        std::get<xAOD::ObserverToolIndex::hasSharedPixel>(trk_map->at(uid)) = hasSharedPixel;
        std::get<xAOD::ObserverToolIndex::firstPixIsShared>(trk_map->at(uid)) = firstPixIsShared;
        std::get<xAOD::ObserverToolIndex::numPixelDeadSensor>(trk_map->at(uid)) = numPixelDeadSensor;
        std::get<xAOD::ObserverToolIndex::numSCTDeadSensor>(trk_map->at(uid)) = numSCTDeadSensor;
        std::get<xAOD::ObserverToolIndex::numPixelHits>(trk_map->at(uid)) = numPixelHits;
        std::get<xAOD::ObserverToolIndex::numSCTHits>(trk_map->at(uid)) = numSCTHits;
        std::get<xAOD::ObserverToolIndex::numUnused>(trk_map->at(uid)) = numUnused;
        std::get<xAOD::ObserverToolIndex::numTRT_Unused>(trk_map->at(uid)) = numTRT_Unused;
        std::get<xAOD::ObserverToolIndex::numSCT_Unused>(trk_map->at(uid)) = numSCT_Unused;
        std::get<xAOD::ObserverToolIndex::numPseudo>(trk_map->at(uid)) = numPseudo;
        std::get<xAOD::ObserverToolIndex::averageSplit1>(trk_map->at(uid)) = averageSplit1;
        std::get<xAOD::ObserverToolIndex::averageSplit2>(trk_map->at(uid)) = averageSplit2;
        std::get<xAOD::ObserverToolIndex::numWeightedShared>(trk_map->at(uid)) = numWeightedShared;
        ATH_MSG_DEBUG("updateHolesSharedHits: track "<<uid<<" with totalSiHits "<<totalSiHits);
    }
}

updateScore()

void Trk::TrkObserverTool::updateScore ( int uid, double score ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 126 of file TrkObserverTool.cxx.

                                                                {
 
    ATH_MSG_DEBUG("updateScore: track "<<uid);
    // get event context and map from cache
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    std::lock_guard<std::mutex> lock{m_mutex};
    ObservedTrackMap* trk_map = getTrackMap(ctx);
    // find track and update score
    if ( trk_map->find(uid) == trk_map->end() ) {
        // not found
        ATH_MSG_WARNING("updateScore: track " << uid << " not found in observedTrkMap");
    }
    else {
        // found
        std::get<xAOD::ObserverToolIndex::score>(trk_map->at(uid)) = score;
        ATH_MSG_DEBUG("updateScore: track "<<uid<<" with score "<<score);
    }
}

updateTrackMap()

void Trk::TrkObserverTool::updateTrackMap ( int uid, double score, xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason ) const

virtual

Implements Trk::ITrkObserverTool.

Definition at line 102 of file TrkObserverTool.cxx.

                                                                                                                                   {
 
    ATH_MSG_DEBUG("updateTrackMap: track "<<uid);
    // get event context and map from cache
    const EventContext& ctx{Gaudi::Hive::currentContext()};
    std::lock_guard<std::mutex> lock{m_mutex};
    ObservedTrackMap* trk_map = getTrackMap(ctx);
    // find track and update score
    if ( trk_map->find(uid) == trk_map->end() ) {
        // not found
        ATH_MSG_WARNING("updateTrackMap: track << " << uid << " not found in observedTrkMap");
    }
    else {
        // found
        std::get<xAOD::ObserverToolIndex::score>(trk_map->at(uid)) = score;
        std::get<xAOD::ObserverToolIndex::rejectStep>(trk_map->at(uid)) = rejectStep;
        std::get<xAOD::ObserverToolIndex::rejectReason>(trk_map->at(uid)) = rejectReason;
        // Keep track of cumulative rejection steps/reasons
        std::get<xAOD::ObserverToolIndex::rejectStep_full>(trk_map->at(uid)).push_back(rejectStep);
        std::get<xAOD::ObserverToolIndex::rejectReason_full>(trk_map->at(uid)).push_back(rejectReason);
        ATH_MSG_DEBUG("updateTrackMap: track "<<uid<<" with score, rejectStep, rejectReason: "<<score<<", "<<rejectStep<<", "<<rejectReason);
    }
}

Member Data Documentation

ATLAS_THREAD_SAFE

SG::SlotSpecificObj<CacheEntry> m_cache Trk::TrkObserverTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 71 of file TrkObserverTool.h.

m_mutex

std::mutex Trk::TrkObserverTool::m_mutex

mutableprivate

Definition at line 65 of file TrkObserverTool.h.

m_rejectReason_descriptions

const std::map< xAOD::RejectionReason, std::string > Trk::TrkObserverTool::m_rejectReason_descriptions

staticprivate

Definition at line 440 of file TrkObserverTool.h.

m_rejectStep_descriptions

const std::map< xAOD::RejectionStep, std::string > Trk::TrkObserverTool::m_rejectStep_descriptions

staticprivate

Initial value:

= {
    {xAOD::RejectionStep::addNewTracks, "DenseEnvironmentsAmbiguityScoreProcessorTool::addNewTracks"},
    {xAOD::RejectionStep::refitTrack, "AmbiguityProcessorBase::refitTrack"},
    {xAOD::RejectionStep::addTrack, "AmbiguityProcessorBase::addTrack"},
    {xAOD::RejectionStep::decideWhichHitsToKeep, "InDetDenseEnvAmbiTrackSelectionTool::decideWhichHitsToKeep"},
    {xAOD::RejectionStep::getCleanedOutTrack, "InDetDenseEnvAmbiTrackSelectionTool::getCleanedOutTrack"}
}

Definition at line 432 of file TrkObserverTool.h.

              {
 
    class ITrackParticleCreatorTool;
 
    class TrkObserverTool : virtual public Trk::ITrkObserverTool, public :: AthAlgTool {
        public:
            TrkObserverTool(const std::string& type, const std::string& name, const IInterface* parent);
            virtual ~TrkObserverTool();
            // athena algtool's Hooks
            virtual StatusCode initialize();
            virtual StatusCode finalize();
            // const methods
            void updateTrackMap(int uid, double score, xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason) const;
            void updateScore(int uid, double score) const;
            void rejectTrack(int uid, xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason) const;
            void addInputTrack(int uid, const Trk::Track& track) const;
            void addSubTrack(int track_uid, int parent_uid, const Trk::Track& track) const;
            ObservedTrackMap* getTrackMap(const EventContext& ctx) const;
            int saveTracksToStore(const EventContext& ctx, const ObservedTrackMap* trk_map) const;
            void updateHolesSharedHits(int uid, int numPixelHoles, int numSCTHoles, int numSplitSharedPixel, int numSplitSharedSCT,
                int numSharedOrSplit, int numSharedOrSplitPixels, int numShared, int isPatternTrack, int totalSiHits, int inROI, int hasIBLHit,
                int hasSharedIBLHit, int hasSharedPixel, int firstPixIsShared, int numPixelDeadSensor, int numSCTDeadSensor, int numPixelHits,
                int numSCTHits, int numUnused, int numTRT_Unused, int numSCT_Unused, int numPseudo, float averageSplit1, float averageSplit2, int numWeightedShared) const;
 
        private:
            // name of the observed (saved) track collection
            SG::WriteHandleKey<TrackCollection> m_savedTracksWriteKey;
            SG::WriteHandleKey<ObservedTrackMap> m_savedTracksMapWriteKey;
 
            mutable std::mutex m_mutex;
            struct CacheEntry {
                EventContext::ContextEvt_t m_evt{EventContext::INVALID_CONTEXT_EVT};
                // map with observed tracks and information
                ObservedTrackMap*   m_observedTrkMap;
            };
            mutable SG::SlotSpecificObj<CacheEntry> m_cache ATLAS_THREAD_SAFE; // Guarded by m_mutex
 
            void newEvent(CacheEntry* ent) const;
            void dumpTrackMap(const ObservedTrackMap* trk_map) const;
            static std::string dumpRejection(xAOD::RejectionStep rejectStep, xAOD::RejectionReason rejectReason) ;
            static int getNFinalTracks(const ObservedTrackMap* trk_map) ;
            static int getNObservedTracks(const ObservedTrackMap* trk_map) ;
            static const std::map<xAOD::RejectionStep, std::string> m_rejectStep_descriptions;
            static const std::map<xAOD::RejectionReason, std::string> m_rejectReason_descriptions;
    }; 
}
 
#endif // TRK_TRKOBSERVERTOOL_H

m_savedTracksMapWriteKey

SG::WriteHandleKey<ObservedTrackMap> Trk::TrkObserverTool::m_savedTracksMapWriteKey

private

Definition at line 63 of file TrkObserverTool.h.

m_savedTracksWriteKey

SG::WriteHandleKey<TrackCollection> Trk::TrkObserverTool::m_savedTracksWriteKey

private

Definition at line 62 of file TrkObserverTool.h.

---

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

• TrkObserverTool.h
• TrkObserverTool.cxx