#include <DetailedMuonPatternTruthBuilder.h>

Inheritance diagram for Trk::DetailedMuonPatternTruthBuilder:

Collaboration diagram for Trk::DetailedMuonPatternTruthBuilder:

Public Member Functions
	DetailedMuonPatternTruthBuilder (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize ()
virtual void	buildDetailedMuonPatternTruth (DetailedMuonPatternTruthCollection output, const MuonPatternCombinationCollection &tracks, const std::vector< const PRD_MultiTruthCollection > &prdTruth)
	See description for IDetailedMuonPatternTruthBuilder::buildDetailedTrackTruth().
virtual void	buildDetailedTrackTruth (std::vector< DetailedTrackTruth > output, const Muon::MuonPatternCombination &pattern, const std::vector< const PRD_MultiTruthCollection > &prdTruth)
void	buildDetailedTrackTruthFromSegments (std::vector< DetailedSegmentTruth > output, const Muon::MuonSegment &segment, const std::vector< const PRD_MultiTruthCollection > &prdTruth)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef InverseMultiMap< PRD_MultiTruthCollection >	PRD_InverseTruth
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
SubDetHitStatistics::SubDetType	findSubDetType (Identifier id)
const MuonSimData::Deposit *	getDeposit (const MuonSimDataCollection &simCol, const HepMC::ConstGenParticlePtr &genPart, const Identifier &id)
const MuonSimDataCollection *	retrieveTruthCollection (const std::string &colName)
void	addTrack (DetailedMuonPatternTruthCollection output, const ElementLink< DataVector< Muon::MuonPatternCombination > > &track, const std::vector< const PRD_MultiTruthCollection > &orderedPRD_Truth, const PRD_InverseTruth &inverseTruth)
void	addDetailedTrackTruth (std::vector< DetailedTrackTruth > output, const Muon::MuonPatternCombination &pattern, const std::vector< const PRD_MultiTruthCollection > &orderedPRD_Truth, const PRD_InverseTruth &inverseTruth)
SubDetHitStatistics	countPRDsOnTruth (const TruthTrajectory &traj, const PRD_InverseTruth &inverseTruth, std::set< Muon::MuonStationIndex::ChIndex > chIndices)
Amg::Vector3D	getPRDTruthPosition (const Muon::MuonSegment &segment, std::list< HepMC::ConstGenParticlePtr > genPartList, int truthPos, std::set< Muon::MuonStationIndex::ChIndex > chIndices)
void	addDetailedTrackTruthFromSegment (std::vector< DetailedSegmentTruth > output, const Muon::MuonSegment &segment, const std::vector< const PRD_MultiTruthCollection > &orderedPRD_Truth, const PRD_InverseTruth &inverseTruth)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< Trk::ITruthTrajectoryBuilder >	m_truthTrackBuilder {this, "TruthTrajectoryTool", "Trk::ElasticTruthTrajectoryBuilder"}
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator >	m_mdtCreator
ToolHandle< Muon::IMuonClusterOnTrackCreator >	m_muonClusterCreator
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 45 of file DetailedMuonPatternTruthBuilder.h.

Member Typedef Documentation

◆ PRD_InverseTruth

typedef InverseMultiMap<PRD_MultiTruthCollection> Trk::DetailedMuonPatternTruthBuilder::PRD_InverseTruth

private

Definition at line 63 of file DetailedMuonPatternTruthBuilder.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ DetailedMuonPatternTruthBuilder()

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

Definition at line 112 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                               :
        AthAlgTool(type, name, parent) {
        declareInterface<IDetailedMuonPatternTruthBuilder>(this);
    }

Member Function Documentation

◆ addDetailedTrackTruth()

void Trk::DetailedMuonPatternTruthBuilder::addDetailedTrackTruth	(	std::vector< DetailedTrackTruth > *	output,
		const Muon::MuonPatternCombination &	pattern,
		const std::vector< const PRD_MultiTruthCollection * > &	orderedPRD_Truth,
		const PRD_InverseTruth &	inverseTruth )

private

Definition at line 724 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                      {
        SubDetHitStatistics trackStat;
        std::map<HepMcParticleLink, SubDetPRDs> pairStat;  // stats for (track,GenParticle) for the current track
 
        // Loop over MuonPatternChamberIntersect
        const std::vector<Muon::MuonPatternChamberIntersect>& MPCIV = pattern.chamberData();
        for (unsigned int i_MPCI = 0; i_MPCI < MPCIV.size(); i_MPCI++) {
            if (MPCIV.empty()) continue;
 
            // get the PrepRawData from the MuonPatternChamberIntersect
            std::vector<const Trk::PrepRawData*> PRDV = MPCIV.at(i_MPCI).prepRawDataVec();
 
            // Loop over the PRDV
            for (unsigned int j_PRD = 0; j_PRD < PRDV.size(); j_PRD++) {
                if (PRDV.empty()) continue;
 
                Identifier id = PRDV.at(j_PRD)->identify();
                SubDetHitStatistics::SubDetType subdet = findSubDetType(id);
 
                if (subdet != SubDetHitStatistics::NUM_SUBDETECTORS) {
                    // if PRD truth collection is missing, ignore subdet in track stat calculation as well.
                    if (orderedPRD_Truth[subdet]) {
                        ++trackStat[subdet];
 
                        typedef PRD_MultiTruthCollection::const_iterator iprdt;
                        std::pair<iprdt, iprdt> range = orderedPRD_Truth[subdet]->equal_range(id);
 
                        int n = 0;
                        // Loop over particles contributing to this cluster
                        for (iprdt i = range.first; i != range.second; ++i) {
                            if (!i->second.isValid()) {
                                ATH_MSG_WARNING("Unexpected invalid HepMcParticleLink in PRD_MultiTruthCollection");
                            } else {
                                pairStat[i->second].subDetHits[subdet].insert(id);
                                n += 1;
                                ATH_MSG_VERBOSE("PRD-ID:" << id << " subdet:" << subdet << " number:" << n
                                                          << " particle link:" << i->second);
                            }
                        }
                        if (n == 0) {
                            ATH_MSG_VERBOSE("--> no link, noise ? PRD-ID:" << id << " subdet:" << subdet);
                            // add uniqueID 0 to pairs, we like to keep track of fake fakes
                            unsigned int ID(0), EV(0);
                            pairStat[HepMcParticleLink(ID, EV, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_ID)].subDetHits[subdet].insert(id);
                        }
                    }  // orderedPRD_Truth[] available
                }      // subdet type check, warning in findSubDetType()
            }
        }
 
        if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::VERBOSE) << "PRD truth particles = ";
            for (std::map<HepMcParticleLink, SubDetPRDs>::const_iterator i = pairStat.begin(); i != pairStat.end(); ++i) {
                msg(MSG::VERBOSE) << i->first << ",";
            }
            msg(MSG::VERBOSE) << endmsg;
        }
 
        //----------------------------------------------------------------
        // The stat structures are ready.
        // Build truth trajectories for the track
 
        std::set<HepMcParticleLink> seeds;
        for (std::map<HepMcParticleLink, SubDetPRDs>::const_iterator i = pairStat.begin(); i != pairStat.end(); ++i) {
            if (i->first.isValid()) {
                seeds.insert(i->first);
            } else {
                // add uniqueID 0 particles, we like to keep track of fake fakes
                TruthTrajectory traj;
                traj.reserve(1);
                traj.push_back(i->first);
                ATH_MSG_VERBOSE("addTrack(): add barcode 0 hits - noise ?");
 
                // noise/no truth hits on this track
                SubDetHitStatistics noiseStat = makeSubDetHitStatistics(i->second);
 
                // Only valid HepMcParticleLink make it into seeds and then into sprouts, and
                // stored in the loop over sprouts below.
                // Store output for noise/no truth particles here.
                output->push_back(DetailedTrackTruth(traj, noiseStat, trackStat, noiseStat));
            }
        }
 
        // Grow sprouts from the seeds
        typedef std::map<HepMcParticleLink, Sprout> SproutMap;
        SproutMap sprouts;
 
        while (!seeds.empty()) {
            HepMcParticleLink link = *seeds.begin();
 
            Sprout current_sprout;
            std::queue<HepMC::ConstGenParticlePtr> tmp;
            unsigned eventIndex = link.eventIndex();
            HepMC::ConstGenParticlePtr current = link.scptr();
            do {
                HepMcParticleLink curlink(HepMC::uniqueID(current), eventIndex, HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_ID);
 
                // remove the current particle from the list of particles to consider (if it is still there)
                seeds.erase(curlink);
 
                // Have we worked on this particle before?
                SproutMap::iterator p_old = sprouts.find(curlink);
                if (p_old != sprouts.end()) {
                    // merge the old sprout with the current one.
                    current_sprout.splice(current_sprout.end(), p_old->second);
                    current_sprout.stat += p_old->second.stat;
                    // and remove the entry for the old
                    sprouts.erase(p_old);
                    break;  // the do-while(getMother()) loop
                } else {    // No, this is a new particle.  Try to extend the current truth trajectory.
 
                    // Add the particle to the current truth trajectory.
                    // New: with the current stricter cuts on mother-daughter
                    // we don't have to require that ancestors produce hits.
 
                    current_sprout.push_back(current);
 
                    std::map<HepMcParticleLink, SubDetPRDs>::iterator p_newstat = pairStat.find(curlink);
                    if (p_newstat != pairStat.end()) { current_sprout.stat += p_newstat->second; }
                }
            } while ((current = m_truthTrackBuilder->getMother(current)));
 
            // Add the grown sprout to the list
            sprouts.insert(std::make_pair(link, current_sprout));
 
        }  // while(!seeds.empty())
 
        //----------------
        // All seeds have been processed, and the upstream extensions of the
        // sprouts are done.  Extend the sprouts downstream to get the final
        // truth trajectories and store the result.
        //
        // Note: so far the "sprouts" object mapped {last particle ==> sprout}
        // Extending a sprout downstream will break this relationship,
        // but at this point we don't care about it and will only use the
        // value of the map, not the key.
        for (SproutMap::iterator s = sprouts.begin(); s != sprouts.end(); ++s) {
            // Attempt to extend the TruthTrajectory sprout to the "outside".
            // This may add only hits that are *not* on the current track.
            // Thus no need to update stats track and stats common.
 
            HepMC::ConstGenParticlePtr current = *s->second.begin();
            while ((current = m_truthTrackBuilder->getDaughter(current))) { s->second.push_front(current); }
 
            // Now we have info to build the final TruthTrajectory.
            // FIXME: what is the current average size?
            TruthTrajectory traj;
            traj.reserve(2);  // The average size is about 1.05.  Hardcode that instead of using slow list::size().
            for (Sprout::const_iterator ppart = s->second.begin(); ppart != s->second.end(); ++ppart) {
                traj.push_back(HepMcParticleLink(HepMC::uniqueID(*ppart), s->first.eventIndex(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_ID));
            }
 
            // Count PRDs on the TruthTrajectory
            std::set<Muon::MuonStationIndex::ChIndex> tempSet;
            SubDetHitStatistics truthStat = countPRDsOnTruth(traj, inverseTruth, tempSet);
 
            ATH_MSG_VERBOSE("addTrack(): sprout length = " << traj.size());
            output->push_back(DetailedTrackTruth(traj, makeSubDetHitStatistics(s->second.stat), trackStat, truthStat));
        }
 
        ATH_MSG_VERBOSE("addTrack(): #sprouts = " << sprouts.size() << ", output->size() = " << output->size());
    }

