#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, V, H > &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	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> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &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 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() [1/4]

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

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	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, V, H > &	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, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

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

85 { 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.

90 { 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()

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:

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ MuonRecoValidationTool()

◆ ~MuonRecoValidationTool()

Member Function Documentation

◆ add() [1/3]

◆ add() [2/3]

◆ add() [3/3]

◆ addMuonCandidate()

◆ addTimeMeasurement() [1/2]

◆ addTimeMeasurement() [2/2]

◆ addTimeMeasurements()

◆ addTrackParticle()

◆ clear()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extract()

◆ extraDeps_update_handler()

◆ getIndex()

◆ getUniqueID()

◆ handle()

◆ initialize()

◆ inputHandles()

◆ interfaceID()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_candidateCounter

◆ m_detStore

◆ m_edmHelperSvc

◆ m_evtStore

◆ m_extrapolator

◆ m_hitSummaryTool

◆ m_hitTimingTool

◆ m_idHelperSvc

◆ m_incidentSvc

◆ m_isMC

◆ m_matchingTool

◆ m_ntuple

◆ m_segmentHitSummaryTool

◆ m_trackParticleIndexLookup

◆ m_trackParticles

◆ m_tree

◆ m_truthSummaryTool

◆ m_varHandleArraysDeclared

◆ m_vhka