Muon::MuonRecoValidationTool Class Reference

#include <MuonRecoValidationTool.h>

Inheritance diagram for Muon::MuonRecoValidationTool:

Public Member Functions
	MuonRecoValidationTool (const std::string &, const std::string &, const IInterface *)
	default AlgTool constructor
	~MuonRecoValidationTool ()=default
	destructor
virtual StatusCode	initialize () override
	initialize method, method taken from bass-class AlgTool
bool	addTrackParticle (const xAOD::TrackParticle &indetTrackParticle, const MuonSystemExtension &muonSystemExtention) const override
	add a new TrackParticle with it's muon system extension
bool	add (const MuonSystemExtension::Intersection &intersection, const MuonSegment &segment, int stage) const override
	add a new segment
bool	add (const MuonSystemExtension::Intersection &intersection, const MuonHough::MuonLayerHough::Maximum &maximum) const override
	add a new hough maximum
bool	add (const MuonSystemExtension::Intersection &intersection, const Trk::PrepRawData &prd, float expos, float expos_err) const override
	add a new prd
bool	addTimeMeasurement (const MuonSystemExtension::Intersection &intersection, const Trk::MeasurementBase &meas) const override
	add a new time measurement
bool	addTimeMeasurement (const MuonSystemExtension::Intersection &intersection, const Identifier &id, const Amg::Vector3D &gpos, float time, float errorTime) const override
	add a new time measurement
bool	addTimeMeasurements (const xAOD::TrackParticle &indetTrackParticle, const MuGirlNS::StauHits &stauHits) const override
	add StauHits to ntuple
bool	addMuonCandidate (const xAOD::TrackParticle &indetTrackParticle, const MuonCandidate *candidate, Trk::Track *combinedTrack, int ntimes, float beta, float chi2ndof, int stage) const override
	add a new muon candidate
virtual void	handle (const Incident &inc) override
	incident service handle for EndEvent
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 ()
	AlgTool and IAlgTool interface methods.

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 ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	clear ()
	clear ntuples
void	extract (const MuonSegment &segment, std::set< Identifier > &ids, std::vector< const MuonClusterOnTrack * > &clusters) const
int	getIndex (const MuonSystemExtension::Intersection &intersection) const
int	getUniqueID (const std::set< Identifier > &ids) const
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"}
ServiceHandle< IMuonEDMHelperSvc >	m_edmHelperSvc
ToolHandle< IMuonSegmentHitSummaryTool >	m_segmentHitSummaryTool
ToolHandle< IMuonHitSummaryTool >	m_hitSummaryTool
ToolHandle< IMuonTruthSummaryTool >	m_truthSummaryTool
ToolHandle< Trk::IExtrapolator >	m_extrapolator
ToolHandle< IMuTagMatchingTool >	m_matchingTool
ToolHandle< IMuonHitTimingTool >	m_hitTimingTool
ServiceHandle< IIncidentSvc >	m_incidentSvc
std::vector< const xAOD::TrackParticle * >	m_trackParticles
std::map< const Trk::TrackParameters *, unsigned int >	m_trackParticleIndexLookup
MuonInsideOutValidationNtuple	m_ntuple
TTree *	m_tree = nullptr
std::atomic< unsigned int >	m_candidateCounter
bool	m_isMC
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 46 of file MuonRecoValidationTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonRecoValidationTool()

Muon::MuonRecoValidationTool::MuonRecoValidationTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

default AlgTool constructor

Definition at line 36 of file MuonRecoValidationTool.cxx.

                                                                                                              :
        AthAlgTool(t, n, p),
        m_segmentHitSummaryTool("Muon::MuonSegmentHitSummaryTool/MuonSegmentHitSummaryTool"),
        m_hitSummaryTool("Muon::MuonHitSummaryTool/MuonHitSummaryTool"),
        m_truthSummaryTool("Muon::MuonTruthSummaryTool/MuonTruthSummaryTool"),
        m_extrapolator("Trk::Extrapolation/AtlasExtrapolator"),
        m_matchingTool("MuTagMatchingTool/MuTagMatchingTool"),
        m_hitTimingTool("Muon::MuonHitTimingTool/MuonHitTimingTool"),
        m_incidentSvc("IncidentSvc", n),
        m_candidateCounter(0) {
        declareInterface<IMuonRecoValidationTool>(this);
        declareProperty("MuonSegmentHitSummaryTool", m_segmentHitSummaryTool);
        declareProperty("MuonHitSummaryTool", m_hitSummaryTool);
        declareProperty("MuonTruthSummaryTool", m_truthSummaryTool);
        declareProperty("Extrapolator", m_extrapolator);
        declareProperty("MatchTool", m_matchingTool);
        declareProperty("MuonHitTimingTool", m_hitTimingTool);
        declareProperty("IncidentSvc", m_incidentSvc);
        declareProperty("isMC", m_isMC = false);
    }