◆ addDetailedTrackTruthFromSegment()

void Trk::DetailedMuonPatternTruthBuilder::addDetailedTrackTruthFromSegment	(	std::vector< DetailedSegmentTruth > *	output,
		const Muon::MuonSegment &	segment,
		const std::vector< const PRD_MultiTruthCollection * > &	orderedPRD_Truth,
		const PRD_InverseTruth &	inverseTruth )

private

Definition at line 933 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                                  {
        SubDetHitStatistics trackStat;
        std::map<HepMcParticleLink, SubDetPRDs> pairStat;  // stats for (track,GenParticle) for the current track
 
        std::set<Muon::MuonStationIndex::ChIndex> chIndices;
 
        // Loop over containedROTs in segment
        for (unsigned int i_cROTv = 0; i_cROTv < segment.numberOfContainedROTs(); i_cROTv++) {
            const Trk::RIO_OnTrack* rot = segment.rioOnTrack(i_cROTv);
 
            // get the PrepRawData from the ROT
            const Trk::PrepRawData* prd = rot->prepRawData();
 
            Identifier id = prd->identify();
            chIndices.insert(m_idHelperSvc->chamberIndex(id));
 
            SubDetHitStatistics::SubDetType subdet = findSubDetType(id);
 
            if (subdet != SubDetHitStatistics::NUM_SUBDETECTORS) {
                // if PRD truth collection is missing, ignore subdet in track stat calculation as well.
                if (orderedPRD_Truth[subdet]) {
                    ++trackStat[subdet];
 
                    typedef PRD_MultiTruthCollection::const_iterator iprdt;
                    std::pair<iprdt, iprdt> range = orderedPRD_Truth[subdet]->equal_range(id);
 
                    int n = 0;
                    // Loop over particles contributing to this cluster
                    for (iprdt i = range.first; i != range.second; ++i) {
                        if (!i->second.isValid()) {
                            ATH_MSG_WARNING("Unexpected invalid HepMcParticleLink in PRD_MultiTruthCollection");
                        } else {
                            pairStat[i->second].subDetHits[subdet].insert(id);
                            n += 1;
                            ATH_MSG_VERBOSE("PRD-ID:" << id << " subdet:" << subdet << " number:" << n << " particle link:" << i->second);
                        }
                    }
                    if (n == 0) {
                        ATH_MSG_VERBOSE("--> no link, noise ? PRD-ID:" << id << " subdet:" << subdet);
                        // add uniqueID 0 to pairs, we like to keep track of fake fakes
                        unsigned int ID(0), EV(0);
                        pairStat[HepMcParticleLink(ID, EV, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_ID)].subDetHits[subdet].insert(id);
                    }
                }  // orderedPRD_Truth[] available
            }      // subdet type check, warning in findSubDetType()
        }
 
        if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::VERBOSE) << "PRD truth particles = ";
            for (std::map<HepMcParticleLink, SubDetPRDs>::const_iterator i = pairStat.begin(); i != pairStat.end(); ++i) {
                msg(MSG::VERBOSE) << i->first << ",";
            }
            msg(MSG::VERBOSE) << endmsg;
        }
 
        //----------------------------------------------------------------
        // The stat structures are ready.
        // Build truth trajectories for the track
 
        std::set<HepMcParticleLink> seeds;
        for (std::map<HepMcParticleLink, SubDetPRDs>::const_iterator i = pairStat.begin(); i != pairStat.end(); ++i) {
            if (i->first.isValid()) {
                seeds.insert(i->first);
            } else {
                // add uniqueID 0 particles, we like to keep track of fake fakes
                TruthTrajectory traj;
                traj.reserve(1);
                traj.push_back(i->first);
                ATH_MSG_VERBOSE("addTrack(): add barcode 0 hits - noise ?");
 
                // noise/no truth hits on this track
                SubDetHitStatistics noiseStat = makeSubDetHitStatistics(i->second);
 
                // Only valid HepMcParticleLink make it into seeds and then into sprouts, and
                // stored in the loop over sprouts below.
                // Store output for noise/no truth particles here.
                output->push_back(
                    DetailedSegmentTruth(traj, noiseStat, trackStat, noiseStat, Amg::Vector3D(0, 0, 0), Amg::Vector3D(0, 0, 0)));
            }
        }
 
        // Grow sprouts from the seeds
        typedef std::map<HepMcParticleLink, Sprout> SproutMap;
        SproutMap sprouts;
 
        while (!seeds.empty()) {
            HepMcParticleLink link = *seeds.begin();
 
            Sprout current_sprout;
            std::queue<HepMC::ConstGenParticlePtr> tmp;
            unsigned eventIndex = link.eventIndex();
            HepMC::ConstGenParticlePtr current = link.scptr();
 
            do {
                HepMcParticleLink curlink(HepMC::uniqueID(current), eventIndex, HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_ID);
 
                // remove the current particle from the list of particles to consider (if it is still there)
                seeds.erase(curlink);
 
                // Have we worked on this particle before?
                SproutMap::iterator p_old = sprouts.find(curlink);
                if (p_old != sprouts.end()) {
                    // merge the old sprout with the current one.
                    current_sprout.splice(current_sprout.end(), p_old->second);
                    current_sprout.stat += p_old->second.stat;
                    // and remove the entry for the old
                    sprouts.erase(p_old);
                    break;  // the do-while(getMother()) loop
                } else {    // No, this is a new particle.  Try to extend the current truth trajectory.
 
                    // Add the particle to the current truth trajectory.
                    // New: with the current stricter cuts on mother-daughter
                    // we don't have to require that ancestors produce hits.
 
                    current_sprout.push_back(current);
 
                    std::map<HepMcParticleLink, SubDetPRDs>::iterator p_newstat = pairStat.find(curlink);
                    if (p_newstat != pairStat.end()) { current_sprout.stat += p_newstat->second; }
                }
            } while ((current = m_truthTrackBuilder->getMother(current)));
 
            // Add the grown sprout to the list
            sprouts.insert(std::make_pair(link, current_sprout));
 
        }  // while(!seeds.empty())
 
        //----------------
        // All seeds have been processed, and the upstream extensions of the
        // sprouts are done.  Extend the sprouts downstream to get the final
        // truth trajectories and store the result.
        //
        // Note: so far the "sprouts" object mapped {last particle ==> sprout}
        // Extending a sprout downstream will break this relationship,
        // but at this point we don't care about it and will only use the
        // value of the map, not the key.
        for (SproutMap::iterator s = sprouts.begin(); s != sprouts.end(); ++s) {
            // Attempt to extend the TruthTrajectory sprout to the "outside".
            // This may add only hits that are *not* on the current track.
            // Thus no need to update stats track and stats common.
 
            HepMC::ConstGenParticlePtr current = *s->second.begin();
            while ((current = m_truthTrackBuilder->getDaughter(current))) { s->second.push_front(current); }
 
            // Now we have info to build the final TruthTrajectory.
            // FIXME: what is the current average size?
            TruthTrajectory traj;
            traj.reserve(2);  // The average size is about 1.05.  Hardcode that instead of using slow list::size().
            for (Sprout::const_iterator ppart = s->second.begin(); ppart != s->second.end(); ++ppart) {
                traj.push_back(HepMcParticleLink(HepMC::uniqueID(*ppart), s->first.eventIndex(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_ID));
            }
 
            // Count PRDs on the TruthTrajectory
            SubDetHitStatistics truthStat = countPRDsOnTruth(traj, inverseTruth, chIndices);
            Amg::Vector3D pos = getPRDTruthPosition(segment, s->second, 1, chIndices);
            Amg::Vector3D dir = getPRDTruthPosition(segment, s->second, 0, chIndices);
 
            ATH_MSG_VERBOSE("addTrack(): sprout length = " << traj.size());
            output->push_back(DetailedSegmentTruth(traj, makeSubDetHitStatistics(s->second.stat), trackStat, truthStat, pos, dir));
        }
 
        ATH_MSG_VERBOSE("addTrack(): #sprouts = " << sprouts.size() << ", output->size() = " << output->size());
    }

