Muon::MuonSegmentRegionRecoveryTool Class Reference

Implementation of an IMuonHoleRecoveryTool. More...

#include <MuonSegmentRegionRecoveryTool.h>

Inheritance diagram for Muon::MuonSegmentRegionRecoveryTool:

Collaboration diagram for Muon::MuonSegmentRegionRecoveryTool:

Classes
struct	MuonData

Public Member Functions
	MuonSegmentRegionRecoveryTool (const std::string &, const std::string &, const IInterface *)
	constructor More...
virtual	~MuonSegmentRegionRecoveryTool ()=default
	destructor More...
virtual StatusCode	initialize () override
	AlgTool initialize. More...
virtual std::unique_ptr< Trk::Track >	recover (const Trk::Track &track, const EventContext &ctx) const override
	returns a new track with segments recovered using RegionSelector More...
void	createHoleTSOSsForClusterChamber (const Identifier &detElId, const EventContext &ctx, const Trk::TrackParameters &pars, std::set< Identifier > &layIds, std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > &states) const override
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 ()
	access to tool interface 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
std::unique_ptr< const Trk::TrackParameters >	reachableDetEl (const EventContext &ctx, const Trk::Track &track, const Trk::TrkDetElementBase &detEl, bool smallerBounds=false) const
void	collectCrossedChambers (const EventContext &ctx, const Trk::Track &track, MuonData &data) const
	methods used by recover More...
void	fillOnTrackChambers (const Trk::Track &theTrack, MuonData &data) const
std::unique_ptr< Trk::Track >	addMissingChambers (const EventContext &ctx, const Trk::Track &track, MuonData &data, bool addMdt) const
void	addHashes (const EventContext &ctx, DETID type, const IRoiDescriptor &roi, std::set< IdentifierHash > &hashes, const std::set< IdentifierHash > &exclusion) const
std::unique_ptr< Trk::Track >	findHoles (const EventContext &ctx, const Trk::Track &track, MuonData &data) 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< IMuonEDMHelperSvc >	m_edmHelperSvc
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ToolHandle< IMuonSeededSegmentFinder >	m_seededSegmentFinder
ToolHandle< IMuonTrackSegmentMatchingTool >	m_trackSegmentMatchingTool
ToolHandle< MuonChamberHoleRecoveryTool >	m_chamberHoleRecoveryTool {this, "ChamberHoleRecoveryTool", "", "hit-based hole search"}
ToolHandle< Trk::IExtrapolator >	m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/MuonExtrapolator"}
ToolHandle< Rec::ICombinedMuonTrackFitter >	m_builder {this, "Builder", ""}
ToolHandle< Trk::ITrackFitter >	m_fitter {this, "Fitter", "Trk::GlobalChi2Fitter/MCTBSLFitter"}
ToolHandle< IMuonHitSummaryTool >	m_hitSummaryTool {this, "HitSummaryTool", "Muon::MuonHitSummaryTool/MuonHitSummaryTool"}
ToolHandle< IRegSelTool >	m_regsel_mdt {this, "MDTRegionSelector", "RegSelTool/RegSelTool_MDT"}
ToolHandle< IRegSelTool >	m_regsel_csc {this, "CSCRegionSelector", "RegSelTool/RegSelTool_CSC"}
ToolHandle< IRegSelTool >	m_regsel_rpc {this, "RPCRegionSelector", "RegSelTool/RegSelTool_RPC"}
ToolHandle< IRegSelTool >	m_regsel_tgc {this, "TGCRegionSelector", "RegSelTool/RegSelTool_TGC"}
ToolHandle< IRegSelTool >	m_regsel_stgc {this, "STGCRegionSelector", "RegSelTool/RegSelTool_STGC"}
ToolHandle< IRegSelTool >	m_regsel_mm {this, "MMRegionSelector", "RegSelTool/RegSelTool_MM"}
PublicToolHandle< MuonEDMPrinterTool >	m_printer {this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}
SG::ReadCondHandleKey< Muon::MuonIntersectGeoData >	m_chamberGeoKey {this, "ChamberGeoKey", "MuonStationIntersects", "Pointer to hole search service"}
Gaudi::Property< double >	m_deta {this, "DeltaEtaRegion", 0.05}
Gaudi::Property< double >	m_dphi {this, "DeltaPhiRegion", 0.1}
Gaudi::Property< bool >	m_excludeEES {this, "ExcludeEES", true}
Gaudi::Property< bool >	m_onlyEO {this, "OnlyEO", false}
Gaudi::Property< bool >	m_useFitterOutlierLogic {this, "UseFitterOutlierLogic", true}
Gaudi::Property< bool >	m_recoverMM {this, "RecoverMM", true, "Pick up dropped micromega chambers"}
Gaudi::Property< bool >	m_recoverSTGC {this, "RecoverSTGC", true, "Pick up dropped sTGC chambers"}
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

Implementation of an IMuonHoleRecoveryTool.

It propagates the track to a chamber where no segments where found and runs the SeededSegmentFinder in a region selected by the region selector

Definition at line 67 of file MuonSegmentRegionRecoveryTool.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

MuonSegmentRegionRecoveryTool()

MuonSegmentRegionRecoveryTool::MuonSegmentRegionRecoveryTool	(	const std::string &	ty,
		const std::string &	na,
		const IInterface *	pa
	)

constructor

Definition at line 48 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                                                                               :
        AthAlgTool(ty, na, pa) {
        declareInterface<IMuonHoleRecoveryTool>(this);
    }

~MuonSegmentRegionRecoveryTool()

virtual Muon::MuonSegmentRegionRecoveryTool::~MuonSegmentRegionRecoveryTool ( )

virtualdefault

destructor

Member Function Documentation

addHashes()

void MuonSegmentRegionRecoveryTool::addHashes ( const EventContext &  ctx, DETID  type, const IRoiDescriptor &  roi, std::set< IdentifierHash > &  hashes, const std::set< IdentifierHash > &  exclusion  ) const

private

Definition at line 165 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                        {
        // if only looking at EO, skip all but MDT chambers
        if (m_onlyEO && type != MDT) return;
 
        std::vector<IdentifierHash> crossed;
 
        if (type == MDT && m_regsel_mdt->lookup(ctx)) m_regsel_mdt->lookup(ctx)->HashIDList(roi, crossed);
        if (type == CSC && m_regsel_csc->lookup(ctx)) m_regsel_csc->lookup(ctx)->HashIDList(roi, crossed);
        if (type == RPC && m_regsel_rpc->lookup(ctx)) m_regsel_rpc->lookup(ctx)->HashIDList(roi, crossed);
        if (type == TGC && m_regsel_tgc->lookup(ctx)) m_regsel_tgc->lookup(ctx)->HashIDList(roi, crossed);
        if (type == STGC && m_regsel_stgc->lookup(ctx)) m_regsel_stgc->lookup(ctx)->HashIDList(roi, crossed);
        if (type == MM && m_regsel_mm->lookup(ctx)) m_regsel_mm->lookup(ctx)->HashIDList(roi, crossed);
 
        for (std::vector<IdentifierHash>::iterator it = crossed.begin(); it != crossed.end(); ++it) {
            if (!exclusion.count(*it) && !hashes.count(*it)) {
                if (type == MDT) {
                    Identifier chId;
                    IdContext otCont = m_idHelperSvc->mdtIdHelper().module_context();
                    m_idHelperSvc->mdtIdHelper().get_id(*it, chId, &otCont);
 
                    if (m_excludeEES && m_idHelperSvc->chamberIndex(chId) == MuonStationIndex::EES) {
                        ATH_MSG_VERBOSE("  excluding " << *it << " " << m_idHelperSvc->toStringChamber(chId));
                        continue;
                    }
                    if (m_onlyEO && m_idHelperSvc->stationIndex(chId) != MuonStationIndex::EO) {
                        ATH_MSG_VERBOSE("  excluding " << *it << " " << m_idHelperSvc->toStringChamber(chId));
                        continue;
                    }
                    ATH_MSG_VERBOSE("  -- hash " << *it << " " << m_idHelperSvc->toStringChamber(chId));
                }
                if (type == CSC) {
                    Identifier chId;
                    IdContext otCont = m_idHelperSvc->cscIdHelper().module_context();
                    m_idHelperSvc->cscIdHelper().get_id(*it, chId, &otCont);
                    ATH_MSG_VERBOSE("  -- csc hash " << *it << " " << m_idHelperSvc->toStringChamber(chId));
                }
                if (type == STGC) {
                    Identifier chId;
                    IdContext otCont = m_idHelperSvc->stgcIdHelper().detectorElement_context();
                    m_idHelperSvc->stgcIdHelper().get_id(*it, chId, &otCont);
                    ATH_MSG_VERBOSE("  -- stgc hash " << *it << " " << m_idHelperSvc->toStringChamber(chId));
                }
                if (type == MM) {
                    Identifier chId;
                    IdContext otCont = m_idHelperSvc->mmIdHelper().detectorElement_context();
                    m_idHelperSvc->mmIdHelper().get_id(*it, chId, &otCont);
                    ATH_MSG_VERBOSE("  -- mm hash " << *it << " " << m_idHelperSvc->toStringChamber(chId));
                }
                hashes.insert(*it);
            }
        }
    }