~MuonRecoValidationTool()

Muon::MuonRecoValidationTool::~MuonRecoValidationTool ( )

default

destructor

Member Function Documentation

add() [1/3]

bool Muon::MuonRecoValidationTool::add ( const MuonSystemExtension::Intersection & intersection, const MuonHough::MuonLayerHough::Maximum & maximum ) const

overridevirtual

add a new hough maximum

Implements Muon::IMuonRecoValidationTool.

Definition at line 401 of file MuonRecoValidationTool.cxx.

                                                                                          {
        m_ntuple.houghBlock.maximum->push_back(maximum.max);
 
        m_ntuple.houghBlock.track.fill(getIndex(intersection));
 
        int sector = -1;
        int chIndex = -1;
        float maxwidth = (maximum.binposmax - maximum.binposmin);
        if (maximum.hough) {
            maxwidth *= maximum.hough->m_binsize;
            sector = maximum.hough->m_descriptor.sector;
            chIndex = toInt(maximum.hough->m_descriptor.chIndex);
        }
        m_ntuple.houghBlock.id.fill(sector, chIndex);
        m_ntuple.houghBlock.residuals.fill(maximum.pos, maxwidth, intersection, Trk::loc1);
 
        // get truth from hits
        std::set<Identifier> ids;
 
        MuonHough::HitVec::const_iterator hit = maximum.hits.begin();
        MuonHough::HitVec::const_iterator hit_end = maximum.hits.end();
        for (; hit != hit_end; ++hit) {
            // treat the case that the hit is a composite TGC hit
            if ((*hit)->tgc) {
                for (const auto& prd : (*hit)->tgc->etaCluster) ids.insert(prd->identify());
            } else if ((*hit)->prd) {
                ids.insert((*hit)->prd->identify());
            }
        }
        int uniqueID = HepMC::INVALID_PARTICLE_ID, pdg = 0;
        if (m_isMC) {
            uniqueID = getUniqueID(ids);
            pdg = uniqueID != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(uniqueID) : 0;
        }
        m_ntuple.houghBlock.truth.fill(pdg, uniqueID);
 
        ATH_MSG_DEBUG(" Adding Hough maximum to ntuple ");
 
        return true;
    }

add() [2/3]

bool Muon::MuonRecoValidationTool::add ( const MuonSystemExtension::Intersection & intersection, const MuonSegment & segment, int stage ) const

overridevirtual

add a new segment

Implements Muon::IMuonRecoValidationTool.