◆ addTrack()

void Trk::DetailedMuonPatternTruthBuilder::addTrack	(	DetailedMuonPatternTruthCollection *	output,
		const ElementLink< DataVector< Muon::MuonPatternCombination > > &	track,
		const std::vector< const PRD_MultiTruthCollection * > &	orderedPRD_Truth,
		const PRD_InverseTruth &	inverseTruth )

private

Definition at line 270 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                         {
        SubDetHitStatistics trackStat;
        std::map<HepMcParticleLink, SubDetPRDs> pairStat;  // stats for (track,GenParticle) for the current track
 
        // Loop over MuonPatternChamberIntersect
        const std::vector<Muon::MuonPatternChamberIntersect>& MPCIV = (*MuPatternCombo)->chamberData();
        for (unsigned int i_MPCI = 0; i_MPCI < MPCIV.size(); i_MPCI++) {
            if (MPCIV.empty()) continue;
 
            // get the PrepRawData from the MuonPatternChamberIntersect
            std::vector<const Trk::PrepRawData*> PRDV = MPCIV.at(i_MPCI).prepRawDataVec();
 
            // Loop over the PRDV
            for (unsigned int j_PRD = 0; j_PRD < PRDV.size(); j_PRD++) {
                if (PRDV.empty()) continue;
 
                Identifier id = PRDV.at(j_PRD)->identify();
                SubDetHitStatistics::SubDetType subdet = findSubDetType(id);
 
                if (subdet != SubDetHitStatistics::NUM_SUBDETECTORS) {
                    // if PRD truth collection is missing, ignore subdet in track stat calculation as well.
                    if (orderedPRD_Truth[subdet]) {
                        ++trackStat[subdet];
 
                        typedef PRD_MultiTruthCollection::const_iterator iprdt;
                        std::pair<iprdt, iprdt> range = orderedPRD_Truth[subdet]->equal_range(id);
 
                        int n = 0;
                        // Loop over particles contributing to this cluster
                        for (iprdt i = range.first; i != range.second; ++i) {
                            if (!i->second.isValid()) {
                                ATH_MSG_WARNING("Unexpected invalid HepMcParticleLink in PRD_MultiTruthCollection");
                            } else {
                                pairStat[i->second].subDetHits[subdet].insert(id);
                                n += 1;
                                ATH_MSG_VERBOSE("PRD-ID:" << id << " subdet:" << subdet << " number:" << n
                                                          << " particle link:" << i->second);
                            }
                        }
                        if (n == 0) {
                            ATH_MSG_VERBOSE("--> no link, noise ? PRD-ID:" << id << " subdet:" << subdet);
                            // add unique ID 0 to pairs, we like to keep track of fake fakes
                            unsigned int ID(0), EV(0);
                            pairStat[HepMcParticleLink(ID, EV, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_ID)].subDetHits[subdet].insert(id);
                        }
                    }  // orderedPRD_Truth[] available
                }      // subdet type check, warning in findSubDetType()
            }
        }
 
        if (msgLvl(MSG::VERBOSE)) {
            msg(MSG::VERBOSE) << "PRD truth particles = ";
            for (std::map<HepMcParticleLink, SubDetPRDs>::const_iterator i = pairStat.begin(); i != pairStat.end(); ++i) {
                msg(MSG::VERBOSE) << i->first << ",";
            }
            msg(MSG::VERBOSE) << endmsg;
        }
 
        //----------------------------------------------------------------
        // The stat structures are ready.
        // Build truth trajectories for the track
        std::set<HepMcParticleLink> seeds;
        for (std::map<HepMcParticleLink, SubDetPRDs>::const_iterator i = pairStat.begin(); i != pairStat.end(); ++i) {
            if (i->first.isValid()) {
                seeds.insert(i->first);
            } else {
                // add uniqueID 0 particles, we like to keep track of fake fakes
                TruthTrajectory traj;
                traj.reserve(1);
                traj.push_back(i->first);
                ATH_MSG_VERBOSE("addTrack(): add barcode 0 hits - noise ?");
 
                // noise/no truth hits on this track
                SubDetHitStatistics noiseStat = makeSubDetHitStatistics(i->second);
 
                // Only valid HepMcParticleLink make it into seeds and then into sprouts, and
                // stored in the loop over sprouts below.
                // Store output for noise/no truth particles here.
                output->insert(std::make_pair(MuPatternCombo, DetailedTrackTruth(traj, noiseStat, trackStat, noiseStat)));
            }
        }
 
        // Grow sprouts from the seeds
        typedef std::map<HepMcParticleLink, Sprout> SproutMap;
        SproutMap sprouts;
 
        while (!seeds.empty()) {
            HepMcParticleLink link = *seeds.begin();
 
            Sprout current_sprout;
            std::queue<HepMC::ConstGenParticlePtr> tmp;
            unsigned eventIndex = link.eventIndex();
            HepMC::ConstGenParticlePtr current = link.scptr();
            do {
                HepMcParticleLink curlink(HepMC::uniqueID(current), eventIndex, HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_ID);
 
                // remove the current particle from the list of particles to consider (if it is still there)
                seeds.erase(curlink);
 
                // Have we worked on this particle before?
                SproutMap::iterator p_old = sprouts.find(curlink);
                if (p_old != sprouts.end()) {
                    // merge the old sprout with the current one.
                    current_sprout.splice(current_sprout.end(), p_old->second);
                    current_sprout.stat += p_old->second.stat;
                    // and remove the entry for the old
                    sprouts.erase(p_old);
                    break;  // the do-while(getMother()) loop
                } else {    // No, this is a new particle.  Try to extend the current truth trajectory.
 
                    // Add the particle to the current truth trajectory.
                    // New: with the current stricter cuts on mother-daughter
                    // we don't have to require that ancestors produce hits.
 
                    current_sprout.push_back(current);
 
                    std::map<HepMcParticleLink, SubDetPRDs>::iterator p_newstat = pairStat.find(curlink);
                    if (p_newstat != pairStat.end()) { current_sprout.stat += p_newstat->second; }
                }
            } while ((current = m_truthTrackBuilder->getMother(current)));
 
            // Add the grown sprout to the list
            sprouts.insert(std::make_pair(link, current_sprout));
 
        }  // while(!seeds.empty())
 
        //----------------
        // All seeds have been processed, and the upstream extensions of the
        // sprouts are done.  Extend the sprouts downstream to get the final
        // truth trajectories and store the result.
        //
        // Note: so far the "sprouts" object mapped {last particle ==> sprout}
        // Extending a sprout downstream will break this relationship,
        // but at this point we don't care about it and will only use the
        // value of the map, not the key.
 
        for (SproutMap::iterator s = sprouts.begin(); s != sprouts.end(); ++s) {
            // Attempt to extend the TruthTrajectory sprout to the "outside".
            // This may add only hits that are *not* on the current track.
            // Thus no need to update stats track and stats common.
 
            HepMC::ConstGenParticlePtr current = *s->second.begin();
            while ((current = m_truthTrackBuilder->getDaughter(current))) { s->second.push_front(current); }
 
            // Now we have info to build the final TruthTrajectory.
            // FIXME: what is the current average size?
            TruthTrajectory traj;
            traj.reserve(2);  // The average size is about 1.05.  Hardcode that instead of using slow list::size().
            for (Sprout::const_iterator ppart = s->second.begin(); ppart != s->second.end(); ++ppart) {
                traj.push_back(HepMcParticleLink(HepMC::uniqueID(*ppart), s->first.eventIndex(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_ID));
            }
 
            // Count PRDs on the TruthTrajectory
            std::set<Muon::MuonStationIndex::ChIndex> tempSet;
            SubDetHitStatistics truthStat = countPRDsOnTruth(traj, inverseTruth, tempSet);
 
            ATH_MSG_VERBOSE("addTrack(): sprout length = " << traj.size());
            output->insert(
                std::make_pair(MuPatternCombo, DetailedTrackTruth(traj, makeSubDetHitStatistics(s->second.stat), trackStat, truthStat)));
        }
 
        ATH_MSG_VERBOSE("addTrack(): #sprouts = " << sprouts.size() << ", output->size() = " << output->size());
    }

◆ buildDetailedMuonPatternTruth()

void Trk::DetailedMuonPatternTruthBuilder::buildDetailedMuonPatternTruth	(	DetailedMuonPatternTruthCollection *	output,
		const MuonPatternCombinationCollection &	tracks,
		const std::vector< const PRD_MultiTruthCollection * > &	prdTruth )

virtual

See description for IDetailedMuonPatternTruthBuilder::buildDetailedTrackTruth().

Implements Trk::IDetailedMuonPatternTruthBuilder.

Definition at line 128 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                                                    {
        ATH_MSG_VERBOSE("DetailedMuonPatternTruthBuilder::buildDetailedMuonPatternTruth() ");
 
        if (!output) { return; }
 
        //----------------------------------------------------------------
        // The caller can pass PRD truth collections in any order. Sort them out.
 
        std::vector<const PRD_MultiTruthCollection*> orderedPRD_Truth(SubDetHitStatistics::NUM_SUBDETECTORS);
        PRD_InverseTruth inverseTruth;
 
        for (std::vector<const PRD_MultiTruthCollection*>::const_iterator i = prdTruth.begin(); i != prdTruth.end(); ++i) {
            if (*i) {
                if (!(*i)->empty()) {
                    SubDetHitStatistics::SubDetType subdet = findSubDetType((*i)->begin()->first);
 
                    if (subdet != SubDetHitStatistics::NUM_SUBDETECTORS) {
                        orderedPRD_Truth[subdet] = *i;
                        addToInverseMultiMap(&inverseTruth, **i);
                    } else {
                        ATH_MSG_WARNING("Got unknown SubDetType in prdTruth ");
                    }
                } else {
                    ATH_MSG_DEBUG("Empty truth ???");
                }
            }
        }
 
        //----------------------------------------------------------------
        // Find associated truth for each track
 
        for (unsigned itrack = 0; itrack < patterns.size(); itrack++) {
            ElementLink<DataVector<Muon::MuonPatternCombination> > ptrack(patterns, itrack);
            addTrack(output, ptrack, orderedPRD_Truth, inverseTruth);
        }
 
        // DEBUG
        // FIXME: in normal production jobs that does *a lot of* formatting only to discard the result...
        ATH_MSG_DEBUG(
            "Dumping output collection.\n"
            " Entries with TruthTrajectories of more then one particle shown at the DEBUG level.\n"
            " Use VERBOSE level for complete dump.");
 
        for (DetailedMuonPatternTruthCollection::const_iterator i = output->begin(); i != output->end(); ++i) {
            bool interesting = (i->second.trajectory().size() > 1);
 
            // TODO:  Reinsert the following code once I understand the compile-time error
            //    msg(interesting  ? MSG::DEBUG : MSG::VERBOSE)
            //      <<"out: trk="<<i->first.index()<<" => "<<i->second<<endmsg;
 
            if (interesting) {
                const TruthTrajectory& t = i->second.trajectory();
                msg(MSG::VERBOSE) << "Particles on the trajectory:\n";
                for (unsigned k = 0; k < t.size(); ++k) { msg(MSG::VERBOSE) << t[k] << "\n"; }
                msg(MSG::VERBOSE) << "\n" << endmsg;
            }
        }
    }

◆ buildDetailedTrackTruth()

void Trk::DetailedMuonPatternTruthBuilder::buildDetailedTrackTruth	(	std::vector< DetailedTrackTruth > *	output,
		const Muon::MuonPatternCombination &	pattern,
		const std::vector< const PRD_MultiTruthCollection * > &	prdTruth )

virtual

Implements Trk::IDetailedMuonPatternTruthBuilder.

Definition at line 191 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                                              {
        ATH_MSG_VERBOSE("DetailedMuonPatternTruthBuilder::buildDetailedTrackTruth() ");
 
        if (!output) { return; }
 
        //----------------------------------------------------------------
        // The caller can pass PRD truth collections in any order. Sort them out.
 
        std::vector<const PRD_MultiTruthCollection*> orderedPRD_Truth(SubDetHitStatistics::NUM_SUBDETECTORS);
        PRD_InverseTruth inverseTruth;
 
        for (std::vector<const PRD_MultiTruthCollection*>::const_iterator i = prdTruth.begin(); i != prdTruth.end(); ++i) {
            if (*i) {
                if (!(*i)->empty()) {
                    SubDetHitStatistics::SubDetType subdet = findSubDetType((*i)->begin()->first);
 
                    if (subdet != SubDetHitStatistics::NUM_SUBDETECTORS) {
                        orderedPRD_Truth[subdet] = *i;
                        addToInverseMultiMap(&inverseTruth, **i);
                    } else {
                        ATH_MSG_WARNING("Got unknown SubDetType in prdTruth ");
                    }
                } else {
                    ATH_MSG_DEBUG("Empty truth ???");
                }
            }
        }
 
        //----------------------------------------------------------------
        // Find associated truth for each track
        addDetailedTrackTruth(output, pattern, orderedPRD_Truth, inverseTruth);
 
        // DEBUG
        // FIXME: in normal production jobs that does *a lot of* formatting only to discard the result...
        ATH_MSG_DEBUG(
            "Dumping output collection.\n"
            " Entries with TruthTrajectories of more then one particle shown at the DEBUG level.\n"
            " Use VERBOSE level for complete dump.");
 
     
    }

◆ buildDetailedTrackTruthFromSegments()

void Trk::DetailedMuonPatternTruthBuilder::buildDetailedTrackTruthFromSegments	(	std::vector< DetailedSegmentTruth > *	output,
		const Muon::MuonSegment &	segment,
		const std::vector< const PRD_MultiTruthCollection * > &	prdTruth )

virtual

Implements Trk::IDetailedMuonPatternTruthBuilder.

Definition at line 890 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                    {
        ATH_MSG_VERBOSE("DetailedMuonPatternTruthBuilder::buildDetailedTrackTruthFromSegments() ");
 
        if (!output) { return; }
 
        //----------------------------------------------------------------
        // The caller can pass PRD truth collections in any order. Sort them out.
 
        std::vector<const PRD_MultiTruthCollection*> orderedPRD_Truth(SubDetHitStatistics::NUM_SUBDETECTORS);
        PRD_InverseTruth inverseTruth;
 
        for (std::vector<const PRD_MultiTruthCollection*>::const_iterator i = prdTruth.begin(); i != prdTruth.end(); ++i) {
            if (*i) {
                if (!(*i)->empty()) {
                    SubDetHitStatistics::SubDetType subdet = findSubDetType((*i)->begin()->first);
 
                    if (subdet != SubDetHitStatistics::NUM_SUBDETECTORS) {
                        orderedPRD_Truth[subdet] = *i;
                        addToInverseMultiMap(&inverseTruth, **i);
                    } else {
                        ATH_MSG_WARNING("Got unknown SubDetType in prdTruth ");
                    }
                } else {
                    ATH_MSG_DEBUG("Empty truth ???");
                }
            }
        }
 
        //----------------------------------------------------------------
        // Find associated truth for each track
        addDetailedTrackTruthFromSegment(output, segment, orderedPRD_Truth, inverseTruth);
 
        // DEBUG
        // FIXME: in normal production jobs that does *a lot of* formatting only to discard the result...
        ATH_MSG_DEBUG(
            "Dumping output collection.\n"
            " Entries with TruthTrajectories of more then one particle shown at the DEBUG level.\n"
            " Use VERBOSE level for complete dump.");
    }

◆ countPRDsOnTruth()

SubDetHitStatistics Trk::DetailedMuonPatternTruthBuilder::countPRDsOnTruth	(	const TruthTrajectory &	traj,
		const PRD_InverseTruth &	inverseTruth,
		std::set< Muon::MuonStationIndex::ChIndex >	chIndices )

private

Definition at line 438 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                                         {
        // Different particles from the same TruthTrajectory can contribute to the same cluster.
        // We should be careful to avoid double-counting in such cases.
 
        SubDetPRDs prds;
        for (TruthTrajectory::const_iterator p = traj.begin(); p != traj.end(); ++p) {
            typedef PRD_InverseTruth::const_iterator iter;
            std::pair<iter, iter> range = inverseTruth.equal_range(*p);
            for (iter i = range.first; i != range.second; ++i) {
                if (chIndices.find(m_idHelperSvc->chamberIndex(i->second)) != chIndices.end()) {
                    SubDetHitStatistics::SubDetType subdet = findSubDetType(i->second);
                    if (subdet == SubDetHitStatistics::NUM_SUBDETECTORS) continue;
                    prds.subDetHits[subdet].insert(i->second);
                }
            }
        }
 
        return makeSubDetHitStatistics(prds);
    }

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	hndl,
		const SG::VarHandleKeyType &	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ findSubDetType()

SubDetHitStatistics::SubDetType Trk::DetailedMuonPatternTruthBuilder::findSubDetType ( Identifier id )

private

Definition at line 241 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                               {
        if (!m_idHelperSvc->isMuon(id)) {
            if (m_idHelperSvc->mdtIdHelper().is_pixel(id))
                return SubDetHitStatistics::Pixel;
            else if (m_idHelperSvc->mdtIdHelper().is_sct(id))
                return SubDetHitStatistics::SCT;
            else if (m_idHelperSvc->mdtIdHelper().is_trt(id))
                return SubDetHitStatistics::TRT;
        } else {
            if (m_idHelperSvc->isMdt(id))
                return SubDetHitStatistics::MDT;
            else if (m_idHelperSvc->isRpc(id))
                return SubDetHitStatistics::RPC;
            else if (m_idHelperSvc->isTgc(id))
                return SubDetHitStatistics::TGC;
            else if (m_idHelperSvc->isCsc(id))
                return SubDetHitStatistics::CSC;
            else if (m_idHelperSvc->isMM(id))
                return SubDetHitStatistics::MM;
            else if (m_idHelperSvc->issTgc(id))
                return SubDetHitStatistics::STGC;
        }
 
        ATH_MSG_WARNING("findSubDetType(): UNKNOWN subdet for id=" << id);
 
        return SubDetHitStatistics::NUM_SUBDETECTORS;
    }

◆ getDeposit()

const MuonSimData::Deposit * Trk::DetailedMuonPatternTruthBuilder::getDeposit	(	const MuonSimDataCollection &	simCol,
		const HepMC::ConstGenParticlePtr &	genPart,
		const Identifier &	id )

private

Definition at line 1099 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                                                           {
        MuonSimDataCollection::const_iterator it = simCol.find(id);
        if (it == simCol.end()) {
            ATH_MSG_WARNING(" Truth PRD not found in simdata collection: " << m_idHelperSvc->toString(id));
            return nullptr;
        }
 
        const MuonSimData& simData = it->second;
        const MuonSimData::Deposit* deposit = nullptr;
        std::vector<MuonSimData::Deposit>::const_iterator dit = simData.getdeposits().begin();
        std::vector<MuonSimData::Deposit>::const_iterator dit_end = simData.getdeposits().end();
        for (; dit != dit_end; ++dit) {
            HepMC::ConstGenParticlePtr gp = dit->first.scptr();
            if (gp == genPart) {
                deposit = &*dit;
                break;
            }
 
        }
        return deposit;
    }

◆ getPRDTruthPosition()

Amg::Vector3D Trk::DetailedMuonPatternTruthBuilder::getPRDTruthPosition	(	const Muon::MuonSegment &	segment,
		std::list< HepMC::ConstGenParticlePtr >	genPartList,
		int	truthPos,
		std::set< Muon::MuonStationIndex::ChIndex >	chIndices )

private

Definition at line 460 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                                      {
        double minPos = 2e8, maxPos = 0;
        Amg::Vector3D first3D(0, 0, 0), last3D(0, 0, 0);
 
        if (genPartList.empty()) {
            ATH_MSG_WARNING("No GenParticles associated to this PRD_TruthTrajectory. Exiting segment creation.");
            return Amg::Vector3D(0, 0, 0);
        }
 
        const MuonSimDataCollection* mdtSimDataMap = retrieveTruthCollection("MDT_SDO");
        if (!mdtSimDataMap) {
            ATH_MSG_WARNING(" failed to retrieve MuonSimDataCollection: "
                            << "MDT_SDO");
            return Amg::Vector3D(0, 0, 0);
        }
        const MuonSimDataCollection* mmSimDataMap = retrieveTruthCollection("MM_SDO");
        if (!mmSimDataMap) {
            ATH_MSG_WARNING(" failed to retrieve MuonSimDataCollection: "
                            << "MM_SDO");
            return Amg::Vector3D(0, 0, 0);
        }
        const MuonSimDataCollection* stgcSimDataMap = retrieveTruthCollection("sTGC_SDO");
        if (!stgcSimDataMap) {
            ATH_MSG_WARNING(" failed to retrieve MuonSimDataCollection: "
                            << "sTGC_SDO");
            return Amg::Vector3D(0, 0, 0);
        }
 
        // First sort the hits per detector layer
        std::map<Muon::MuonStationIndex::StIndex, DetectorLayer> hitsPerLayer;
        std::map<const Trk::TrkDetElementBase*, std::pair<std::list<const Trk::PrepRawData*>, std::list<const Trk::PrepRawData*> > >
            clustersPerDetEl;
 
        // Loop over containedROTs in segment
        for (unsigned int i_cROTv = 0; i_cROTv < segment.numberOfContainedROTs(); i_cROTv++) {
            const Trk::RIO_OnTrack* rot = segment.rioOnTrack(i_cROTv);
 
            // get the PrepRawData from the ROT
            const Trk::PrepRawData* prd = rot->prepRawData();
 
            Identifier id = prd->identify();
 
            Muon::MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
            bool isEndcap = m_idHelperSvc->isEndcap(id);
 
            if (chIndices.find(m_idHelperSvc->chamberIndex(id)) == chIndices.end()) {
                ATH_MSG_DEBUG("Muon station doesn't match segment.  Continuing");
                continue;
            }
 
            // some patches until MuonIdHelper is updated
            const Muon::MMPrepData* mm = dynamic_cast<const Muon::MMPrepData*>(prd);
            if (mm) {
                isEndcap = true;
                stIndex = Muon::MuonStationIndex::StIndex::EI;
            }
            const Muon::sTgcPrepData* stgc = dynamic_cast<const Muon::sTgcPrepData*>(prd);
            if (stgc) {
                isEndcap = true;
                stIndex = Muon::MuonStationIndex::StIndex::EI;
            }
            // BEGIN NEW WORK
 
            DetectorLayer& detLayer = hitsPerLayer[stIndex];
            detLayer.isEndcap = isEndcap;
            detLayer.stIndex = stIndex;
 
            // const Trk::MeasurementBase* meas = 0;
            if (m_idHelperSvc->isMdt(id)) {
                const Muon::MdtPrepData* mprd = dynamic_cast<const Muon::MdtPrepData*>(prd);
                if (!mprd) {
                    ATH_MSG_WARNING(" MDT PRD not of type MdtPrepData " << m_idHelperSvc->toString(id));
                    continue;
                }
 
                const MuonSimData::Deposit* deposit = nullptr;
                for (auto it = genPartList.begin(); it != genPartList.end() && !deposit; ++it) {
                    deposit = getDeposit(*mdtSimDataMap, *it, id);
                }
                if (!deposit) {
                    ATH_MSG_WARNING(" Deposit for GenParticle not found " << m_idHelperSvc->toString(id));
                    continue;
                }
 
                Amg::Vector2D lp(deposit->second.firstEntry(), deposit->second.secondEntry());
                const Amg::Vector3D gpos = prd->detectorElement()->surface(id).localToGlobal(lp);
 
                double val = isEndcap ? fabs(gpos.z()) : gpos.perp();
 
                // nasty comparisons to figure out which MDT hit comes first
                if (val < detLayer.minPos) {
                    if (detLayer.maxPos < -1e8 && detLayer.minPos < 1e8) {
                        detLayer.last3D = detLayer.first3D;
                        detLayer.maxPos = detLayer.minPos;
                    }
                    detLayer.first3D = gpos;
                    detLayer.minPos = val;
                } else if (val > detLayer.maxPos) {
                    detLayer.last3D = gpos;
                    detLayer.maxPos = val;
                }
 
                if (val < minPos) {
                    if (maxPos < -1e8 && minPos < 1e8) {
                        last3D = first3D;
                        maxPos = minPos;
                    }
                    minPos = val;
                    first3D = gpos;
                } else if (val > maxPos) {
                    maxPos = val;
                    last3D = gpos;
                }
 
                const Muon::MdtDriftCircleOnTrack* mdt = m_mdtCreator->createRIO_OnTrack(*mprd, gpos);
                if (!mdt) {
                    ATH_MSG_WARNING(" ROT creation failed " << m_idHelperSvc->toString(id));
                    continue;
                }
                Trk::DriftCircleSide side = deposit->second.firstEntry() < 0 ? Trk::LEFT : Trk::RIGHT;
                m_mdtCreator->updateSign(*const_cast<Muon::MdtDriftCircleOnTrack*>(mdt), side);
                double pull = (mdt->driftRadius() - deposit->second.firstEntry()) / mdt->localCovariance()(Trk::locR);
                ATH_MSG_VERBOSE(" new MDT    " << m_idHelperSvc->toString(id) << " radius " << mdt->driftRadius() << " true radius "
                                               << deposit->second.firstEntry() << " pull " << pull);
                if (fabs(pull) > 3.) ATH_MSG_VERBOSE(" hit with large pull ");
                detLayer.meas.push_back(mdt);
                if (m_idHelperSvc->isSmallChamber(id))
                    ++detLayer.nmdtS;
                else
                    ++detLayer.nmdtL;
                // meas = mdt;
            } else if (mm) {
                const MuonSimData::Deposit* deposit = nullptr;
                for (auto it = genPartList.begin(); it != genPartList.end() && !deposit; ++it) {
                    deposit = getDeposit(*mmSimDataMap, *it, id);
                }
                if (!deposit) {
                    ATH_MSG_WARNING(" Deposit for GenParticle not found " << m_idHelperSvc->toString(id));
                    continue;
                }
 
                Amg::Vector2D lp(deposit->second.firstEntry(), deposit->second.secondEntry());
                const Amg::Vector3D gpos = prd->detectorElement()->surface(id).localToGlobal(lp);
 
                // double val = isEndcap ? fabs(gpos->z()) : gpos->perp();
                // micormegas are always endcap
                double val = fabs(gpos.z());
                // nasty comparisons to figure out which MDT hit comes first
                if (val < detLayer.minPos) {
                    if (detLayer.maxPos < -1e8 && detLayer.minPos < 1e8) {
                        detLayer.last3D = detLayer.first3D;
                        detLayer.maxPos = detLayer.minPos;
                    }
                    detLayer.first3D = gpos;
                    detLayer.minPos = val;
                } else if (val > detLayer.maxPos) {
                    detLayer.last3D = gpos;
                    detLayer.maxPos = val;
                }
 
                if (val < minPos) {
                    if (maxPos < -1e8 && detLayer.minPos < 1e8) {
                        last3D = first3D;
                        maxPos = minPos;
                    }
                    minPos = val;
                    first3D = gpos;
                } else if (val > maxPos) {
                    maxPos = val;
                    last3D = gpos;
                }
 
                const Muon::MuonClusterOnTrack* rot = m_muonClusterCreator->createRIO_OnTrack(*mm, gpos);
                if (!rot) {
                    ATH_MSG_WARNING(" ROT creation failed " << m_idHelperSvc->toString(id));
                    continue;
                }
                double residual = rot->localParameters().get(Trk::locX) - lp.x();
                double pull = residual / rot->localCovariance()(Trk::locX);
                ATH_MSG_DEBUG("Adding r " << gpos.perp() << " z " << gpos.z() << "  " << m_idHelperSvc->toString(id) << " " << residual
                                          << " pull " << pull);
                detLayer.meas.push_back(rot);
                // meas = rot;
                ++detLayer.nnsw;
 
            } else if (stgc) {
                // skip pads in outer most two chambers as here the wires are more precise
                if (m_idHelperSvc->stgcIdHelper().channelType(id) == 0 && abs(m_idHelperSvc->stationEta(id)) > 2) continue;
 
                // there is already a check for this at the beginning of the method
                // if( !stgcSimDataMap ) continue;
 
                const MuonSimData::Deposit* deposit = nullptr;
                for (auto it = genPartList.begin(); it != genPartList.end() && !deposit; ++it) {
                    deposit = getDeposit(*stgcSimDataMap, *it, id);
                }
                if (!deposit) {
                    ATH_MSG_WARNING(" Deposit for GenParticle not found " << m_idHelperSvc->toString(id));
                    continue;
                }
 
                Amg::Vector2D lp(deposit->second.firstEntry(), deposit->second.secondEntry());
                const Amg::Vector3D gpos = prd->detectorElement()->surface(id).localToGlobal(lp);
 
                // double val = isEndcap ? fabs(gpos->z()) : gpos->perp();
                // stgcs are always endcap
                double val = fabs(gpos.z());
                // // nasty comparisons to figure out which STGC hit comes first
                if (val < detLayer.minPos) {
                    if (detLayer.maxPos < -1e8 && detLayer.minPos < 1e8) {
                        detLayer.last3D = detLayer.first3D;
                        detLayer.maxPos = detLayer.minPos;
                    }
                    detLayer.first3D = gpos;
                    detLayer.minPos = val;
                } else if (val > detLayer.maxPos) {
                    detLayer.last3D = gpos;
                    detLayer.maxPos = val;
                }
 
                if (val < minPos) {
                    if (maxPos < -1e8 && minPos < 1e8) {
                        last3D = first3D;
                        maxPos = minPos;
                    }
                    minPos = val;
                    first3D = gpos;
                } else if (val > maxPos) {
                    maxPos = val;
                    last3D = gpos;
                }
 
                const Muon::MuonClusterOnTrack* rot = m_muonClusterCreator->createRIO_OnTrack(*stgc, gpos);
                if (!rot) {
                    ATH_MSG_WARNING(" ROT creation failed " << m_idHelperSvc->toString(id));
                    continue;
                }
                double residual = rot->localParameters().get(Trk::locX) - lp.x();
                double pull = residual / rot->localCovariance()(Trk::locX);
                ATH_MSG_DEBUG("Adding r " << gpos.perp() << " z " << gpos.z() << "  " << m_idHelperSvc->toString(id) << " " << residual
                                          << " pull " << pull);
                detLayer.meas.push_back(rot);
                // meas = rot;
                ++detLayer.nnsw;
            }
        }
 
        // END NEW WORK
        if (minPos == 2e8 || maxPos == 0) {
            ATH_MSG_WARNING("Min and max positions not found.  Filling with meaningless position");
            return Amg::Vector3D(-15000, -15000, -15000);
        }
 
        if (truthPos)
            return (first3D + last3D) / 2;
        else {
            // else truth direction
            return (last3D - first3D);
        }
    }

◆ initialize()

StatusCode Trk::DetailedMuonPatternTruthBuilder::initialize ( )

virtual

Definition at line 119 of file DetailedMuonPatternTruthBuilder.cxx.

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

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

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

inlinestaticinherited

Definition at line 33 of file IDetailedMuonPatternTruthBuilder.h.

33{ return IID_IDetailedMuonPatternTruthBuilder; }

Trk::IID_IDetailedMuonPatternTruthBuilder

static const InterfaceID IID_IDetailedMuonPatternTruthBuilder("Trk::IDetailedMuonPatternTruthBuilder", 1, 0)

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ retrieveTruthCollection()

const MuonSimDataCollection * Trk::DetailedMuonPatternTruthBuilder::retrieveTruthCollection ( const std::string & colName )

private

Definition at line 1122 of file DetailedMuonPatternTruthBuilder.cxx.

                                                                                                                  {
        // Retrieve SDO map for this event
        if (!evtStore()->contains<MuonSimDataCollection>(colName)) return nullptr;
 
        const MuonSimDataCollection* truthCol(nullptr);
        if (!evtStore()->retrieve(truthCol, colName).isSuccess()) {
            ATH_MSG_VERBOSE("Could NOT find the MuonSimDataMap map key = " << colName);
        } else {
            ATH_MSG_VERBOSE("Retrieved MuonSimDataCollection for key = " << colName);
        }
        return truthCol;
    }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_idHelperSvc

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

private

Definition at line 65 of file DetailedMuonPatternTruthBuilder.h.

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

◆ m_mdtCreator

ToolHandle<Muon::IMdtDriftCircleOnTrackCreator> Trk::DetailedMuonPatternTruthBuilder::m_mdtCreator

private

Initial value:

{this, "MdtDriftCircleCreator",

"Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"}

Definition at line 68 of file DetailedMuonPatternTruthBuilder.h.

68 {this, "MdtDriftCircleCreator",

69 "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator"};

◆ m_muonClusterCreator

ToolHandle<Muon::IMuonClusterOnTrackCreator> Trk::DetailedMuonPatternTruthBuilder::m_muonClusterCreator

private

Initial value:

{this, "MuonClusterCreator",

"Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator"}

Definition at line 70 of file DetailedMuonPatternTruthBuilder.h.

70 {this, "MuonClusterCreator",

71 "Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator"};

◆ m_truthTrackBuilder

ToolHandle<Trk::ITruthTrajectoryBuilder> Trk::DetailedMuonPatternTruthBuilder::m_truthTrackBuilder {this, "TruthTrajectoryTool", "Trk::ElasticTruthTrajectoryBuilder"}

private

Definition at line 67 of file DetailedMuonPatternTruthBuilder.h.

67{this, "TruthTrajectoryTool", "Trk::ElasticTruthTrajectoryBuilder"};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ PRD_InverseTruth

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ DetailedMuonPatternTruthBuilder()

Member Function Documentation

◆ addDetailedTrackTruth()

◆ addDetailedTrackTruthFromSegment()

◆ addTrack()

◆ buildDetailedMuonPatternTruth()

◆ buildDetailedTrackTruth()

◆ buildDetailedTrackTruthFromSegments()

◆ countPRDsOnTruth()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ findSubDetType()

◆ getDeposit()

◆ getPRDTruthPosition()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ retrieveTruthCollection()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_evtStore

◆ m_idHelperSvc

◆ m_mdtCreator

◆ m_muonClusterCreator

◆ m_truthTrackBuilder

◆ m_varHandleArraysDeclared

◆ m_vhka