addMissingChambers()

std::unique_ptr< Trk::Track > MuonSegmentRegionRecoveryTool::addMissingChambers ( const EventContext &  ctx, const Trk::Track &  track, MuonData &  data, bool  addMdt  ) const

private

Definition at line 694 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                                                                     {
        // states were added, create a new track
        std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> states;
        std::set<IdentifierHash> newMdtHashes;
        std::set<IdentifierHash> newRpcHashes;
        std::set<IdentifierHash> newTgcHashes;
        std::set<IdentifierHash> newCscHashes;
        // New Small Wheel
        std::set<IdentifierHash> newMMHashes;
        std::set<IdentifierHash> newsTgcHashes;
        if (addMdt) {
            ATH_MSG_DEBUG("Adding Missing MDT chambers: regions " << data.mdtPerStation.size());
            std::vector<const MdtPrepDataCollection*> newmcols;
            for (const auto& chit : data.mdtPerStation) {
                ATH_MSG_VERBOSE("Region " << MuonStationIndex::chName(chit.first) << " size  " << chit.second.size());
                std::vector<const MdtPrepDataCollection*> cols;
                m_seededSegmentFinder->extractMdtPrdCols(ctx, chit.second, cols);
                std::map<int, std::vector<const MdtPrepData*>> mdtPrds;
                std::unique_ptr<const Trk::TrackParameters> exParsFirst;
                for (const MdtPrepDataCollection* mit : cols) {
                    std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *mit->front()->detectorElement())};
                    if (exPars) {
                        int sector = m_idHelperSvc->sector(mit->identify());
                        ATH_MSG_DEBUG("New chamber " << m_idHelperSvc->toStringChamber(mit->identify()) << " hash " << mit->identifyHash()
                                                     << " sector " << sector);
                        newmcols.emplace_back(mit);
                        std::vector<const MdtPrepData*>& col = mdtPrds[sector];
                        col.insert(col.end(), mit->begin(), mit->end());
                        if (!exParsFirst) exParsFirst.swap(exPars);
 
                    } else {
                        ATH_MSG_DEBUG("Did not reach chamber " << m_idHelperSvc->toStringChamber(mit->identify()) << " hash "
                                                               << mit->identifyHash());
                    }
                }
                std::vector<const MdtPrepData*>* prds = nullptr;
                std::map<int, std::vector<const MdtPrepData*>>::iterator sectorIt = mdtPrds.begin();
                if (mdtPrds.empty()) {
                    ATH_MSG_VERBOSE("No hits selected");
                } else if (mdtPrds.size() == 1) {
                    prds = &sectorIt->second;
                } else {
                    IMuonHitSummaryTool::CompactSummary hitSummary = m_hitSummaryTool->summary(track);
                    ATH_MSG_VERBOSE("Multiple sectors selected, using main sector: " << hitSummary.mainSector);
                    std::map<int, std::vector<const MdtPrepData*>>::iterator pos = mdtPrds.find(hitSummary.mainSector);
                    if (pos != mdtPrds.end())
                        prds = &pos->second;
                    else {
                        ATH_MSG_DEBUG("Failed to find prds in main sector: " << hitSummary.mainSector);
                    }
                }
                if (prds && exParsFirst) {
                    std::unique_ptr<Trk::SegmentCollection> segments = m_seededSegmentFinder->find(ctx, *exParsFirst, *prds);
                    if (segments) {
                        if (!segments->empty()) ATH_MSG_DEBUG("found segments " << segments->size());
 
                        MuonSegment* bestSegment = nullptr;
                        std::unique_ptr<const Trk::TrackParameters> bestSegmentPars;
                        for (Trk::Segment* tseg : *segments) {
                            MuonSegment* mseg = dynamic_cast<MuonSegment*>(tseg);
 
                            if (m_trackSegmentMatchingTool.empty())
                                ATH_MSG_VERBOSE("No track/segment matching");
                            else if (!m_trackSegmentMatchingTool->match(ctx, track, *mseg, true)) {
                                ATH_MSG_DEBUG(" Segment does not match with track ");
                                continue;
                            } else {
                                ATH_MSG_DEBUG(" Segment/track matched successfully using " << m_trackSegmentMatchingTool);
                            }
                            std::unique_ptr<const Trk::TrackParameters> segPars{m_extrapolator->extrapolateDirectly(
                                ctx, *exParsFirst, mseg->associatedSurface(), Trk::anyDirection, false, Trk::muon)};
                            if (segPars) {
                                double resy = mseg->localParameters()[Trk::locY] - segPars->parameters()[Trk::locY];
                                Trk::LocalDirection locDir;
                                mseg->associatedSurface().globalToLocalDirection(segPars->momentum(), locDir);
                                double dangleYZ = mseg->localDirection().angleYZ() - locDir.angleYZ();
                                ATH_MSG_DEBUG("resy " << resy << " dangleYZ " << dangleYZ << " " << m_printer->print(*mseg));
                                if (std::abs(dangleYZ) < 0.05) {
                                    bestSegment = mseg;
                                    bestSegmentPars.swap(segPars);
                                }
                            } else {
                                ATH_MSG_DEBUG("Did not reach " << m_printer->print(*mseg));
                            }
                        }
                        if (bestSegment) {
                            for (const Trk::MeasurementBase* hit : bestSegment->containedMeasurements()) {
                                std::unique_ptr<Trk::TrackParameters> hitPars{m_extrapolator->extrapolateDirectly(
                                    ctx, *bestSegmentPars, hit->associatedSurface(), Trk::anyDirection, false, Trk::muon)};
                                if (hitPars) {
                                    std::bitset<Trk::TrackStateOnSurface::NumberOfTrackStateOnSurfaceTypes> typePattern;
                                    typePattern.set(Trk::TrackStateOnSurface::Measurement);
                                    Trk::TrackStateOnSurface* tsos =
                                        new Trk::TrackStateOnSurface(hit->uniqueClone(), std::move(hitPars), nullptr, typePattern);
                                    states.emplace_back(tsos);
                                    const MdtDriftCircleOnTrack* mdt = dynamic_cast<const MdtDriftCircleOnTrack*>(hit);
                                    if (mdt) newMdtHashes.insert(mdt->collectionHash());
                                } else {
                                    ATH_MSG_WARNING("Failed to extrapolate to MDT hit ");
                                }
                            }
                        }
                    }
                }
            }
            data.mdtCols = std::move(newmcols);
        } else {
            unsigned int nstates = states.size();
            {
                m_seededSegmentFinder->extractRpcPrdCols(ctx, data.rpc, data.rpcCols);
                std::vector<const RpcPrepDataCollection*> newtcols;
                for (const RpcPrepDataCollection* rit : data.rpcCols) {
                    std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *(rit)->front()->detectorElement())};
                    if (exPars) {
                        newtcols.emplace_back(rit);
                        Identifier detElId = m_idHelperSvc->detElId(rit->identify());
                        std::set<Identifier> layIds;
                        createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, states);
                        if (states.size() != nstates) {
                            nstates = states.size();
                            newRpcHashes.insert(rit->identifyHash());
                        }
                    }
                }
                data.rpcCols = std::move(newtcols);
            }
            {
                m_seededSegmentFinder->extractTgcPrdCols(ctx, data.tgc, data.tgcCols);
                std::vector<const TgcPrepDataCollection*> newtcols;
                for (const TgcPrepDataCollection* tgcit : data.tgcCols) {
                    std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *(tgcit)->front()->detectorElement())};
                    if (exPars) {
                        newtcols.emplace_back(tgcit);
                        Identifier detElId = m_idHelperSvc->detElId(tgcit->identify());
                        std::set<Identifier> layIds;
                        createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, states);
                        if (states.size() != nstates) {
                            nstates = states.size();
                            newTgcHashes.insert(tgcit->identifyHash());
                        }
                    }
                }
                data.tgcCols = std::move(newtcols);
            }
 
            m_seededSegmentFinder->extractCscPrdCols(data.csc, data.cscCols);
            std::vector<const CscPrepDataCollection*> newccols;
            for (const CscPrepDataCollection* cit : data.cscCols) {
                std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *(cit)->front()->detectorElement())};
                if (exPars) {
                    newccols.push_back(cit);
                    Identifier detElId = m_idHelperSvc->detElId(cit->identify());
                    std::set<Identifier> layIds;
                    createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, states);
                    if (states.size() != nstates) {
                        nstates = states.size();
                        newCscHashes.insert(cit->identifyHash());
                    }
                }
            }
            data.cscCols = std::move(newccols);
 
            nstates = states.size();
            if (m_recoverSTGC) {
                m_seededSegmentFinder->extractsTgcPrdCols(ctx, data.stgc, data.stgcCols);
                std::vector<const sTgcPrepDataCollection*> newstcols;
                ATH_MSG_DEBUG(" extractsTgcPrdCols data.stgcCols.size() " << data.stgcCols.size());
                for (const sTgcPrepDataCollection* stgcit : data.stgcCols) {
                    std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *(stgcit)->front()->detectorElement())};
                    if (exPars) {
                        newstcols.push_back(stgcit);
                        Identifier detElId = m_idHelperSvc->detElId(stgcit->identify());
                        std::set<Identifier> layIds;
                        createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, states);
                        ATH_MSG_DEBUG("Collected new sTgc states: " << states.size());
                        if (states.size() != nstates) {
                            nstates = states.size();
                            newsTgcHashes.insert(stgcit->identifyHash());
                        }
                    }
                }
                data.stgcCols = std::move(newstcols);
            }
 
            if (m_recoverMM) {
                m_seededSegmentFinder->extractMMPrdCols(data.mm, data.mmCols);
                ATH_MSG_DEBUG(" extractMMPrdCols data.mmCols.size() " << data.mmCols.size());
                std::vector<const MMPrepDataCollection*> newmcols;
                for (const MMPrepDataCollection* mit : data.mmCols) {
                    std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *mit->front()->detectorElement())};
                    if (exPars) {
                        newmcols.push_back(mit);
                        Identifier detElId = m_idHelperSvc->detElId(mit->identify());
                        std::set<Identifier> layIds;
                        createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, states);
                        ATH_MSG_DEBUG("Collected new Mm states: " << states.size());
                        if (states.size() != nstates) {
                            nstates = states.size();
                            newMMHashes.insert(mit->identifyHash());
                        }
                    }
                }
                data.mmCols = std::move(newmcols);
            }
        }
        if (!states.empty()) {
            ATH_MSG_DEBUG("Collected new states: " << states.size());
 
            const Trk::TrackStates* oldStates = track.trackStateOnSurfaces();
            if (!oldStates) {
                ATH_MSG_WARNING(" track without states, cannot perform cleaning ");
                return nullptr;
            }
 
            ATH_MSG_DEBUG("Copying old TSOSs " << oldStates->size());
            for (const Trk::TrackStateOnSurface* tsit : *oldStates) states.emplace_back(tsit->clone());
 
            std::stable_sort(states.begin(), states.end(), SortTSOSs(m_edmHelperSvc.get(), m_idHelperSvc.get()));
            ATH_MSG_DEBUG("Filling DataVector with TSOSs " << states.size());
            auto trackStateOnSurfaces = std::make_unique<Trk::TrackStates>();
            trackStateOnSurfaces->reserve(states.size());
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& sorted : states) { trackStateOnSurfaces->push_back(sorted.release()); }
            ATH_MSG_DEBUG("Creating new Track " << states.size());
            std::unique_ptr<Trk::Track> newTrack = std::make_unique<Trk::Track>(track.info(), std::move(trackStateOnSurfaces),
                                                                                track.fitQuality() ? track.fitQuality()->uniqueClone() : nullptr);
            std::unique_ptr<Trk::Track> refittedTrack;
            if (m_onlyEO)
                refittedTrack = std::unique_ptr<Trk::Track>(m_fitter->fit(ctx, *newTrack, m_useFitterOutlierLogic, Trk::muon));
            else
                refittedTrack = std::unique_ptr<Trk::Track>(m_builder->fit(ctx, *newTrack, m_useFitterOutlierLogic, Trk::muon));
            if (refittedTrack) {
                ATH_MSG_DEBUG("New Track " << m_printer->print(*refittedTrack) << std::endl << m_printer->printStations(*refittedTrack));
 
                // fit ok, add new hashs to lists
                data.mdtTrack.insert(newMdtHashes.begin(), newMdtHashes.end());
                data.rpcTrack.insert(newRpcHashes.begin(), newRpcHashes.end());
                data.tgcTrack.insert(newTgcHashes.begin(), newTgcHashes.end());
                data.cscTrack.insert(newCscHashes.begin(), newCscHashes.end());
                // New Small Wheel
                data.stgcTrack.insert(newsTgcHashes.begin(), newsTgcHashes.end());
                data.mmTrack.insert(newMMHashes.begin(), newMMHashes.end());
            }
            return refittedTrack;
        }
        return nullptr;
    }