Definition at line 320 of file MuonRecoValidationTool.cxx.

                                                                                                                                     {
        const EventContext& ctx = Gaudi::Hive::currentContext();
        m_ntuple.segmentBlock.stage->push_back(stage);
 
        Identifier id = m_edmHelperSvc->chamberId(segment);
        m_ntuple.segmentBlock.id.fill(m_idHelperSvc->sector(id), toInt(m_idHelperSvc->chamberIndex(id)));
 
        // position information
        m_ntuple.segmentBlock.r->push_back(segment.globalPosition().perp());
        m_ntuple.segmentBlock.z->push_back(segment.globalPosition().z());
 
        // timing information
        float t0 = segment.hasFittedT0() ? segment.time() : -99999;
        float t0Error = segment.hasFittedT0() ? segment.errorTime() : -99999;
        m_ntuple.segmentBlock.t0->push_back(t0);
        m_ntuple.segmentBlock.t0Error->push_back(t0Error);
 
        // extract clusters and ids
        std::set<Identifier> ids;
        std::vector<const MuonClusterOnTrack*> clusters;
        extract(segment, ids, clusters);
 
        IMuonHitTimingTool::TimingResult result = m_hitTimingTool->calculateTimingResult(clusters);
        t0 = result.valid ? result.time : -99999;
        t0Error = result.valid ? result.error : -99999;
        m_ntuple.segmentBlock.t0Trig->push_back(t0);
        m_ntuple.segmentBlock.t0TrigError->push_back(t0Error);
 
        // hit counts
        IMuonSegmentHitSummaryTool::HitCounts hitCounts = m_segmentHitSummaryTool->getHitCounts(segment);
        m_ntuple.segmentBlock.nmdtHits->push_back(hitCounts.nmdtHits()+ hitCounts.nmmHits() + hitCounts.ncscHits.netaHits);
        m_ntuple.segmentBlock.ntrigEtaHits->push_back(hitCounts.netaTrigHitLayers);
        m_ntuple.segmentBlock.ntrigPhiHits->push_back(hitCounts.nphiTrigHitLayers);
 
        // uniqueID + pdg
        int uniqueID = getUniqueID(ids);
        int pdg = 0;
        if (m_isMC) pdg = uniqueID != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(uniqueID) : 0;
        m_ntuple.segmentBlock.truth.fill(pdg, uniqueID);
 
        m_ntuple.segmentBlock.track.fill(getIndex(intersection));
 
        // extrapolate and create an intersection @ the segment surface.
        std::shared_ptr<Trk::TrackParameters> exPars(
            m_extrapolator->extrapolate(ctx, *intersection.trackParameters, segment.associatedSurface(), Trk::anyDirection, false, Trk::muon));
        if (!exPars) {
            ATH_MSG_VERBOSE(" extrapolation failed ");
            m_ntuple.segmentBlock.quality->push_back(-2);
            m_ntuple.segmentBlock.xresiduals.fill(0., 1., 0., 1., -1);
            m_ntuple.segmentBlock.yresiduals.fill(0., 1., 0., 1., -1);
            m_ntuple.segmentBlock.angleXZ.fill(0., 1., 0., 1., -1);
            m_ntuple.segmentBlock.angleYZ.fill(0., 1., 0., 1., -1);
            m_ntuple.segmentBlock.combinedYZ.fill(0., 1., 0., 1., -1);
            return false;
        }
 
        // cast to AtaPlane so we can get the segment info
        std::shared_ptr<Trk::AtaPlane> ataPlane = std::dynamic_pointer_cast<Trk::AtaPlane>(exPars);
        if (!ataPlane) {
            ATH_MSG_WARNING(" dynamic_cast<> failed ");
            m_ntuple.segmentBlock.quality->push_back(-2);
            m_ntuple.segmentBlock.angleXZ.fill(0., 1., 0., 1., -1);
            m_ntuple.segmentBlock.angleYZ.fill(0., 1., 0., 1., -1);
            m_ntuple.segmentBlock.combinedYZ.fill(0., 1., 0., 1., -1);
            return false;
        }
        MuonCombined::MuonSegmentInfo segmentInfo = m_matchingTool->muTagSegmentInfo(ctx, nullptr, segment, ataPlane);
        m_ntuple.segmentBlock.quality->push_back(segmentInfo.quality);
        m_ntuple.segmentBlock.xresiduals.fillResPull(segmentInfo.resX, segmentInfo.pullX, segmentInfo.segErrorX, segmentInfo.exErrorX, 1);
        m_ntuple.segmentBlock.yresiduals.fillResPull(segmentInfo.resY, segmentInfo.pullY, segmentInfo.segErrorY, segmentInfo.exErrorY, 1);
        m_ntuple.segmentBlock.angleXZ.fillResPull(segmentInfo.dangleXZ, segmentInfo.pullXZ, segmentInfo.segErrorXZ, segmentInfo.exErrorXZ,
                                                  1);
        m_ntuple.segmentBlock.angleYZ.fillResPull(segmentInfo.dangleYZ, segmentInfo.pullYZ, segmentInfo.segErrorYZ, segmentInfo.exErrorYZ,
                                                  1);
        m_ntuple.segmentBlock.combinedYZ.fillResPull(segmentInfo.resCY, segmentInfo.pullCY, 1);
 
        ATH_MSG_DEBUG(" Adding Segment to ntuple: stage " << stage);
 
        return true;
    }

add() [3/3]

bool Muon::MuonRecoValidationTool::add ( const MuonSystemExtension::Intersection & intersection, const Trk::PrepRawData & prd, float expos, float expos_err ) const

overridevirtual

add a new prd

Implements Muon::IMuonRecoValidationTool.

