Muon::MuonRecoValidationTool Class Reference

#include <MuonRecoValidationTool.h>

Inheritance diagram for Muon::MuonRecoValidationTool:

Collaboration diagram for Muon::MuonRecoValidationTool:

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

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

Private Member Functions
void	clear ()
	clear ntuples More...
void	extract (const MuonSegment &segment, std::set< Identifier > &ids, std::vector< const MuonClusterOnTrack * > &clusters) const
int	getIndex (const MuonSystemExtension::Intersection &intersection) const
int	getBarcode (const std::set< Identifier > &ids) const
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"}
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) 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 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 35 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 400 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 = 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 barcode = HepMC::INVALID_PARTICLE_ID, pdg = 0;
        if (m_isMC) {
            barcode = getBarcode(ids);
            pdg = barcode != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(barcode) : 0;
        }
        m_ntuple.houghBlock.truth.fill(pdg, barcode);
 
        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 319 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), 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);
 
        // barcode + pdg
        int barcode = getBarcode(ids);
        int pdg = 0;
        if (m_isMC) pdg = barcode != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(barcode) : 0;
        m_ntuple.segmentBlock.truth.fill(pdg, barcode);
 
        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 442 of file MuonRecoValidationTool.cxx.

                                                            {
        Identifier id = prd.identify();
        m_ntuple.hitBlock.id.fill(m_idHelperSvc->sector(id), m_idHelperSvc->chamberIndex(id));
        m_ntuple.hitBlock.track.fill(getIndex(intersection));
 
        int barcode = HepMC::INVALID_PARTICLE_ID, pdg = 0;
        if (m_isMC) {
            barcode = m_truthSummaryTool->getBarcode(id);
            pdg = barcode != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(barcode) : 0;
        }
        m_ntuple.hitBlock.truth.fill(pdg, barcode);
 
        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 486 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 215 of file MuonRecoValidationTool.cxx.

                                                                                                                {
        // track index
        m_ntuple.timeBlock.track.fill(getIndex(intersection));
 
        // identifier info
        m_ntuple.timeBlock.id.fill(m_idHelperSvc->sector(id), 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);
 
        // barcode + pdg
        int barcode = HepMC::INVALID_PARTICLE_ID, pdg = 0;
        if (m_isMC) {
            barcode = m_truthSummaryTool->getBarcode(id);
            pdg = barcode != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(barcode) : 0;
        }
        m_ntuple.timeBlock.truth.fill(pdg, barcode);
 
        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 237 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), 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());
 
            // barcode + pdg
            std::set<Identifier> ids;
            std::vector<const MuonClusterOnTrack*> clusters;
            extract(*seg, ids, clusters);
            int barcode = getBarcode(ids);
            int pdg = 0;
            if (m_isMC) pdg = barcode != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(barcode) : 0;
            m_ntuple.timeBlock.truth.fill(pdg, barcode);
 
            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), m_idHelperSvc->chamberIndex(id));
 
            // barcode + pdg
            int barcode = HepMC::INVALID_PARTICLE_ID, pdg = 0;
            if (m_isMC) {
                barcode = m_truthSummaryTool->getBarcode(id);
                pdg = barcode != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(barcode) : 0;
            }
            m_ntuple.timeBlock.truth.fill(pdg, barcode);
 
            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 177 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 = m_idHelperSvc->technologyIndex(id) + 10;
            double r = sqrt(stauHit.x * stauHit.x + stauHit.y * stauHit.y);
            double tof = muonBetaCalculationUtils.calculateTof(1, sqrt(r * r + stauHit.z * stauHit.z));
            // track index
            m_ntuple.timeBlock.track.fill(index);
 
            // identifier info
            m_ntuple.timeBlock.id.fill(m_idHelperSvc->sector(id), 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);
 
            // barcode + pdg
            int barcode = HepMC::INVALID_PARTICLE_ID, pdg = 0;
            if (m_isMC) {
              barcode = m_truthSummaryTool->getBarcode(id); // FIXME barcode-based
              pdg = barcode != HepMC::INVALID_PARTICLE_ID ? m_truthSummaryTool->getPdgId(barcode) : 0;
            }
            m_ntuple.timeBlock.truth.fill(pdg, barcode);
        }
        ++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 106 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 barcode = HepMC::INVALID_PARTICLE_ID; // FIXME barcode-based
        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();
                barcode = HepMC::barcode(*link);
                beta = (*link)->p4().Beta();
            }
        }
        m_ntuple.trackParticleBlock.truth.fill(pdg, barcode, beta); // FIXME barcode-based
 
        // 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 90 of file MuonRecoValidationTool.cxx.

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

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

extract()

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

private

Definition at line 462 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

getBarcode()

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

private

Definition at line 154 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 bc = m_truthSummaryTool->getBarcode(*it); // FIXME barcode-based
        if (bc != HepMC::INVALID_PARTICLE_ID) ++counters[bc];
      }
 
      // 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;
    }

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

handle()

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

overridevirtual

incident service handle for EndEvent

Definition at line 97 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 56 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()

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

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_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.

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.

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