collectCrossedChambers()

void MuonSegmentRegionRecoveryTool::collectCrossedChambers ( const EventContext &  ctx, const Trk::Track &  track, MuonSegmentRegionRecoveryTool::MuonData &  data  ) const

private

methods used by recover

Definition at line 219 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                                     {
        ATH_MSG_VERBOSE(" Collecting all crossed chambers");
 
        const Trk::TrackStates* states = track.trackStateOnSurfaces();
        if (!states) {
            ATH_MSG_WARNING(" track without states, cannot perform cleaning ");
            return;
        }
 
        std::set<MuonStationIndex::StIndex> stations;
        double etamin{1e9}, etamax{-1e9}, phimin{1e9}, phimax{-1e9};
        // loop over TSOSs
        Trk::TrackStates::const_iterator tsit = states->begin();
        Trk::TrackStates::const_iterator tsit_end = states->end();
 
        for (; tsit != tsit_end; ++tsit) {
            const Trk::TrackParameters* pars = (*tsit)->trackParameters();
            if (!pars) continue;
 
            double rpos = pars->position().perp();
            double zpos = std::abs(pars->position().z());
            if (rpos < 2500 && zpos < 4000) continue;
            double eta = pars->position().eta();
            double phi = pars->position().phi();
            if (msgLvl(MSG::DEBUG)) {
                msg() << "All State parameters: eta: " << eta << " ,phi: " << phi << " pos r " << rpos << " z " << zpos;
                if (pars->covariance()) msg() << MSG::DEBUG << " extrapolation error " << Amg::error(*pars->covariance(), Trk::locX);
                msg() << endmsg;
            }
 
            // check whether state is a measurement
            const Trk::MeasurementBase* meas = (*tsit)->measurementOnTrack();
            if (!meas) continue;
 
            Identifier id = m_edmHelperSvc->getIdentifier(*meas);
            bool pseudo = !id.is_valid();
 
            if (pseudo || !m_idHelperSvc->mdtIdHelper().is_muon(id)) continue;
 
            if (eta > etamax) etamax = eta;
            if (eta < etamin) etamin = eta;
            if (phi > phimax) phimax = phi;
            if (phi < phimin) phimin = phi;
            if (msgLvl(MSG::DEBUG)) {
                msg() << "Selected State parameters: eta: " << eta << " ,phi: " << phi << " pos r " << rpos << " z " << zpos;
                if (pars->covariance()) msg() << MSG::DEBUG << " extrapolation error " << Amg::error(*pars->covariance(), Trk::locX);
                msg() << endmsg;
            }
 
            MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(id);
            if (stations.count(stIndex)) continue;
            stations.insert(stIndex);
 
            // At each station launch the Reg Sel and stuff the Id hashes in a vector
        }
        etamin -= m_deta;
        etamax += m_deta;
        phimin -= m_dphi;
        phimax += m_dphi;
 
        ATH_MSG_DEBUG("Eta range: " << etamin << " " << etamax << " Phi range " << phimin << " " << phimax);
        if (etamin > etamax) {  // something went wrong with the fit and no hits were selected in the loop
            ATH_MSG_DEBUG("no hits selected, nothing further will be done");
            return;
        }
 
        RoiDescriptor roi(etamin, etamax, phimin, phimax);
 
        if (m_idHelperSvc->hasMDT())  addHashes( ctx, MDT, roi, data.mdt, data.mdtTrack);
        if (m_idHelperSvc->hasRPC())  addHashes( ctx, RPC, roi, data.rpc, data.rpcTrack);
        if (m_idHelperSvc->hasTGC())  addHashes( ctx, TGC, roi, data.tgc, data.tgcTrack);
        if (m_regsel_csc.isEnabled()) addHashes( ctx, CSC, roi, data.csc, data.cscTrack);
        if (m_recoverSTGC) addHashes( ctx, STGC, roi, data.stgc, data.stgcTrack);
        if (m_recoverMM) addHashes( ctx, MM, roi, data.mm, data.mmTrack);
 
        std::set<IdentifierHash>::iterator hsit = data.mdt.begin();
        std::set<IdentifierHash>::iterator hsit_end = data.mdt.end();
        for (; hsit != hsit_end; ++hsit) {
            Identifier chId;
            IdContext otCont = m_idHelperSvc->mdtIdHelper().module_context();
            m_idHelperSvc->mdtIdHelper().get_id(*hsit, chId, &otCont);
            MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
            data.mdtPerStation[chIndex].insert(*hsit);
            ATH_MSG_VERBOSE(" chamberlayer  " << MuonStationIndex::chName(chIndex) << "  " << m_idHelperSvc->toStringChamber(chId));
        }
        hsit = data.csc.begin();
        hsit_end = data.csc.end();
        for (; hsit != hsit_end; ++hsit) {
            Identifier chId;
            IdContext otCont = m_idHelperSvc->cscIdHelper().module_context();
            m_idHelperSvc->cscIdHelper().get_id(*hsit, chId, &otCont);
            chId = m_idHelperSvc->chamberId(chId);
            MuonStationIndex::ChIndex chIndex = m_idHelperSvc->chamberIndex(chId);
            ATH_MSG_VERBOSE(" chamberlayer  " << MuonStationIndex::chName(chIndex) << "  " << m_idHelperSvc->toString(chId));
        }
    }