Definition at line 443 of file MuonRecoValidationTool.cxx.

                                                            {
        Identifier id = prd.identify();
        m_ntuple.hitBlock.id.fill(m_idHelperSvc->sector(id), toInt(m_idHelperSvc->chamberIndex(id)));
        m_ntuple.hitBlock.track.fill(getIndex(intersection));
 
        int uniqueID = HepMC::INVALID_PARTICLE_ID, pdg = 0;
        if (m_isMC) {
            uniqueID = m_truthSummaryTool->getUniqueID(id);
            pdg = uniqueID != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(uniqueID) : 0;
        }
        m_ntuple.hitBlock.truth.fill(pdg, uniqueID);
 
        float sign = expos < 0 ? -1. : 1.;
        m_ntuple.hitBlock.residuals.fill(sign * prd.localPosition()[Trk::locX], Amg::error(prd.localCovariance(), Trk::locX), expos,
                                         expos_err);
 
        return true;
    }

addMuonCandidate()

bool Muon::MuonRecoValidationTool::addMuonCandidate ( const xAOD::TrackParticle & indetTrackParticle, const MuonCandidate * candidate, Trk::Track * combinedTrack, int ntimes, float beta, float chi2ndof, int stage ) const

overridevirtual

add a new muon candidate

Implements Muon::IMuonRecoValidationTool.

Definition at line 487 of file MuonRecoValidationTool.cxx.

                                                                                                                                    {
        auto pos = std::find(m_trackParticles.begin(), m_trackParticles.end(), &indetTrackParticle);
        if (pos == m_trackParticles.end()) {
            ATH_MSG_WARNING("addMuonCandidate: indetTrackParticle not found ");
            return false;
        }
 
        m_ntuple.candidateBlock.track.fill(std::distance(m_trackParticles.begin(), pos));
        int nprec = 0;
        int ntrigPhi = 0;
        int ntrigEta = 0;
        int nseg = candidate ? candidate->layerIntersections.size() : 0;
        const Trk::Track* track = combinedTrack;
        if (combinedTrack) {
            IMuonHitSummaryTool::CompactSummary summary = m_hitSummaryTool->summary(*track);
            nprec = summary.nprecisionLayers;
            ntrigPhi = summary.nphiLayers;
            ntrigEta = summary.ntrigEtaLayers;
        }
        m_ntuple.candidateBlock.fill(ntimes, beta, chi2ndof, nseg, nprec, ntrigPhi, ntrigEta, stage);
        return true;
    }

addTimeMeasurement() [1/2]

bool Muon::MuonRecoValidationTool::addTimeMeasurement ( const MuonSystemExtension::Intersection & intersection, const Identifier & id, const Amg::Vector3D & gpos, float time, float errorTime ) const

overridevirtual

add a new time measurement

Implements Muon::IMuonRecoValidationTool.

Definition at line 216 of file MuonRecoValidationTool.cxx.

                                                                                                                {
        // track index
        m_ntuple.timeBlock.track.fill(getIndex(intersection));
 
        // identifier info
        m_ntuple.timeBlock.id.fill(m_idHelperSvc->sector(id), toInt(m_idHelperSvc->chamberIndex(id)));
 
        // position information
        m_ntuple.timeBlock.fill(2, m_idHelperSvc->gasGapId(id).get_identifier32().get_compact(), gpos.perp(), gpos.z(), time, errorTime);
 
        // uniqueID + pdg
        int uniqueID = HepMC::INVALID_PARTICLE_ID, pdg = 0;
        if (m_isMC) {
            uniqueID = m_truthSummaryTool->getUniqueID(id);
            pdg = uniqueID != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(uniqueID) : 0;
        }
        m_ntuple.timeBlock.truth.fill(pdg, uniqueID);
 
        return true;
    }

addTimeMeasurement() [2/2]

bool Muon::MuonRecoValidationTool::addTimeMeasurement ( const MuonSystemExtension::Intersection & intersection, const Trk::MeasurementBase & meas ) const

overridevirtual

add a new time measurement

Implements Muon::IMuonRecoValidationTool.

