Trk::DetailedMuonPatternTruthBuilder Class Reference

#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() More...
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. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) 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 More...
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. More...

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 > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

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) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
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 729 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 barcode 0 to pairs, we like to keep track of fake fakes
                            unsigned int BC(0), EV(0);
                            pairStat[HepMcParticleLink(BC, EV, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_BARCODE)].subDetHits[subdet].insert(id); // FIXME barcode-based
                        }
                    }  // 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 barcode 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();
#ifdef HEPMC3
            HepMC::ConstGenParticlePtr current = link.scptr();
#else
            const HepMC::GenParticle* current = link.cptr();
#endif
 
            do {
                HepMcParticleLink curlink(HepMC::barcode(current), eventIndex, HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_BARCODE); // FIXME barcode-based
 
                // 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::barcode(*ppart), s->first.eventIndex(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_BARCODE)); // FIXME barcode-based
            }
 
            // 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 943 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 barcode 0 to pairs, we like to keep track of fake fakes
                        unsigned int BC(0), EV(0);
                        pairStat[HepMcParticleLink(BC, EV, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_BARCODE)].subDetHits[subdet].insert(id); // FIXME barcode-based
                    }
                }  // 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 barcode 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();
#ifdef HEPMC3
            HepMC::ConstGenParticlePtr current = link.scptr();
#else
            const HepMC::GenParticle* current = link.cptr();
#endif
 
            do {
                HepMcParticleLink curlink(HepMC::barcode(current), eventIndex, HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_BARCODE); // FIXME barcode-based
 
                // 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::barcode(*ppart), s->first.eventIndex(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_BARCODE)); // FIXME barcode-based
            }
 
            // 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 barcode 0 to pairs, we like to keep track of fake fakes
                            unsigned int BC(0), EV(0);
                            pairStat[HepMcParticleLink(BC, EV, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_BARCODE)].subDetHits[subdet].insert(id); // FIXME barcode-based
                        }
                    }  // 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 barcode 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();
#ifdef HEPMC3
            HepMC::ConstGenParticlePtr current = link.scptr();
#else
            const HepMC::GenParticle* current = link.cptr();
#endif
 
            do {
                HepMcParticleLink curlink(HepMC::barcode(current), eventIndex, HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_BARCODE); // FIXME barcode-based
 
                // 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::barcode(*ppart), s->first.eventIndex(), HepMcParticleLink::IS_EVENTNUM, HepMcParticleLink::IS_BARCODE)); // FIXME barcode-based
            }
 
            // 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 900 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 443 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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t, const SG::NotHandleType &    )

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleBase &  hndl, const std::string &  doc, const SG::VarHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKey &  hndl, const std::string &  doc, const SG::VarHandleKeyType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, SG::VarHandleKeyArray &  hndArr, const std::string &  doc, const SG::VarHandleKeyArrayType &    )

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc, const SG::NotHandleType &    )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(name, property, doc);
  }

declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name, T &  property, const std::string &  doc = "none"  )

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  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.

{ return m_detStore; }

evtStore() [1/2]

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.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

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 1113 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) {
#ifdef HEPMC3
            HepMC::ConstGenParticlePtr gp = dit->first.scptr();
#else
            const HepMC::GenParticle* gp = dit->first;
#endif
            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 465 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::EI;
            }
            const Muon::sTgcPrepData* stgc = dynamic_cast<const Muon::sTgcPrepData*>(prd);
            if (stgc) {
                isEndcap = true;
                stIndex = Muon::MuonStationIndex::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()

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

inlinestaticinherited

Definition at line 33 of file IDetailedMuonPatternTruthBuilder.h.

{ return IID_IDetailedMuonPatternTruthBuilder; }

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

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 1140 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

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.

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.

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.

m_truthTrackBuilder

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

private

Definition at line 67 of file DetailedMuonPatternTruthBuilder.h.

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:

• DetailedMuonPatternTruthBuilder.h
• DetailedMuonPatternTruthBuilder.cxx