createHoleTSOSsForClusterChamber()

void MuonSegmentRegionRecoveryTool::createHoleTSOSsForClusterChamber ( const Identifier &  detElId, const EventContext &  ctx, const Trk::TrackParameters &  pars, std::set< Identifier > &  layIds, std::vector< std::unique_ptr< const Trk::TrackStateOnSurface > > &  states  ) const

overridevirtual

Implements Muon::IMuonHoleRecoveryTool.

Definition at line 89 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                              {
        m_chamberHoleRecoveryTool->createHoleTSOSsForClusterChamber(detElId, ctx, pars, layIds, states);
    }

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

fillOnTrackChambers()

void MuonSegmentRegionRecoveryTool::fillOnTrackChambers ( const Trk::Track &  theTrack, MuonData &  data  ) const

private

Definition at line 317 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                                                       {
        ATH_MSG_VERBOSE(" making set of already-on-track chambers");
 
        // Collect track PRD's
        const Trk::TrackStates* states = track.trackStateOnSurfaces();
        if (!states) {
            ATH_MSG_WARNING(" track without states, cannot perform cleaning ");
            return;
        }
 
        std::set<MuonStationIndex::StIndex> stations;
 
        // loop over TSOSs
        Trk::TrackStates::const_iterator tsit = states->begin();
        Trk::TrackStates::const_iterator tsit_end = states->end();
        for (; tsit != tsit_end; ++tsit) {
            const Trk::TrackParameters* pars = (*tsit)->trackParameters();
            if (!pars) continue;
 
            // check whether state is a measurement
            const Trk::MeasurementBase* meas = (*tsit)->measurementOnTrack();
            if (!meas) continue;
 
            const Muon::MdtDriftCircleOnTrack* mdt = dynamic_cast<const Muon::MdtDriftCircleOnTrack*>(meas);
            if (mdt && !data.mdtTrack.count(mdt->collectionHash())) {
                data.mdtTrack.insert(mdt->collectionHash());
                ATH_MSG_VERBOSE("Adding " << m_idHelperSvc->toStringChamber(mdt->identify()) << " hash " << mdt->collectionHash());
                continue;
            }
 
            const MuonClusterOnTrack* clus = nullptr;
            const CompetingMuonClustersOnTrack* compRot = dynamic_cast<const CompetingMuonClustersOnTrack*>(meas);
            if (compRot) {
                clus = &compRot->rioOnTrack(0);
            } else {
                clus = dynamic_cast<const MuonClusterOnTrack*>(meas);
            }
            if (!clus) continue;
 
            const RpcClusterOnTrack* rpc = dynamic_cast<const RpcClusterOnTrack*>(clus);
            if (rpc && !data.rpcTrack.count(rpc->collectionHash())) {
                data.rpcTrack.insert(rpc->collectionHash());
                ATH_MSG_VERBOSE("Adding " << m_idHelperSvc->toStringChamber(clus->identify()) << " hash " << clus->collectionHash());
                continue;
            }
            const TgcClusterOnTrack* tgc = dynamic_cast<const TgcClusterOnTrack*>(clus);
            if (tgc && !data.tgcTrack.count(tgc->collectionHash())) {
                data.tgcTrack.insert(tgc->collectionHash());
                ATH_MSG_VERBOSE("Adding " << m_idHelperSvc->toStringChamber(clus->identify()) << " hash " << clus->collectionHash());
                continue;
            }
            const CscClusterOnTrack* csc = dynamic_cast<const CscClusterOnTrack*>(clus);
            if (csc && !data.cscTrack.count(csc->collectionHash())) {
                data.cscTrack.insert(csc->collectionHash());
                ATH_MSG_VERBOSE("Adding " << m_idHelperSvc->toStringChamber(clus->identify()) << " hash " << clus->collectionHash());
                continue;
            }
            // New Small Wheel
            const sTgcClusterOnTrack* stgc = dynamic_cast<const sTgcClusterOnTrack*>(clus);
            if (stgc && !data.stgcTrack.count(stgc->collectionHash())) {
                data.stgcTrack.insert(stgc->collectionHash());
                ATH_MSG_VERBOSE("Adding " << m_idHelperSvc->toStringChamber(clus->identify()) << " hash " << clus->collectionHash());
                continue;
            }
            const MMClusterOnTrack* mm = dynamic_cast<const MMClusterOnTrack*>(clus);
            if (mm && !data.mmTrack.count(mm->collectionHash())) {
                data.mmTrack.insert(mm->collectionHash());
                ATH_MSG_VERBOSE("Adding " << m_idHelperSvc->toStringChamber(clus->identify()) << " hash " << clus->collectionHash());
                continue;
            }
        }
    }