Definition at line 238 of file MuonRecoValidationTool.cxx.

                                                                                          {
        float segmentTimeCorrection = 0.;
 
        const MuonSegment* seg = dynamic_cast<const MuonSegment*>(&meas);
        if (seg && seg->hasFittedT0()) {
            m_ntuple.timeBlock.track.fill(getIndex(intersection));
 
            Identifier id = m_edmHelperSvc->chamberId(*seg);
            m_ntuple.timeBlock.id.fill(m_idHelperSvc->sector(id), toInt(m_idHelperSvc->chamberIndex(id)));
 
            // position information
            m_ntuple.timeBlock.fill(1, m_idHelperSvc->chamberId(id).get_identifier32().get_compact(), seg->globalPosition().perp(),
                                    seg->globalPosition().z(), seg->time() - segmentTimeCorrection, seg->errorTime());
 
            // uniqueID + pdg
            std::set<Identifier> ids;
            std::vector<const MuonClusterOnTrack*> clusters;
            extract(*seg, ids, clusters);
            int uniqueID = getUniqueID(ids);
            int pdg = 0;
            if (m_isMC) pdg = uniqueID != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(uniqueID) : 0;
            m_ntuple.timeBlock.truth.fill(pdg, uniqueID);
 
            return true;
        }
 
        const RpcClusterOnTrack* rpc = dynamic_cast<const RpcClusterOnTrack*>(&meas);
        if (rpc) {
            m_ntuple.timeBlock.track.fill(getIndex(intersection));
 
            Identifier id = rpc->identify();
            m_ntuple.timeBlock.id.fill(m_idHelperSvc->sector(id), toInt(m_idHelperSvc->chamberIndex(id)));
 
            // uniqueID + pdg
            int uniqueID = HepMC::INVALID_PARTICLE_ID, pdg = 0;
            if (m_isMC) {
                uniqueID = m_truthSummaryTool->getUniqueID(id);
                pdg = uniqueID != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(uniqueID) : 0;
            }
            m_ntuple.timeBlock.truth.fill(pdg, uniqueID);
 
            bool measphi = m_idHelperSvc->measuresPhi(id);
            const Amg::Vector3D& GP = rpc->globalPosition();
            const Muon::RpcPrepData* MClus = rpc->prepRawData();
            const MuonGM::RpcReadoutElement* rpc_readout_element = MClus->detectorElement();
            Amg::Vector3D posi = rpc_readout_element->stripPos(id);
 
            // let's correct rpc time subtracting delay due to the induced electric signal propagation along strip
            double correct_time_along_strip = 0;
            if (measphi == 0) {
                correct_time_along_strip = rpc_readout_element->distanceToEtaReadout(GP) / 1000. * SIG_VEL;
            } else {
                correct_time_along_strip = rpc_readout_element->distanceToPhiReadout(GP) / 1000. * SIG_VEL;
            }
 
            // let's evaluate the average  delay due to the induced electric signal propagation along strip
            double av_correct_time_along_strip = 0;
            if (measphi == 0) {
                av_correct_time_along_strip = rpc_readout_element->distanceToEtaReadout(posi) / 1000. * SIG_VEL;
            } else {
                av_correct_time_along_strip = rpc_readout_element->distanceToPhiReadout(posi) / 1000. * SIG_VEL;
            }
 
            // let's evaluate [real TOF - nominal TOF]
            double real_TOF_onRPCgap = GP.mag() / 1000. * C_VEL;
            double nominal_TOF_onRPCgap = posi.mag() / 1000. * C_VEL;
 
            // let's evaluate the total time correction
            double correct_time_tot = real_TOF_onRPCgap - nominal_TOF_onRPCgap + correct_time_along_strip - av_correct_time_along_strip;
 
            // time and position information
            m_ntuple.timeBlock.fill(0, m_idHelperSvc->gasGapId(id).get_identifier32().get_compact(), rpc->globalPosition().perp(),
                                    rpc->globalPosition().z(), rpc->time(), 2., correct_time_along_strip, av_correct_time_along_strip,
                                    real_TOF_onRPCgap, nominal_TOF_onRPCgap, correct_time_tot);
 
            return true;
        }
 
        return true;
    }

addTimeMeasurements()

bool Muon::MuonRecoValidationTool::addTimeMeasurements ( const xAOD::TrackParticle & indetTrackParticle, const MuGirlNS::StauHits & stauHits ) const

overridevirtual

add StauHits to ntuple

Implements Muon::IMuonRecoValidationTool.