findHoles()

std::unique_ptr< Trk::Track > MuonSegmentRegionRecoveryTool::findHoles ( const EventContext &  ctx, const Trk::Track &  track, MuonData &  data  ) const

private

Definition at line 390 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                                               {
        const Trk::TrackStates* oldStates = track.trackStateOnSurfaces();
        if (!oldStates) {
            ATH_MSG_WARNING(" track without states, cannot perform mdt hole search ");
            return nullptr;
        }
 
        SG::ReadCondHandle<Muon::MuonIntersectGeoData> InterSectSvc{m_chamberGeoKey,ctx};
        if (!InterSectSvc.isValid())   {
            ATH_MSG_ERROR("Failed to retrieve chamber intersection service");
            return nullptr;
        }
        const MuonGM::MuonDetectorManager* MuonDetMgr = InterSectSvc->detMgr();
 
        std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> states;
        unsigned int nholes = 0;
        std::set<Identifier> chambersInSearch;
        for (const IdentifierHash& ith : data.mdt) {
            // ignore hashes already on track
            if (data.mdtTrack.count(ith)) {
                ATH_MSG_VERBOSE("Chamber already on track " << ith);
                continue;
            }
            Identifier chId;
            IdContext otCont = m_idHelperSvc->mdtIdHelper().module_context();
            m_idHelperSvc->mdtIdHelper().get_id(ith, chId, &otCont);
 
            // ignore chambers that already had a hole search
            if (chambersInSearch.count(chId)) {
                ATH_MSG_VERBOSE("Chamber already on track " << ith << " " << m_idHelperSvc->toStringChamber(chId));
                continue;
            }
            const MuonGM::MdtReadoutElement* detEl = MuonDetMgr->getMdtReadoutElement(chId);
            if (!detEl) {
                ATH_MSG_WARNING("Found no detector element for " << ith);
                continue;
            }
            std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *detEl, true)};
            if (!exPars) {
                ATH_MSG_DEBUG("Did not reach " << m_idHelperSvc->toStringChamber(chId) << " hash " << ith);
                continue;
            }
            ATH_MSG_DEBUG("Reached " << m_idHelperSvc->toStringChamber(chId) << " hash " << ith);
 
            // calculate crossed tubes
            const MuonStationIntersect intersect = InterSectSvc->tubesCrossedByTrack(chId, exPars->position(), exPars->momentum().unit());
 
            // clear hole vector
            for (unsigned int ii = 0; ii < intersect.tubeIntersects().size(); ++ii) {
                const MuonTubeIntersect& tint = intersect.tubeIntersects()[ii];
                const Identifier& id = tint.tubeId;
                const MuonGM::MdtReadoutElement* detElLoc = MuonDetMgr->getMdtReadoutElement(id);
 
                // addition skip for cases when the track crosses inbetween two chambers
                if (data.mdtTrack.count(detElLoc->identifyHash())) continue;
 
                Identifier ch = m_idHelperSvc->chamberId(id);
                chambersInSearch.insert(ch);
 
                const Trk::Surface& surf = detElLoc->surface(id);
                std::unique_ptr<Trk::TrackParameters> tubePars{
                    m_extrapolator->extrapolateDirectly(ctx, *exPars, surf, Trk::anyDirection, false, Trk::muon)};
                if (!tubePars) {
                    ATH_MSG_WARNING("Failed to extrapolate to tube " << m_idHelperSvc->toString(id));
                    continue;
                }
                int lay = m_idHelperSvc->mdtIdHelper().tubeLayer(id);
                int tube = m_idHelperSvc->mdtIdHelper().tube(id);
                double tubeLen = detElLoc->getActiveTubeLength(lay, tube);
                double distEdge = std::abs(tubePars->parameters()[Trk::locZ]) - 0.5 * tubeLen;
                double pullEdge = tubePars->covariance() && Amg::hasPositiveDiagElems(*tubePars->covariance())
                                      ? distEdge / Amg::error(*tubePars->covariance(), Trk::locZ)
                                      : distEdge / 20.;
                std::optional<Amg::Vector2D> locPos = surf.Trk::Surface::globalToLocal(tubePars->position());
 
                bool inBounds = false;
                if (locPos) {
                    // perform bound check do not count holes with 100. mm of bound edge
                    inBounds = surf.bounds().insideLoc2(*locPos, -100.) && std::abs((*locPos)[Trk::locR]) <= detElLoc->innerTubeRadius();
                }
                if (!inBounds) {
                    ATH_MSG_VERBOSE(" discarding hole " << m_idHelperSvc->toString(id) << " dist wire " << tubePars->parameters()[Trk::locR]
                                                        << " outside bounds ");
                    continue;
                }
                ATH_MSG_VERBOSE(" new hole " << m_idHelperSvc->toString(id) << " dist wire " << tubePars->parameters()[Trk::locR]
                                             << " dist tube edge " << distEdge << " pullEdge " << pullEdge);
                ++nholes;
                std::unique_ptr<Trk::TrackStateOnSurface> tsos = MuonTSOSHelper::createHoleTSOS(std::move(tubePars));
                states.emplace_back(std::move(tsos));
            }
            if (!nholes) ATH_MSG_DEBUG("found holes " << nholes);
        }
 
        for (const IdentifierHash& ith : data.csc) {
            // ignore hashes already on track
            if (data.cscTrack.count(ith)) {
                ATH_MSG_VERBOSE("Chamber already on track " << ith);
                continue;
            }
            Identifier chId;
            IdContext otCont = m_idHelperSvc->cscIdHelper().module_context();
            m_idHelperSvc->cscIdHelper().get_id(ith, chId, &otCont);
            chId = m_idHelperSvc->chamberId(chId);
 
            const MuonGM::CscReadoutElement* detEl = MuonDetMgr->getCscReadoutElement(chId);
            if (!detEl) {
                ATH_MSG_WARNING("Found no detector element for " << ith << " " << m_idHelperSvc->toString(chId));
                continue;
            }
 
            std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *detEl, true)};
            if (!exPars) {
                ATH_MSG_DEBUG("Did not reach " << m_idHelperSvc->toStringChamber(chId) << " hash " << ith);
                continue;
            }
            Identifier detElId = m_idHelperSvc->detElId(chId);
            std::set<Identifier> layIds;
            std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> cscstates;
            createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, cscstates);
            ATH_MSG_DEBUG("Reached " << m_idHelperSvc->toString(chId) << " hash " << ith << " holes " << cscstates.size());
 
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& cscit : cscstates) {
                ATH_MSG_VERBOSE("Adding " << cscit.get());
                states.emplace_back(std::move(cscit));
            }
        }
        for (const IdentifierHash& ith : data.tgc) {
            // ignore hashes already on track
            if (data.tgcTrack.count(ith)) {
                ATH_MSG_VERBOSE("Chamber already on track " << ith);
                continue;
            }
            Identifier chId;
            IdContext otCont = m_idHelperSvc->tgcIdHelper().module_context();
            m_idHelperSvc->tgcIdHelper().get_id(ith, chId, &otCont);
            chId = m_idHelperSvc->chamberId(chId);
 
            const MuonGM::TgcReadoutElement* detEl = MuonDetMgr->getTgcReadoutElement(chId);
            if (!detEl) {
                ATH_MSG_WARNING("Found no detector element for " << ith << " " << m_idHelperSvc->toString(chId));
                continue;
            }
 
            std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *detEl, true)};
            if (!exPars) {
                ATH_MSG_DEBUG("Did not reach " << m_idHelperSvc->toStringChamber(chId) << " hash " << ith);
                continue;
            }
            Identifier detElId = m_idHelperSvc->detElId(chId);
            std::set<Identifier> layIds;
            std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> tgcstates;
            createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, tgcstates);
            ATH_MSG_DEBUG("Reached " << m_idHelperSvc->toString(chId) << " hash " << ith << " holes " << tgcstates.size());
 
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& tgcit : tgcstates) {
                ATH_MSG_VERBOSE("Adding " << tgcit.get());
                states.emplace_back(std::move(tgcit));
            }
        }
 
        for (const IdentifierHash& ith : data.rpc) {
            // ignore hashes already on track
            if (data.rpcTrack.count(ith)) {
                ATH_MSG_VERBOSE("Chamber already on track " << ith);
                continue;
            }
            Identifier chId;
            IdContext otCont = m_idHelperSvc->rpcIdHelper().module_context();
            m_idHelperSvc->rpcIdHelper().get_id(ith, chId, &otCont);
            chId = m_idHelperSvc->chamberId(chId);
 
            const MuonGM::RpcReadoutElement* detEl = MuonDetMgr->getRpcReadoutElement(chId);
            if (!detEl) {
                ATH_MSG_WARNING("Found no detector element for " << ith << " " << m_idHelperSvc->toString(chId));
                continue;
            }
 
            std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *detEl, true)};
            if (!exPars) {
                ATH_MSG_DEBUG("Did not reach " << m_idHelperSvc->toStringChamber(chId) << " hash " << ith);
                continue;
            }
            Identifier detElId = m_idHelperSvc->detElId(chId);
            std::set<Identifier> layIds;
            std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> rpcstates;
            createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, rpcstates);
            ATH_MSG_DEBUG("Reached " << m_idHelperSvc->toString(chId) << " hash " << ith << " holes " << rpcstates.size());
 
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& rpcit : rpcstates) {
                ATH_MSG_VERBOSE("Adding " << rpcit.get());
                states.emplace_back(std::move(rpcit));
            }
        }
 
        // New Small Wheel
        // sTGC
        for (const IdentifierHash& ith : data.stgc) {
            // ignore hashes already on track
            if (data.stgcTrack.count(ith)) {
                ATH_MSG_VERBOSE("Chamber already on track " << ith);
                continue;
            }
            Identifier chId;
            IdContext otCont = m_idHelperSvc->stgcIdHelper().module_context();
            m_idHelperSvc->stgcIdHelper().get_id(ith, chId, &otCont);
 
            if (!chId.is_valid()) {
                ATH_MSG_VERBOSE("invalid chId for stgc data " << ith);
                continue;
            }
 
            chId = m_idHelperSvc->chamberId(chId);
 
            const MuonGM::sTgcReadoutElement* detEl = MuonDetMgr->getsTgcReadoutElement(chId);
            if (!detEl) {
                ATH_MSG_WARNING("Found no detector element for " << ith << " " << m_idHelperSvc->toString(chId));
                continue;
            }
 
            std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *detEl, true)};
            if (!exPars) {
                ATH_MSG_DEBUG("Did not reach " << m_idHelperSvc->toStringChamber(chId) << " hash " << ith);
                continue;
            }
            Identifier detElId = m_idHelperSvc->detElId(chId);
            std::set<Identifier> layIds;
            std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> stgcstates;
            createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, stgcstates);
            ATH_MSG_DEBUG("Reached " << m_idHelperSvc->toString(chId) << " hash " << ith << " holes " << stgcstates.size());
 
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& stgcit : stgcstates) {
                ATH_MSG_VERBOSE("Adding " << stgcit.get());
                states.push_back(std::move(stgcit));
            }
        }
 
        // MM
        for (const IdentifierHash& ith : data.mm) {
            // ignore hashes already on track
            if (data.mmTrack.count(ith)) {
                ATH_MSG_VERBOSE("Chamber already on track " << ith);
                continue;
            }
            Identifier chId;
            IdContext otCont = m_idHelperSvc->mmIdHelper().module_context();
            m_idHelperSvc->mmIdHelper().get_id(ith, chId, &otCont);
 
            if (!chId.is_valid()) {
                ATH_MSG_VERBOSE("invalid chId for mm data " << ith);
                continue;
            }
 
            chId = m_idHelperSvc->chamberId(chId);
 
            const MuonGM::MMReadoutElement* detEl = MuonDetMgr->getMMReadoutElement(chId);
            if (!detEl) {
                ATH_MSG_WARNING("Found no detector element for " << ith << " " << m_idHelperSvc->toString(chId));
                continue;
            }
 
            std::unique_ptr<const Trk::TrackParameters> exPars{reachableDetEl(ctx, track, *detEl, true)};
            if (!exPars) {
                ATH_MSG_DEBUG("Did not reach " << m_idHelperSvc->toStringChamber(chId) << " hash " << ith);
                continue;
            }
            Identifier detElId = m_idHelperSvc->detElId(chId);
            std::set<Identifier> layIds;
            std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> mmstates;
            createHoleTSOSsForClusterChamber(detElId, ctx, *exPars, layIds, mmstates);
            ATH_MSG_DEBUG("Reached " << m_idHelperSvc->toString(chId) << " hash " << ith << " holes " << mmstates.size());
 
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& mmit : mmstates) {
                ATH_MSG_VERBOSE("Adding " << mmit.get());
                states.emplace_back(std::move(mmit));
            }
        }
        if (!states.empty()) {
            // states were added, create a new track
            auto trackStateOnSurfaces = std::make_unique<Trk::TrackStates>();
            trackStateOnSurfaces->reserve(oldStates->size() + states.size());
 
            std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>> toBeSorted;
            toBeSorted.reserve(oldStates->size() + states.size());
 
            for (const Trk::TrackStateOnSurface* sit : *oldStates) toBeSorted.emplace_back(sit->clone());
 
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& stit : states) toBeSorted.emplace_back(std::move(stit));
 
            std::stable_sort(toBeSorted.begin(), toBeSorted.end(), SortTSOSs(&*m_edmHelperSvc, &*m_idHelperSvc));
 
            for (std::unique_ptr<const Trk::TrackStateOnSurface>& sorted : toBeSorted) { trackStateOnSurfaces->push_back(sorted.release()); }
            std::unique_ptr<Trk::Track> trackWithHoles = std::make_unique<Trk::Track>(
                track.info(), std::move(trackStateOnSurfaces), track.fitQuality() ? track.fitQuality()->uniqueClone() : nullptr);
            // generate a track summary for this track
            if (m_trackSummaryTool.isEnabled()) { m_trackSummaryTool->computeAndReplaceTrackSummary(ctx, *trackWithHoles, false); }
            ATH_MSG_DEBUG("Track with holes " << m_printer->print(*trackWithHoles) << std::endl
                                              << m_printer->printStations(*trackWithHoles));
            return trackWithHoles;
        }
        return nullptr;
    }

initialize()

StatusCode MuonSegmentRegionRecoveryTool::initialize ( )

overridevirtual

AlgTool initialize.

Old chamber technologies

Definition at line 53 of file MuonSegmentRegionRecoveryTool.cxx.

                                                         {
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_chamberGeoKey.initialize());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_seededSegmentFinder.retrieve());
 
        if (!m_trackSegmentMatchingTool.empty()) {
            ATH_CHECK(m_trackSegmentMatchingTool.retrieve());
            ATH_MSG_INFO("Using matching tool " << m_trackSegmentMatchingTool);
        } else {
            ATH_MSG_DEBUG("No matching tool selected ");
        }
 
        ATH_CHECK(m_chamberHoleRecoveryTool.retrieve());
        ATH_CHECK(m_extrapolator.retrieve());
        if (m_onlyEO) {
            ATH_CHECK(m_fitter.retrieve());
            m_builder.disable();
        } else {
            m_fitter.disable();
            ATH_CHECK(m_builder.retrieve());
        }
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_hitSummaryTool.retrieve());
        ATH_CHECK(m_regsel_mdt.retrieve());
        ATH_CHECK(m_regsel_rpc.retrieve());
        ATH_CHECK(m_regsel_tgc.retrieve());
        m_recoverSTGC =  m_recoverSTGC && !m_regsel_stgc.empty();
        m_recoverMM =  m_recoverMM && !m_regsel_mm.empty();
        ATH_CHECK(m_regsel_csc.retrieve(DisableTool{m_regsel_csc.empty()}));
        ATH_CHECK(m_regsel_stgc.retrieve(DisableTool{!m_recoverSTGC}));
        ATH_CHECK(m_regsel_mm.retrieve(DisableTool{!m_recoverMM}));
        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::IMuonHoleRecoveryTool::interfaceID ( )