Definition at line 178 of file MuonRecoValidationTool.cxx.

                                                                                             {
        Muon::MuonBetaCalculationUtils muonBetaCalculationUtils;
 
        auto pos = std::find(m_trackParticles.begin(), m_trackParticles.end(), &indetTrackParticle);
        if (pos == m_trackParticles.end()) {
            ATH_MSG_WARNING("addTimeMeasurement: indetTrackParticle not found ");
            return false;
        }
        int index = std::distance(m_trackParticles.begin(), pos);
 
        for (const auto& stauHit : stauHits) {
            Identifier id = stauHit.id;
            int type = toInt(m_idHelperSvc->technologyIndex(id)) + 10;
            double r = std::hypot(stauHit.x, stauHit.y);
            double tof = muonBetaCalculationUtils.calculateTof(1, std::hypot(r, stauHit.z));
            // track index
            m_ntuple.timeBlock.track.fill(index);
 
            // identifier info
            m_ntuple.timeBlock.id.fill(m_idHelperSvc->sector(id), toInt(m_idHelperSvc->chamberIndex(id)));
 
            // position + time information
            m_ntuple.timeBlock.fill(type, m_idHelperSvc->gasGapId(id).get_identifier32().get_compact(), r, stauHit.z, stauHit.mToF - tof,
                                    stauHit.error, stauHit.propagationTime, stauHit.e, tof, 0., stauHit.shift, 1000 * m_candidateCounter);
 
            // uniqueID + pdg
            int uniqueID = HepMC::INVALID_PARTICLE_ID, pdg = 0;
            if (m_isMC) {
              uniqueID = m_truthSummaryTool->getUniqueID(id);
              pdg = uniqueID != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(uniqueID) : 0;
            }
            m_ntuple.timeBlock.truth.fill(pdg, uniqueID);
        }
        ++m_candidateCounter;
        return true;
    }

addTrackParticle()

bool Muon::MuonRecoValidationTool::addTrackParticle ( const xAOD::TrackParticle & indetTrackParticle, const MuonSystemExtension & muonSystemExtention ) const

overridevirtual

add a new TrackParticle with it's muon system extension

Implements Muon::IMuonRecoValidationTool.

Definition at line 107 of file MuonRecoValidationTool.cxx.

                                                                                                        {
        m_ntuple.trackParticleBlock.pt->push_back(indetTrackParticle.pt());
        m_ntuple.trackParticleBlock.p->push_back(1. / indetTrackParticle.qOverP());
        m_ntuple.trackParticleBlock.eta->push_back(indetTrackParticle.eta());
        m_ntuple.trackParticleBlock.phi->push_back(indetTrackParticle.phi());
        int pdg = 0;
        int uniqueID = HepMC::INVALID_PARTICLE_ID;
        float beta = 1.;
        // set truth
        typedef ElementLink<xAOD::TruthParticleContainer> ElementTruthLink_t;
        static const SG::ConstAccessor<ElementTruthLink_t>
          truthParticleLinkAcc("truthParticleLink");
        if (truthParticleLinkAcc.isAvailable(indetTrackParticle)) {
            const ElementTruthLink_t link = truthParticleLinkAcc(indetTrackParticle);
            if (link.isValid()) {
                pdg = (*link)->pdgId();
                uniqueID = HepMC::uniqueID(*link);
                beta = (*link)->p4().Beta();
            }
        }
        m_ntuple.trackParticleBlock.truth.fill(pdg, uniqueID, beta);
 
        // try to find the pointer of the indetTrackParticle
        bool found = false;
        for (unsigned int index = 0; index < m_trackParticles.size(); ++index) {
            if (&indetTrackParticle == m_trackParticles[index]) {
                found = true;
                break;
            }
        }
        if (!found) {
            // set index to the last element
            unsigned int index = m_trackParticles.size();
            m_trackParticles.push_back(&indetTrackParticle);
 
            const std::vector<Muon::MuonSystemExtension::Intersection>& layerIntersections = muonSystemExtension.layerIntersections();
            ATH_MSG_DEBUG("Adding ID track: pt " << indetTrackParticle.pt() << " eta " << indetTrackParticle.eta() << " phi "
                                                 << indetTrackParticle.phi() << " layers " << layerIntersections.size());
 
            for (std::vector<Muon::MuonSystemExtension::Intersection>::const_iterator it = layerIntersections.begin();
                 it != layerIntersections.end(); ++it) {
                m_trackParticleIndexLookup[it->trackParameters.get()] = index;
            }
        }
        return true;
    }