inlinestaticinherited

access to tool interface

Definition at line 23 of file IMuonHoleRecoveryTool.h.

                                                {
            static const InterfaceID IID_IMuonHoleRecoveryTool("Muon::IMuonHoleRecoveryTool", 1, 0);
            return IID_IMuonHoleRecoveryTool;
        }

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.

reachableDetEl()

std::unique_ptr< const Trk::TrackParameters > MuonSegmentRegionRecoveryTool::reachableDetEl ( const EventContext &  ctx, const Trk::Track &  track, const Trk::TrkDetElementBase &  detEl, bool  smallerBounds = false  ) const

private

Definition at line 942 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                                                                        {
        ATH_MSG_VERBOSE("reachableDetEl() " << m_idHelperSvc->toStringDetEl(detEl.identify()) << " at " << detEl.center());
        std::unique_ptr<const Trk::TrackParameters> exPars;
        std::unique_ptr<const Trk::TrackParameters> closest{MuonGetClosestParameters::closestParameters(track, detEl.surface(), true)};
        if (closest) {
            ATH_MSG_VERBOSE("Extrapolating from closest point:\n" << m_printer->print(*closest));
            exPars = m_extrapolator->extrapolateDirectly(ctx, *closest, detEl.surface(), Trk::anyDirection, false, Trk::muon);
 
        } else {
            ATH_MSG_VERBOSE("Extrapolating from track (no closest point found):\n" << m_printer->print(track));
            exPars = m_extrapolator->extrapolateTrack(ctx, track, detEl.surface(), Trk::anyDirection, false, Trk::muon);
        }
        if (!exPars) {
            ATH_MSG_DEBUG("Extrapolation did not succeed");
            return nullptr;
        }
        Amg::Vector2D locPos(exPars->parameters()[Trk::locX], exPars->parameters()[Trk::locY]);
 
        double tolx = 100.;  // positive -> large surface
        double toly = 100.;  // positive -> large surface
        const AmgSymMatrix(5)* errMat = exPars->covariance();
        if (errMat) {
            ATH_MSG_VERBOSE("Extrapolated local Position & Error matrix\n:" << locPos << "\n" << Amg::toString(*errMat));
            // MJW check validity of errors before using them (fix for bug #82920)
            double covx = (*errMat)(Trk::locX, Trk::locX);
            double covy = (*errMat)(Trk::locY, Trk::locY);
            if (covx > 0.0 && covy > 0.0) {
                tolx = 3 * covx;
                toly = 3 * covy;
            }
        }
 
        // in case we are looking for holes, only ignore stations if we are within 100 mm of the chamber edge
        // all other holes are counted even if the extrapolation errors are large.
        if (smallerBounds) {
            if (tolx > 10.) tolx = 10.;
            if (toly > 10.) toly = 10.;
            // refer sign to check 'inside' the bounds
            tolx *= -1.;
            toly *= -1.;
        }
        bool inbounds = detEl.surface().insideBounds(locPos, tolx, toly);
        if (msgLvl(MSG::DEBUG)) {
            std::ostringstream parsType;
            parsType << "pos=(" << locPos[Trk::locX] << "," << locPos[Trk::locY] << ")";
            if (errMat) { parsType << "  exError=(" << Amg::error(*errMat, Trk::locX) << "," << Amg::error(*errMat, Trk::locY) << ")"; }
            parsType << "  tolerance=(" << tolx << "," << toly << ")";
            if (inbounds)
                parsType << " => inbounds";
            else
                parsType << " => outbounds";
            ATH_MSG_DEBUG(" " << m_idHelperSvc->toStringChamber(detEl.identify()) << " pars  " << parsType.str());
        }
        if (!inbounds) { return nullptr; }
        return exPars;
    }

recover()

std::unique_ptr< Trk::Track > MuonSegmentRegionRecoveryTool::recover ( const Trk::Track &  track, const EventContext &  ctx  ) const

overridevirtual

returns a new track with segments recovered using RegionSelector

Algorithmic part Strategy: 1) Extrapolate back to MS entry record 2) Collect hashes of chambers close to where the track passed 3) Compare collected Hashes with the ones already on track 4) Recover segments on the missing chambers by launching the SeededSegmentFinder.

2) Collect hashes of chambers close to where the track passed 2a) Extrapolate forward to the next station 2b) Launch selector to get IDHashes 2c) push_back hashes for this station into a set 2d) stop where outer layers are 2e) the outcome of all of this is a std::set of collected hashes (some are already on the track, no need to recover)

Implements Muon::IMuonHoleRecoveryTool.

Definition at line 102 of file MuonSegmentRegionRecoveryTool.cxx.

                                                                                                                     {
        // Welcome into the implementation of the recovery method
        ATH_MSG_VERBOSE(" Entering segment recovery method " << m_printer->print(track) << std::endl << m_printer->printStations(track));
 
        // First run the MuonChamberHoleRecoveryTool on the input track
        std::unique_ptr<Trk::Track> chRecTrack(m_chamberHoleRecoveryTool->recover(track, ctx));
        if (!chRecTrack) {
            ATH_MSG_DEBUG(" MuonChamberHoleRecoveryTool failed to create a new track "
                          << " Returning input (unrecovered) track ");
            return std::make_unique<Trk::Track>(track);
        }
        ATH_MSG_VERBOSE(" After chamber hole recovery " << m_printer->print(*chRecTrack) << std::endl
                                                        << m_printer->printStations(*chRecTrack));
        // only run this on single station EM tracks
        if (m_onlyEO) {
            // should be a sl track
            // using release until parent tools use unique_ptr
            if (!m_edmHelperSvc->isSLTrack(*chRecTrack)) return chRecTrack;
 
            // get hit summary
            IMuonHitSummaryTool::CompactSummary hitSummary = m_hitSummaryTool->summary(*chRecTrack);
            // should be single station
            // using release until parent tools use unique_ptr
            if (hitSummary.stationLayers.size() != 1 || !hitSummary.stationLayers.count(MuonStationIndex::EM)) return chRecTrack;
            ATH_MSG_DEBUG("Single station track, checking for EO hits");
        }
 
        // 1) Extrapolate back to MS entry record
        //     const Trk::TrackParameters* msEntryPars = goToMSEntryRecord( *chRecTrack );
        //     if(!msEntryPars) return chRecTrack;
 
        MuonData muonData;
        // extract the hashes already on track
        fillOnTrackChambers(*chRecTrack, muonData);
 
        // collect the hashes not in track close to the track
        collectCrossedChambers( ctx, *chRecTrack, muonData);
 
        // 3b) compare the two std::sets and make a final std::set of not-yet-on-track Hashes
        std::unique_ptr<Trk::Track> triggerRecTrack = addMissingChambers(ctx, *chRecTrack, muonData, false);
        if (triggerRecTrack) chRecTrack.swap(triggerRecTrack);
 
        std::unique_ptr<Trk::Track> mdtRecTrack = addMissingChambers(ctx, *chRecTrack, muonData, true);
        if (mdtRecTrack) chRecTrack.swap(mdtRecTrack);
 
        std::unique_ptr<Trk::Track> mdtRecTrackWithHoles = findHoles(ctx, *chRecTrack, muonData);
        if (mdtRecTrackWithHoles) chRecTrack.swap(mdtRecTrackWithHoles);
 
        // recovered track, success!
        // use release until calling tools also use unique_ptr
        return chRecTrack;
    }

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_builder