clear()

void Muon::MuonRecoValidationTool::clear ( )

private

clear ntuples

Definition at line 91 of file MuonRecoValidationTool.cxx.

                                       {
        m_candidateCounter = 0;
        m_ntuple.clear();
        m_trackParticles.clear();
        m_trackParticleIndexLookup.clear();
    }

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.

{ return m_detStore; }

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.

{ return m_evtStore; }

extract()

void Muon::MuonRecoValidationTool::extract ( const MuonSegment & segment, std::set< Identifier > & ids, std::vector< const MuonClusterOnTrack * > & clusters ) const

private

Definition at line 463 of file MuonRecoValidationTool.cxx.

                                                                                               {
        // loop over hits and extract clusters and ids
        std::vector<const Trk::MeasurementBase*>::const_iterator mit = segment.containedMeasurements().begin();
        std::vector<const Trk::MeasurementBase*>::const_iterator mit_end = segment.containedMeasurements().end();
        for (; mit != mit_end; ++mit) {
            // get Identifier and remove MDT hits
            Identifier id = m_edmHelperSvc->getIdentifier(**mit);
            if (!id.is_valid()) continue;
            ids.insert(id);
            if (!m_idHelperSvc->isTrigger(id)) continue;
 
            // cast to  MuonClusterOnTrack
            const MuonClusterOnTrack* clus = dynamic_cast<const MuonClusterOnTrack*>(*mit);
            if (clus)
                clusters.push_back(clus);
            else {
                const CompetingMuonClustersOnTrack* crot = dynamic_cast<const CompetingMuonClustersOnTrack*>(*mit);
                if (!crot || crot->containedROTs().empty()) continue;
                clusters.insert(clusters.end(), crot->containedROTs().begin(), crot->containedROTs().end());
            }
        }
    }

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

getIndex()

int Muon::MuonRecoValidationTool::getIndex ( const MuonSystemExtension::Intersection & intersection ) const

inlineprivate

Definition at line 93 of file MuonRecoValidationTool.h.

                                                                                {
            int index = -1;
            auto result = m_trackParticleIndexLookup.find(intersection.trackParameters.get());
            if (result != m_trackParticleIndexLookup.end()) index = result->second;
            return index;
        }

getUniqueID()

int Muon::MuonRecoValidationTool::getUniqueID ( const std::set< Identifier > & ids ) const

private

Definition at line 155 of file MuonRecoValidationTool.cxx.

                                                                             {
      if (!m_isMC) return HepMC::INVALID_PARTICLE_ID;
 
      // count how often a barcode occurs
      std::map<int, int> counters;
      for (std::set<Identifier>::const_iterator it = ids.begin(); it != ids.end(); ++it) {
        const int uniqueID = m_truthSummaryTool->getUniqueID(*it);
        if (uniqueID != HepMC::INVALID_PARTICLE_ID) ++counters[uniqueID];
      }
 
      // pick the most frequent
      int barcode = HepMC::INVALID_PARTICLE_ID;
      int max = -1;
      for (std::map<int, int>::iterator it = counters.begin(); it != counters.end(); ++it) {
        if (it->second > max) {
          barcode = it->first; // FIXME barcode-based
          max = it->second;
        }
      }
 
      return barcode;
    }

handle()

void Muon::MuonRecoValidationTool::handle ( const Incident & inc )

overridevirtual

incident service handle for EndEvent

Definition at line 98 of file MuonRecoValidationTool.cxx.

                                                           {
        // Only clear cache for EndEvent incident
        if (inc.type() == IncidentType::EndEvent) {
            ATH_MSG_DEBUG(" clearing cache at end of event ");
            m_tree->Fill();
            clear();
        }
    }

initialize()

StatusCode Muon::MuonRecoValidationTool::initialize ( )

overridevirtual

initialize method, method taken from bass-class AlgTool

Definition at line 57 of file MuonRecoValidationTool.cxx.

                                                  {
 
        if (Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1) {
            ATH_MSG_ERROR("This tool cannot be used in multi-threaded mode");
            return StatusCode::FAILURE;
        }
 
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_segmentHitSummaryTool.retrieve());
        ATH_CHECK(m_hitSummaryTool.retrieve());
        if (m_isMC) {
            ATH_CHECK(m_truthSummaryTool.retrieve());
        } else {
            m_truthSummaryTool.disable();
        }
        ATH_CHECK(m_extrapolator.retrieve());
        ATH_CHECK(m_matchingTool.retrieve());
        ATH_CHECK(m_hitTimingTool.retrieve());
        SmartIF<ITHistSvc> thistSvc{service("THistSvc")};
        ATH_CHECK(thistSvc.isValid());
 
        m_tree = new TTree("data", "RecoValidation");
        ATH_CHECK(thistSvc->regTree("/MuonRecoVal/data", m_tree));
 
        m_ntuple.init("", m_tree);
 
        // call handle in case of EndEvent
        ATH_CHECK(m_incidentSvc.retrieve());
        m_incidentSvc->addListener(this, IncidentType::EndEvent);
 
        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 & Muon::IMuonRecoValidationTool::interfaceID ( )

inlinestaticinherited

AlgTool and IAlgTool interface methods.

Definition at line 27 of file IMuonRecoValidationTool.h.

                                                {
            static const InterfaceID IID_IMuonRecoValidationTool("Muon::IMuonRecoValidationTool", 1, 0);
            return IID_IMuonRecoValidationTool;
        }

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();
  }

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

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_candidateCounter

std::atomic<unsigned int> Muon::MuonRecoValidationTool::m_candidateCounter

mutableprivate

Definition at line 121 of file MuonRecoValidationTool.h.

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_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MuonRecoValidationTool::m_edmHelperSvc

private

Initial value:

{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                        "Handle to the service providing the IMuonEDMHelperSvc interface"}

Definition at line 104 of file MuonRecoValidationTool.h.

                                                       {this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                        "Handle to the service providing the IMuonEDMHelperSvc interface"};

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_extrapolator

ToolHandle<Trk::IExtrapolator> Muon::MuonRecoValidationTool::m_extrapolator

private

Definition at line 109 of file MuonRecoValidationTool.h.

m_hitSummaryTool

ToolHandle<IMuonHitSummaryTool> Muon::MuonRecoValidationTool::m_hitSummaryTool

private

Definition at line 107 of file MuonRecoValidationTool.h.

m_hitTimingTool

ToolHandle<IMuonHitTimingTool> Muon::MuonRecoValidationTool::m_hitTimingTool

private

Definition at line 111 of file MuonRecoValidationTool.h.

m_idHelperSvc

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

private

Definition at line 103 of file MuonRecoValidationTool.h.

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

m_incidentSvc

ServiceHandle<IIncidentSvc> Muon::MuonRecoValidationTool::m_incidentSvc

private

Definition at line 112 of file MuonRecoValidationTool.h.

m_isMC

bool Muon::MuonRecoValidationTool::m_isMC

private

Definition at line 123 of file MuonRecoValidationTool.h.

m_matchingTool

ToolHandle<IMuTagMatchingTool> Muon::MuonRecoValidationTool::m_matchingTool

private

Definition at line 110 of file MuonRecoValidationTool.h.

m_ntuple

MuonInsideOutValidationNtuple Muon::MuonRecoValidationTool::m_ntuple

mutableprivate

Definition at line 118 of file MuonRecoValidationTool.h.

m_segmentHitSummaryTool

ToolHandle<IMuonSegmentHitSummaryTool> Muon::MuonRecoValidationTool::m_segmentHitSummaryTool

private

Definition at line 106 of file MuonRecoValidationTool.h.

m_trackParticleIndexLookup

std::map<const Trk::TrackParameters*, unsigned int> Muon::MuonRecoValidationTool::m_trackParticleIndexLookup

mutableprivate

Definition at line 116 of file MuonRecoValidationTool.h.

m_trackParticles

std::vector<const xAOD::TrackParticle*> Muon::MuonRecoValidationTool::m_trackParticles

mutableprivate

Definition at line 115 of file MuonRecoValidationTool.h.

m_tree

TTree* Muon::MuonRecoValidationTool::m_tree = nullptr

private

Definition at line 119 of file MuonRecoValidationTool.h.

m_truthSummaryTool

ToolHandle<IMuonTruthSummaryTool> Muon::MuonRecoValidationTool::m_truthSummaryTool

private

Definition at line 108 of file MuonRecoValidationTool.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:

• MuonRecoValidationTool.h
• MuonRecoValidationTool.cxx