ToolHandle<Rec::ICombinedMuonTrackFitter> Muon::MuonSegmentRegionRecoveryTool::m_builder {this, "Builder", ""}

private

Definition at line 140 of file MuonSegmentRegionRecoveryTool.h.

m_chamberGeoKey

SG::ReadCondHandleKey<Muon::MuonIntersectGeoData> Muon::MuonSegmentRegionRecoveryTool::m_chamberGeoKey {this, "ChamberGeoKey", "MuonStationIntersects", "Pointer to hole search service"}

private

Definition at line 152 of file MuonSegmentRegionRecoveryTool.h.

m_chamberHoleRecoveryTool

ToolHandle<MuonChamberHoleRecoveryTool> Muon::MuonSegmentRegionRecoveryTool::m_chamberHoleRecoveryTool {this, "ChamberHoleRecoveryTool", "", "hit-based hole search"}

private

Definition at line 138 of file MuonSegmentRegionRecoveryTool.h.

m_deta

Gaudi::Property<double> Muon::MuonSegmentRegionRecoveryTool::m_deta {this, "DeltaEtaRegion", 0.05}

private

Definition at line 155 of file MuonSegmentRegionRecoveryTool.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_dphi

Gaudi::Property<double> Muon::MuonSegmentRegionRecoveryTool::m_dphi {this, "DeltaPhiRegion", 0.1}

private

Definition at line 156 of file MuonSegmentRegionRecoveryTool.h.

m_edmHelperSvc

ServiceHandle<IMuonEDMHelperSvc> Muon::MuonSegmentRegionRecoveryTool::m_edmHelperSvc

private

Initial value:

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

Definition at line 128 of file MuonSegmentRegionRecoveryTool.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_excludeEES

Gaudi::Property<bool> Muon::MuonSegmentRegionRecoveryTool::m_excludeEES {this, "ExcludeEES", true}

private

Definition at line 157 of file MuonSegmentRegionRecoveryTool.h.

m_extrapolator

ToolHandle<Trk::IExtrapolator> Muon::MuonSegmentRegionRecoveryTool::m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/MuonExtrapolator"}

private

Definition at line 139 of file MuonSegmentRegionRecoveryTool.h.

m_fitter

ToolHandle<Trk::ITrackFitter> Muon::MuonSegmentRegionRecoveryTool::m_fitter {this, "Fitter", "Trk::GlobalChi2Fitter/MCTBSLFitter"}

private

Definition at line 141 of file MuonSegmentRegionRecoveryTool.h.

m_hitSummaryTool

ToolHandle<IMuonHitSummaryTool> Muon::MuonSegmentRegionRecoveryTool::m_hitSummaryTool {this, "HitSummaryTool", "Muon::MuonHitSummaryTool/MuonHitSummaryTool"}

private

Definition at line 142 of file MuonSegmentRegionRecoveryTool.h.

m_idHelperSvc

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

private

Definition at line 131 of file MuonSegmentRegionRecoveryTool.h.

m_onlyEO

Gaudi::Property<bool> Muon::MuonSegmentRegionRecoveryTool::m_onlyEO {this, "OnlyEO", false}

private

Definition at line 158 of file MuonSegmentRegionRecoveryTool.h.

m_printer

PublicToolHandle<MuonEDMPrinterTool> Muon::MuonSegmentRegionRecoveryTool::m_printer {this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

private

Definition at line 149 of file MuonSegmentRegionRecoveryTool.h.

m_recoverMM

Gaudi::Property<bool> Muon::MuonSegmentRegionRecoveryTool::m_recoverMM {this, "RecoverMM", true, "Pick up dropped micromega chambers"}

private

Definition at line 161 of file MuonSegmentRegionRecoveryTool.h.

m_recoverSTGC

Gaudi::Property<bool> Muon::MuonSegmentRegionRecoveryTool::m_recoverSTGC {this, "RecoverSTGC", true, "Pick up dropped sTGC chambers"}

private

Definition at line 162 of file MuonSegmentRegionRecoveryTool.h.

m_regsel_csc

ToolHandle<IRegSelTool> Muon::MuonSegmentRegionRecoveryTool::m_regsel_csc {this, "CSCRegionSelector", "RegSelTool/RegSelTool_CSC"}

private

Definition at line 144 of file MuonSegmentRegionRecoveryTool.h.

m_regsel_mdt

ToolHandle<IRegSelTool> Muon::MuonSegmentRegionRecoveryTool::m_regsel_mdt {this, "MDTRegionSelector", "RegSelTool/RegSelTool_MDT"}

private

Definition at line 143 of file MuonSegmentRegionRecoveryTool.h.

m_regsel_mm

ToolHandle<IRegSelTool> Muon::MuonSegmentRegionRecoveryTool::m_regsel_mm {this, "MMRegionSelector", "RegSelTool/RegSelTool_MM"}

private

Definition at line 148 of file MuonSegmentRegionRecoveryTool.h.

m_regsel_rpc

ToolHandle<IRegSelTool> Muon::MuonSegmentRegionRecoveryTool::m_regsel_rpc {this, "RPCRegionSelector", "RegSelTool/RegSelTool_RPC"}

private

Definition at line 145 of file MuonSegmentRegionRecoveryTool.h.

m_regsel_stgc

ToolHandle<IRegSelTool> Muon::MuonSegmentRegionRecoveryTool::m_regsel_stgc {this, "STGCRegionSelector", "RegSelTool/RegSelTool_STGC"}

private

Definition at line 147 of file MuonSegmentRegionRecoveryTool.h.

m_regsel_tgc

ToolHandle<IRegSelTool> Muon::MuonSegmentRegionRecoveryTool::m_regsel_tgc {this, "TGCRegionSelector", "RegSelTool/RegSelTool_TGC"}

private

Definition at line 146 of file MuonSegmentRegionRecoveryTool.h.

m_seededSegmentFinder

ToolHandle<IMuonSeededSegmentFinder> Muon::MuonSegmentRegionRecoveryTool::m_seededSegmentFinder

private

Initial value:

{this, "SeededSegmentFinder",
                                                                   "Muon::MuonSeededSegmentFinder/MuonSeededSegmentFinder"}

Definition at line 133 of file MuonSegmentRegionRecoveryTool.h.

m_trackSegmentMatchingTool

ToolHandle<IMuonTrackSegmentMatchingTool> Muon::MuonSegmentRegionRecoveryTool::m_trackSegmentMatchingTool

private

Initial value:

{this, "TrackSegmentMatchingTool",
                                                                             "Muon::MooCandidateMatchingTool/MooCandidateMatchingTool"}

Definition at line 135 of file MuonSegmentRegionRecoveryTool.h.

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> Muon::MuonSegmentRegionRecoveryTool::m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}

private

Definition at line 150 of file MuonSegmentRegionRecoveryTool.h.

m_useFitterOutlierLogic

Gaudi::Property<bool> Muon::MuonSegmentRegionRecoveryTool::m_useFitterOutlierLogic {this, "UseFitterOutlierLogic", true}

private

Definition at line 159 of file MuonSegmentRegionRecoveryTool.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:

• MuonSegmentRegionRecoveryTool.h
• MuonSegmentRegionRecoveryTool.cxx