Muon::MuonChamberHoleRecoveryTool Class Reference

tool to select tracks More...

#include <MuonChamberHoleRecoveryTool.h>

Inheritance diagram for Muon::MuonChamberHoleRecoveryTool:

Collaboration diagram for Muon::MuonChamberHoleRecoveryTool:

Classes
struct	RecoveryState

Public Types
using	NewTrackStates = std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>>

Public Member Functions
	MuonChamberHoleRecoveryTool (const std::string &, const std::string &, const IInterface *)
virtual	~MuonChamberHoleRecoveryTool ()=default
StatusCode	initialize () override
std::unique_ptr< Trk::Track >	recover (const Trk::Track &track, const EventContext &ctx) const override
	returns a new track with holes recovered
void	createHoleTSOSsForClusterChamber (const Identifier &detElId, const EventContext &ctx, const Trk::TrackParameters &pars, std::set< Identifier > &layIds, NewTrackStates &states) const override
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
virtual 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 =0

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	access to tool interface

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	getNextMuonMeasurement (RecoveryState &trkRecov, RecoveryState::CopyTarget target) const
	Increments the internal iterator of the RecoveryState until the next muon measurement on track is found Measurements inside the MS volume or any scatterer are copied automatically copied onto the target vector.
void	recoverHitsInChamber (const EventContext &ctx, RecoveryState &trkRecov) const
	Loops over all muon hits in a muon chamber and tries to find missed ones by checking each tracking layer for hits.
std::set< Identifier >	holesInMdtChamber (const EventContext &ctx, const Amg::Vector3D &position, const Amg::Vector3D &direction, const Identifier &chId, const std::set< Identifier > &tubeIds) const
	calculate holes in a given chamber using local straight line extrapolation
void	recoverMdtHits (const EventContext &ctx, const Identifier &chId, const Trk::TrackParameters &pars, NewTrackStates &newStates, std::set< Identifier > &knownLayers) const
void	recoverClusterHits (const EventContext &ctx, const Identifier &chId, const Trk::TrackParameters &chambPars, NewTrackStates &newStates, std::set< Identifier > &knownLayers) const
std::set< Identifier >	layersOnTrkIds (const Trk::Track &track) const
	Returns a set of all layer Identifiers of the associated track hits.
const Trk::TrkDetElementBase *	getDetectorElement (const EventContext &ctx, const Identifier &id) const
	Returns the detector element associated with the muon Identifier.
std::set< Identifier >	getHoleLayerIds (const Identifier &detElId, const std::set< Identifier > &knownLayers) const
	Returns a set of all layer Identifiers (GasGap + channel orientation) in a muon chamber of type X excluding the ones in the knownLayers set.
template<class Prd>
NewTrackStates	recoverChamberClusters (const EventContext &ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd > > &prdKey, const Identifier &chambId, const Trk::TrackParameters &parsInChamb, std::set< Identifier > &knownLayers) const
	Attempts to recover all missing hits in a chamber.
template<class Prd>
std::vector< const Prd * >	loadPrepDataHits (const EventContext &ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd > > &key, const std::set< Identifier > &layerIds) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
ServiceHandle< Muon::IMuonEDMHelperSvc >	m_edmHelperSvc
ServiceHandle< Trk::ITrackingVolumesSvc >	m_trackingVolumesSvc {this, "TrackingVolumesSvc", "Trk::TrackingVolumesSvc/TrackingVolumesSvc"}
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer {this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
ToolHandle< Trk::IExtrapolator >	m_extrapolator {this, "Extrapolator", "Trk::Extrapolator/MuonExtrapolator"}
ToolHandle< Muon::IMdtDriftCircleOnTrackCreator >	m_mdtRotCreator
ToolHandle< Muon::IMuonClusterOnTrackCreator >	m_cscRotCreator
ToolHandle< Muon::IMuonClusterOnTrackCreator >	m_clusRotCreator
ToolHandle< Trk::IResidualPullCalculator >	m_pullCalculator
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager >	m_DetectorManagerKey
SG::ReadHandleKey< Muon::MdtPrepDataContainer >	m_key_mdt {this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"}
SG::ReadHandleKey< Muon::CscPrepDataContainer >	m_key_csc {this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"}
SG::ReadHandleKey< Muon::TgcPrepDataContainer >	m_key_tgc {this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"}
SG::ReadHandleKey< Muon::RpcPrepDataContainer >	m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}
SG::ReadHandleKey< Muon::sTgcPrepDataContainer >	m_key_stgc {this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"}
SG::ReadHandleKey< Muon::MMPrepDataContainer >	m_key_mm {this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"}
SG::ReadCondHandleKey< Muon::MuonIntersectGeoData >	m_chamberGeoKey {this, "ChamberGeoKey", "MuonStationIntersects", "Pointer to hole search service"}
Gaudi::Property< bool >	m_addMeasurements {this, "AddMeasurements", true}
Gaudi::Property< bool >	m_detectBadSort {this, "DetectBadSorting", false}
Gaudi::Property< double >	m_associationPullCutEta {this, "AssociationPullCutEta", 3}
Gaudi::Property< double >	m_associationPullCutPhi {this, "AssociationPullCutPhi", 10}
Gaudi::Property< double >	m_adcCut {this, "AdcCut", 50}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

tool to select tracks

Definition at line 34 of file MuonChamberHoleRecoveryTool.h.

Member Typedef Documentation

NewTrackStates

using Muon::MuonChamberHoleRecoveryTool::NewTrackStates = std::vector<std::unique_ptr<const Trk::TrackStateOnSurface>>

Definition at line 40 of file MuonChamberHoleRecoveryTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

MuonChamberHoleRecoveryTool()

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

Definition at line 89 of file MuonChamberHoleRecoveryTool.cxx.

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

~MuonChamberHoleRecoveryTool()

virtual Muon::MuonChamberHoleRecoveryTool::~MuonChamberHoleRecoveryTool ( )

virtualdefault

Member Function Documentation

createHoleTSOSsForClusterChamber() [1/2]

virtual void Muon::IMuonHoleRecoveryTool::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

pure virtualinherited

createHoleTSOSsForClusterChamber() [2/2]

void Muon::MuonChamberHoleRecoveryTool::createHoleTSOSsForClusterChamber ( const Identifier & detElId, const EventContext & ctx, const Trk::TrackParameters & pars, std::set< Identifier > & layIds, NewTrackStates & states ) const

override

Definition at line 344 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                    {
        ATH_MSG_VERBOSE(" performing holes search in chamber " << m_idHelperSvc->toString(detElId));
        recoverClusterHits(ctx, detElId, pars, states, layIds);
    }

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

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

getDetectorElement()

const Trk::TrkDetElementBase * Muon::MuonChamberHoleRecoveryTool::getDetectorElement ( const EventContext & ctx, const Identifier & id ) const

private

Returns the detector element associated with the muon Identifier.

Definition at line 354 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                   {
        SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey, ctx};
        const MuonGM::MuonDetectorManager* MuonDetMgr{*DetectorManagerHandle};
        if (!MuonDetMgr) {
            ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
            return nullptr;
        }
        if (m_idHelperSvc->isMdt(detElId))
            return MuonDetMgr->getMdtReadoutElement(detElId);
        else if (m_idHelperSvc->isTgc(detElId))
            return MuonDetMgr->getTgcReadoutElement(detElId);
        else if (m_idHelperSvc->isRpc(detElId))
            return MuonDetMgr->getRpcReadoutElement(detElId);
        else if (m_idHelperSvc->isCsc(detElId))
            return MuonDetMgr->getCscReadoutElement(detElId);
        // New Small Wheel
        else if (m_idHelperSvc->issTgc(detElId))
            return MuonDetMgr->getsTgcReadoutElement(detElId);
        else if (m_idHelperSvc->isMM(detElId))
            return MuonDetMgr->getMMReadoutElement(detElId);
        return nullptr;
    }

getHoleLayerIds()

std::set< Identifier > Muon::MuonChamberHoleRecoveryTool::getHoleLayerIds ( const Identifier & detElId, const std::set< Identifier > & knownLayers ) const

private

Returns a set of all layer Identifiers (GasGap + channel orientation) in a muon chamber of type X excluding the ones in the knownLayers set.

the second gas gap of the three layer stations does not have a phi measurement

Definition at line 459 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                   {
         std::set<Identifier> holeGaps{};
         if (m_idHelperSvc->isMdt(detElId)) {
            const MdtIdHelper& idHelper{m_idHelperSvc->mdtIdHelper()};
            for (int ml = 1; ml <= idHelper.numberOfMultilayers(detElId); ++ml) {
                for (int layer = idHelper.tubeLayerMin(detElId);
                         layer <= idHelper.tubeLayerMax(detElId); ++layer) {
                    const Identifier layerId = idHelper.channelID(detElId, ml, layer, 1);
                    if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
                }
            }
         } else if (m_idHelperSvc->isMM(detElId)) {
            const MmIdHelper& idHelper{m_idHelperSvc->mmIdHelper()};
            for (int ml : {1 ,2}) {
                for (int gap = MmIdHelper::gasGapMin(); gap <= MmIdHelper::gasGapMax(); ++gap) {
                    const Identifier layerId = idHelper.channelID(detElId, ml, gap, 1);
                    if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
                }
            }
         } else if (m_idHelperSvc->issTgc(detElId)) {
            const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
            using channelType = sTgcIdHelper::sTgcChannelTypes;
            for (int ml : {1, 2}) {
                for (const channelType chType : {channelType::Strip,
                                                 channelType::Pad,
                                                 channelType::Wire}){
                    for (int gap = sTgcIdHelper::gasGapMin();
                             gap <= sTgcIdHelper::gasGapMax(); ++gap) {
                        const Identifier layerId = idHelper.channelID(detElId, ml, gap, chType, 1);
                        if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
                    }
                }
            }
         } else if (m_idHelperSvc->isTgc(detElId)) {
            const TgcIdHelper& idHelper = m_idHelperSvc->tgcIdHelper();
            const int gapMax{idHelper.gasGapMax(detElId)};
            for (int gasgap = idHelper.gasGapMin(detElId);
                     gasgap < gapMax; ++gasgap){
                for (int measPhi: {0,1}) {
                    if (gapMax == 3 && gasgap ==2 && measPhi == 1) continue;
                    const Identifier layerId = idHelper.channelID(detElId, gasgap, measPhi, 1);
                    if (!knownLayers.count(layerId)) holeGaps.insert(layerId);
                }
            }
        } else if (m_idHelperSvc->isRpc(detElId)) {
            const RpcIdHelper& idHelper = m_idHelperSvc->rpcIdHelper();
            const int doubZ{idHelper.doubletZ(detElId)};
            const int gapMax{idHelper.gasGapMax(detElId)};
            for (int phiGap = idHelper.doubletPhi(detElId);
                     phiGap <= idHelper.doubletPhiMax(detElId); ++phiGap) {
                for (int gap = idHelper.gasGapMin(detElId);
                         gap <= gapMax; ++gap) {
                    for (int measPhi: {0, 1}) {
                        const Identifier layerId = idHelper.channelID(detElId, doubZ, phiGap, gap, measPhi, 1);
                        if (!knownLayers.count(layerId)) holeGaps.insert(layerId);  
                    }
                }
            }
        } else if (m_idHelperSvc->isCsc(detElId)) {
            const CscIdHelper& idHelper{m_idHelperSvc->cscIdHelper()};
            for (int layer = 1; layer <= 4; ++ layer) {
                for (bool measPhi: {false, true}) {
                    const Identifier layId = idHelper.channelID(detElId, 2, layer, measPhi, 1);
                    if (!knownLayers.count(layId)) holeGaps.insert(layId);
                }
            }
         }
        return holeGaps;
    }

getNextMuonMeasurement()

bool Muon::MuonChamberHoleRecoveryTool::getNextMuonMeasurement ( RecoveryState & trkRecov, RecoveryState::CopyTarget target ) const

private

Increments the internal iterator of the RecoveryState until the next muon measurement on track is found Measurements inside the MS volume or any scatterer are copied automatically copied onto the target vector.

Copy all track states inside the MS

Scatteres AEOTs, material etc.

Definition at line 121 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                          {
        while(trkRecov.nextState()) {
            const Trk::TrackParameters* pars = trkRecov.tsos()->trackParameters();
            ATH_MSG_VERBOSE("Track parameters "<<(*pars));
            const Trk::Volume& msVol{m_trackingVolumesSvc->volume(Trk::ITrackingVolumesSvc::MuonSpectrometerEntryLayer)};
            if (msVol.inside(pars->position())) {
                ATH_MSG_VERBOSE("Tracking parameters are inside the MS");
                trkRecov.copyState(target);
                continue;
            }
 
            if (trkRecov.tsos()->type(Trk::TrackStateOnSurface::Hole)) {
                ATH_MSG_VERBOSE("Skip hole in MS");
                continue;
            }
            const Trk::MeasurementBase* meas = trkRecov.tsos()->measurementOnTrack();
            if (!meas) {
                ATH_MSG_VERBOSE("The track state does not have an associated measurement");
                trkRecov.copyState(target);
                continue;
            }
            trkRecov.tsosId = m_edmHelperSvc->getIdentifier(*meas);
            // Potentially a pseudo measurement. Anyway keep it
            if (!trkRecov.tsosId.is_valid() || !m_idHelperSvc->isMuon(trkRecov.tsosId)) {
                ATH_MSG_VERBOSE("No muon measurement");
                trkRecov.copyState(target);
                continue;
            }
            return true;
        }
        return false;
    }

holesInMdtChamber()

std::set< Identifier > Muon::MuonChamberHoleRecoveryTool::holesInMdtChamber ( const EventContext & ctx, const Amg::Vector3D & position, const Amg::Vector3D & direction, const Identifier & chId, const std::set< Identifier > & tubeIds ) const

private

calculate holes in a given chamber using local straight line extrapolation

Parameters

pars	TrackParameters in the chamber
chId	Identifier of the chamber
tubeIds	set containing the Identifier of the hits that should not be counted as holes

Returns

a vector of hole Identifiers

Definition at line 378 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                                         {
 
        SG::ReadCondHandle<Muon::MuonIntersectGeoData> interSectSvc{m_chamberGeoKey,ctx};
        if (!interSectSvc.isValid())   {
            ATH_MSG_ERROR("Failed to retrieve chamber intersection service");
            throw std::runtime_error("No chamber intersection service");
        }
 
        SG::ReadCondHandle<MuonGM::MuonDetectorManager> detMgr{m_DetectorManagerKey,ctx};
        const MuonGM::MuonDetectorManager* MuonDetMgr = detMgr.cptr();
        const MuonGM::MdtReadoutElement* readoutEle = MuonDetMgr->getMdtReadoutElement(chId);
 
        MuonStationIntersect intersect = interSectSvc->tubesCrossedByTrack(MuonDetMgr, chId, position, direction);
 
        // clear hole vector
        std::set<Identifier> holes;
        for (unsigned int ii = 0; ii < intersect.tubeIntersects().size(); ++ii) {
            const MuonTubeIntersect& tint = intersect.tubeIntersects()[ii];
 
            if (tubeIds.count(tint.tubeId)) { continue; }
            ATH_MSG_VERBOSE(" intersect " << m_idHelperSvc->toString(tint.tubeId) << "  dist wire " << tint.rIntersect
                                          << "  dist to tube end " << tint.xIntersect);
 
            if (std::abs(tint.rIntersect) > readoutEle->innerTubeRadius() || tint.xIntersect > -10.) {
                ATH_MSG_VERBOSE(" not counted");
                continue;
            }
            // check whether there is a hit in this tube
            ATH_MSG_VERBOSE(" hole tube");
            holes.insert(tint.tubeId);
 
        }
        return holes;
    }

initialize()

StatusCode Muon::MuonChamberHoleRecoveryTool::initialize ( )

override

Definition at line 94 of file MuonChamberHoleRecoveryTool.cxx.

                                                       {
        ATH_CHECK(m_DetectorManagerKey.initialize());
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_trackingVolumesSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_extrapolator.retrieve());
 
 
        ATH_CHECK(m_key_csc.initialize(!m_key_csc.empty()));
        ATH_CHECK(m_key_stgc.initialize(!m_key_stgc.empty()));
        ATH_CHECK(m_key_mm.initialize(!m_key_mm.empty()));
 
        ATH_CHECK(m_key_mdt.initialize(!m_key_mdt.empty()));
        ATH_CHECK(m_key_tgc.initialize(!m_key_tgc.empty()));
        ATH_CHECK(m_key_rpc.initialize(!m_key_rpc.empty()));
 
        ATH_CHECK(m_cscRotCreator.retrieve(DisableTool{m_key_csc.empty()}));
 
        const bool hasClusKey = !m_key_stgc.empty() || !m_key_mm.empty() || !m_key_tgc.empty() || !m_key_rpc.empty();
        ATH_CHECK(m_clusRotCreator.retrieve(EnableTool{hasClusKey}));
        ATH_CHECK(m_mdtRotCreator.retrieve(EnableTool{!m_key_mdt.empty()}));
        ATH_CHECK(m_pullCalculator.retrieve());
 
        ATH_CHECK(m_chamberGeoKey.initialize());
        return StatusCode::SUCCESS;
    }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & Muon::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;
        }

layersOnTrkIds()

std::set< Identifier > Muon::MuonChamberHoleRecoveryTool::layersOnTrkIds ( const Trk::Track & track ) const

private

Returns a set of all layer Identifiers of the associated track hits.

Definition at line 156 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                              {
        std::set<Identifier> layerIds{};
        for (const Trk::TrackStateOnSurface* tsos: *track.trackStateOnSurfaces()){
            const Trk::MeasurementBase* meas = tsos->measurementOnTrack();
            if (!meas) continue;
            const Identifier measId = m_edmHelperSvc->getIdentifier(*meas);
 
            if (!m_idHelperSvc->isMuon(measId)) continue;
            layerIds.insert(measId);
            layerIds.insert(m_idHelperSvc->layerId(measId));
            // split competing ROTs into constituents
            const CompetingMuonClustersOnTrack* comp = dynamic_cast<const CompetingMuonClustersOnTrack*>(meas);
            if (!comp) { continue; }
 
            for (const Muon::MuonClusterOnTrack* clust : comp->containedROTs()) {
                layerIds.insert(m_idHelperSvc->layerId(clust->identify()));
            }
        }
        return layerIds;
    }

loadPrepDataHits()

template<class Prd>

std::vector< const Prd * > Muon::MuonChamberHoleRecoveryTool::loadPrepDataHits ( const EventContext & ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd > > & key, const std::set< Identifier > & layerIds ) const

private

Create a subset of Identifiers

Sort the Mdt prepdatas per Identifier as there's the possibily 2 DC can exist for the same channel

Definition at line 413 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                                          {
        std::vector<const Prd*> collectedHits{};
        if (key.empty()) {
            ATH_MSG_DEBUG("No container configured for "<<typeid(Prd).name());
            return collectedHits;
        }
        SG::ReadHandle<MuonPrepDataContainerT<Prd>> prdContainer{key, ctx};
        if (!prdContainer.isPresent()) {
            ATH_MSG_FATAL("Failed to load prep data collection "<<key.fullKey());
            throw std::runtime_error("Invalid prepdata container");
        }
        std::set<IdentifierHash> chamberIds{};
        std::transform(gasGapIds.begin(), gasGapIds.end(),
                            std::inserter(chamberIds, chamberIds.end()),
                                [this](const Identifier& id){
                                    return m_idHelperSvc->moduleHash(id);
                                });
        for (const IdentifierHash& moduleHash : chamberIds) {
            const MuonPrepDataCollection<Prd>* prdColl = prdContainer->indexFindPtr(moduleHash);
            if (!prdColl) continue;
            collectedHits.reserve(collectedHits.size() + prdColl->size());
            for (const Prd* prd: *prdColl) {
                bool appendPrd{false};
                if constexpr (std::is_same<Prd, MdtPrepData>::value) {
                    appendPrd = gasGapIds.count(prd->identify());
                } else {
                    appendPrd = gasGapIds.count(m_idHelperSvc->layerId(prd->identify()));
                }
                if (appendPrd) {
                    ATH_MSG_VERBOSE(__func__<<"() - Add prd candidate "<<m_printer->print(*prd));
                    collectedHits.push_back(prd);
                }
            }
        }
        if constexpr(std::is_same<Prd, MdtPrepData>::value) {
            std::sort(collectedHits.begin(), collectedHits.end(), [](const Prd* a, const Prd* b){
                return a->identify() < b->identify();
            });
        }
        return collectedHits;
    }

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

recover()

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

overridevirtual

returns a new track with holes recovered

Copy all parameters befor the MS onto the new track state

Start an iterative recovery looping over each chamber

Implements Muon::IMuonHoleRecoveryTool.

Definition at line 177 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                     {
        ATH_MSG_DEBUG(" performing hole search track " << std::endl
                                                       << m_printer->print(track) << std::endl
                                                       << m_printer->printMeasurements(track));
 
        RecoveryState recovState{track};
        recovState.layersOnTrk = layersOnTrkIds(track);

        getNextMuonMeasurement(recovState, RecoveryState::CopyTarget::GlobalTrkStates);
        recoverHitsInChamber(ctx, recovState);
        std::unique_ptr<Trk::Track> newTrack = std::make_unique<Trk::Track>(track.info(), recovState.releaseStates(),
                                                                            track.fitQuality() ? track.fitQuality()->uniqueClone() : nullptr);
        return newTrack;
    }

recoverChamberClusters()

template<class Prd>

NewTrackStates Muon::MuonChamberHoleRecoveryTool::recoverChamberClusters ( const EventContext & ctx, const SG::ReadHandleKey< MuonPrepDataContainerT< Prd > > & prdKey, const Identifier & chambId, const Trk::TrackParameters & parsInChamb, std::set< Identifier > & knownLayers ) const

private

Attempts to recover all missing hits in a chamber.

The hit is out of bounds --> continue

Loop over all prd candidates

The surface cannot be reached. Discard the prd

Compare the pad & local positions

Calculate the pull by hand

For one reason or another, the pads have 1D covariances

Check whether the pull is reasonable

Assign the best pad onto the track

Calculate the track pull

the best clusters are found. Put them onto the track

Next loop over the reamining parameters at surface to create holes

Definition at line 530 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                                   {
        NewTrackStates recoveredStates{};
        const std::set<Identifier> missingLayers = getHoleLayerIds(detElId, knownLayers);
        std::vector<const Prd*> prdCandidates = loadPrepDataHits(ctx, prdKey, missingLayers);
        using LayerParsMap = std::map<Identifier, std::unique_ptr<Trk::TrackParameters>>;
        LayerParsMap parsAtSurfMap{};
        for (const Identifier& holeId : missingLayers) {
            const Trk::TrkDetElementBase* detEl = getDetectorElement(ctx, holeId);
            const Trk::Surface& surf{detEl->surface(holeId)};
            std::unique_ptr<Trk::TrackParameters> pars = m_extrapolator->extrapolateDirectly(ctx, parsInChamb, surf,
                                                                                             Trk::anyDirection, false, Trk::muon);
            if (!pars) {
                ATH_MSG_VERBOSE("Surface layer "<<m_idHelperSvc->toStringGasGap(holeId)<<" cannot be reached");
                continue;
            }
            if (!Amg::hasPositiveDiagElems(*pars->covariance())) {
                ATH_MSG_DEBUG("Uncertainties of extraploation to "<<m_idHelperSvc->toStringGasGap(holeId)<<" blew up");
                continue;
            }
            const Amg::Vector2D locExPos{pars->parameters()[Trk::locX],
                                         pars->parameters()[Trk::locY]};
            bool inbounds{false};
            if constexpr(std::is_same<Prd, MMPrepData>::value) {
                inbounds = static_cast<const MuonGM::MMReadoutElement*>(detEl)->insideActiveBounds(holeId, locExPos, 10.,10.);
            } else {
                inbounds = surf.insideBounds(locExPos, 10., 10.);
            }
            if (!inbounds) {
                ATH_MSG_VERBOSE("Extrapolation to layer "<<m_idHelperSvc->toStringGasGap(holeId)
                              <<" is outside of the chamber "<<Amg::toString(locExPos, 2));
                continue;
            }
            parsAtSurfMap[holeId] = std::move(pars);
        }
        ClusterLayerMap bestClusterInLay;
        for (const Prd* hit : prdCandidates) {
            const Identifier layId = m_idHelperSvc->layerId(hit->identify());
            LayerParsMap::const_iterator pars_itr = parsAtSurfMap.find(layId);
            if (pars_itr == parsAtSurfMap.end()) {
                continue;
            }
            const std::unique_ptr<Trk::TrackParameters>& parsInLay{pars_itr->second};
            std::unique_ptr<MuonClusterOnTrack> calibClus{};
            if constexpr(std::is_same<Prd, CscPrepData>::value) {
                calibClus.reset(m_cscRotCreator->createRIO_OnTrack(*hit,
                                                                   parsInLay->position(),
                                                                   parsInLay->momentum().unit()));
            } else {
                calibClus.reset(m_clusRotCreator->createRIO_OnTrack(*hit,
                                                                    parsInLay->position(),
                                                                    parsInLay->momentum().unit()));
            }
            if (!calibClus) continue;
 
            if constexpr (std::is_same<Prd, sTgcPrepData>::value) {
                const sTgcIdHelper& idHelper{m_idHelperSvc->stgcIdHelper()};
                if (idHelper.channelType(hit->identify()) == sTgcIdHelper::sTgcChannelTypes::Pad){
                    const Amg::Vector2D locExPos{parsInLay->parameters()[Trk::locX],
                                                 parsInLay->parameters()[Trk::locY]};
 
                    const MuonGM::MuonPadDesign* pad = hit->detectorElement()->getPadDesign(hit->identify());
                    const Amg::Vector2D padDist = pad->distanceToPad(locExPos, idHelper.channel(hit->identify()));

                    const double xCov = std::hypot(Amg::error(*parsInLay->covariance(), Trk::locX),
                                                   Amg::error(hit->localCovariance(), Trk::locX));
                    const double yCov =Amg::error(*parsInLay->covariance(), Trk::locY);
 
                    const double xPull = padDist.x() / xCov;
                    const double yPull = padDist.y() / yCov;
 
                    ATH_MSG_VERBOSE(__func__<<"() - check "<<m_printer->print(*calibClus)
                                 <<" diff "<<Amg::toString(padDist, 2)
                                 <<" covariance: ("<<xCov<<", "<<yCov<<")"
                                 <<" pull: ("<<xPull<<","<<yPull<<").");

                    if (xPull > m_associationPullCutEta || yPull > m_associationPullCutPhi) continue;
                    const double pull = std::hypot(xPull, yPull);

                    PullCluster& bestClus = bestClusterInLay[layId];
                    if (bestClus.pull < pull) continue;
                    bestClus.pull = pull;
                    bestClus.clus = std::move(calibClus);
                    bestClus.pars = parsInLay->uniqueClone();
                    continue;
                }
            }

            std::optional<const Trk::ResidualPull> resPull{
                m_pullCalculator->residualPull(calibClus.get(), parsInLay.get(),
                                               Trk::ResidualPull::Unbiased)};
            if (!resPull || resPull->pull().empty()) {
                continue;
            }
 
            const double pull = std::abs(resPull->pull().front());
            const double pullCut = m_idHelperSvc->measuresPhi(layId) ? m_associationPullCutPhi
                                                                     : m_associationPullCutEta;
            if (pull > pullCut) continue;
 
            PullCluster& bestClus = bestClusterInLay[layId];
            if (bestClus.pull < pull) continue;
            bestClus.pull = pull;
            bestClus.clus = std::move(calibClus);
            bestClus.pars = parsInLay->uniqueClone();
 
        }
        for (auto& [layerId, foundClus]: bestClusterInLay) {
            ATH_MSG_VERBOSE(__func__<<"() recovered hit " << m_printer->print(*foundClus.clus)<<" pull: "<<foundClus.pull);
            std::unique_ptr<Trk::TrackStateOnSurface> tsos = MuonTSOSHelper::createMeasTSOS(std::move(foundClus.clus),
                                                                                            std::move(foundClus.pars),
                                                                                            Trk::TrackStateOnSurface::Measurement);
            recoveredStates.emplace_back(std::move(tsos));
            knownLayers.insert(layerId);
            parsAtSurfMap[layerId].reset();
        }
        for (auto& [layerId, exPars] : parsAtSurfMap) {
            if (!exPars) continue;
            ATH_MSG_VERBOSE(__func__<<"() add new hole state "<<m_idHelperSvc->toStringGasGap(layerId));
            recoveredStates.emplace_back(MuonTSOSHelper::createHoleTSOS(std::move(exPars)));
        }
        return recoveredStates;
    }

recoverClusterHits()

void Muon::MuonChamberHoleRecoveryTool::recoverClusterHits ( const EventContext & ctx, const Identifier & chId, const Trk::TrackParameters & chambPars, NewTrackStates & newStates, std::set< Identifier > & knownLayers ) const

private

Definition at line 324 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                        {
 
        NewTrackStates recovered{};
        if (m_idHelperSvc->isRpc(chambId)) {
            recovered = recoverChamberClusters(ctx, m_key_rpc, chambId, pars, knownLayers);
        } else if (m_idHelperSvc->isTgc(chambId)) {
            recovered = recoverChamberClusters(ctx, m_key_tgc, chambId, pars, knownLayers);
        } else if (m_idHelperSvc->isCsc(chambId)) {
            recovered = recoverChamberClusters(ctx, m_key_csc, chambId, pars, knownLayers);
        } else if (m_idHelperSvc->isMM(chambId)) {
            recovered = recoverChamberClusters(ctx, m_key_mm, chambId, pars, knownLayers);
        } else if (m_idHelperSvc->issTgc(chambId)) {
            recovered = recoverChamberClusters(ctx, m_key_stgc, chambId, pars, knownLayers);
        }
        states.insert(states.end(), std::make_move_iterator(recovered.begin()),
                                    std::make_move_iterator(recovered.end()));
    }

recoverHitsInChamber()

void Muon::MuonChamberHoleRecoveryTool::recoverHitsInChamber ( const EventContext & ctx, RecoveryState & trkRecov ) const

private

Loops over all muon hits in a muon chamber and tries to find missed ones by checking each tracking layer for hits.

If a new chamber is reached another iteration of the method is called

Collect all hits in a chamber

New chamber added

Definition at line 193 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                 {
        const Muon::MuonStationIndex::ChIndex currStation = m_idHelperSvc->chamberIndex(trkRecov.tsosId);
        std::set<Identifier> chambInStation{};
        do {
            if (currStation != m_idHelperSvc->chamberIndex(trkRecov.tsosId)) {
                trkRecov.finalizeChamber();
                recoverHitsInChamber(ctx, trkRecov);
                return;
            }
            trkRecov.copyState(RecoveryState::CopyTarget::ChamberTrkStates);
            if (chambInStation.insert(m_idHelperSvc->chamberId(trkRecov.tsosId)).second) {
                if (m_idHelperSvc->isMdt(trkRecov.tsosId)) {
                    recoverMdtHits(ctx, trkRecov.tsosId, *trkRecov.tsos()->trackParameters(),
                                   trkRecov.chamberStates, trkRecov.layersOnTrk);
                } else {
                    recoverClusterHits(ctx, trkRecov.tsosId, *trkRecov.tsos()->trackParameters(),
                                       trkRecov.chamberStates, trkRecov.layersOnTrk);
                }
            }
        } while (getNextMuonMeasurement(trkRecov, RecoveryState::CopyTarget::ChamberTrkStates));
        trkRecov.finalizeChamber();
    }

recoverMdtHits()

void Muon::MuonChamberHoleRecoveryTool::recoverMdtHits ( const EventContext & ctx, const Identifier & chId, const Trk::TrackParameters & pars, NewTrackStates & newStates, std::set< Identifier > & knownLayers ) const

private

calculate Amg::Vector2D using surf to obtain sign

calculate side

update sign

pointer to resPull

Overwrite the previous drift circle if the pull of this one is better or it's an outlier

Definition at line 217 of file MuonChamberHoleRecoveryTool.cxx.

                                                                                                                       {
 
 
        std::set<Identifier> chHoles = holesInMdtChamber(ctx, pars.position(), pars.momentum().unit(), chId, knownLayers);
        ATH_MSG_VERBOSE(" chamber " << m_idHelperSvc->toStringChamber(chId) << " has holes " << chHoles.size());
        if (chHoles.empty()) return;
 
        const std::vector<const MdtPrepData*> prdCandidates{loadPrepDataHits<MdtPrepData>(ctx, m_key_mdt, chHoles)};
        bool addedState{false};
        for (const MdtPrepData* mdtPrd : prdCandidates) {
            const Trk::StraightLineSurface& surf{mdtPrd->detectorElement()->surface(mdtPrd->identify())};
            std::unique_ptr<Trk::TrackParameters> exPars = m_extrapolator->extrapolateDirectly(ctx, pars, surf, Trk::anyDirection, false, Trk::muon);
            if (!exPars) {
                ATH_MSG_VERBOSE("Propagation to "<<m_idHelperSvc->toString(mdtPrd->identify())<<" failed.");
                continue;
            }

            Amg::Vector2D locPos{Amg::Vector2D::Zero()};
            if (!surf.globalToLocal(exPars->position(), exPars->momentum(), locPos)) {
                ATH_MSG_DEBUG(" failed to calculate drift sign ");
                continue;
            }
            if (!surf.insideBounds(locPos)) {
                chHoles.erase(mdtPrd->identify());
                continue;
            }
 
            // calibrate Mdt PRD
            const Amg::Vector3D momentum = exPars->momentum();
            std::unique_ptr<MdtDriftCircleOnTrack> mdtROT{m_mdtRotCreator->createRIO_OnTrack(*mdtPrd,
                                                                                             exPars->position(),
                                                                                             &momentum)};
            if (!mdtROT) continue;

            Trk::DriftCircleSide side = locPos[Trk::driftRadius] < 0 ? Trk::LEFT : Trk::RIGHT;
            m_mdtRotCreator->updateSign(*mdtROT, side);

            std::optional<const Trk::ResidualPull> resPull{m_pullCalculator->residualPull(mdtROT.get(),
                                                                                          exPars.get(),
                                                                                          Trk::ResidualPull::Unbiased)};
            if (!resPull) { continue; }
 
            const double pull = resPull->pull().front();
            const double radialResidual = std::abs(mdtROT->localParameters()[Trk::locR]) -
                                          std::abs(exPars->parameters()[Trk::locR]);
 
            unsigned int hitFlag = 1;
            if (mdtPrd->adc() < m_adcCut || mdtPrd->status() != MdtStatusDriftTime)
                hitFlag = 3;  // noise
            else if (std::abs(pull) < m_associationPullCutEta)
                hitFlag = 0;  // hit on track
            else if (radialResidual > 0.)
                hitFlag = 2;  // out of time
 
            ATH_MSG_VERBOSE(__func__<<"() - Recover "<<m_printer->print(*mdtROT)<<" pull: "<<pull<<" hitFlag: "<<hitFlag);
            std::unique_ptr<Trk::TrackStateOnSurface> tsos = MuonTSOSHelper::createMeasTSOS(std::move(mdtROT),
                                                                                            std::move(exPars),
                                                                                        (hitFlag != 0 || !m_addMeasurements) ?
                                                                                                Trk::TrackStateOnSurface::Outlier :
                                                                                                Trk::TrackStateOnSurface::Measurement);
 
            if (!addedState) {
                newStates.emplace_back(std::move(tsos));
                addedState = true;
            } else {
                const MdtDriftCircleOnTrack* prevDC = static_cast<const MdtDriftCircleOnTrack*>(newStates.back()->measurementOnTrack());
                if (prevDC->identify() != mdtPrd->identify()) {
                    newStates.emplace_back(std::move(tsos));
                } else {
                    ATH_MSG_DEBUG("Two hits recorded for the same tube "<<std::endl<<
                                 " *** current: "<<m_printer->print(*tsos->measurementOnTrack())<<std::endl<<
                                 " *** previous: "<<m_printer->print(*prevDC));
                    std::optional<Trk::ResidualPull> prevPullObj{m_pullCalculator->residualPull(prevDC,
                                                                                                tsos->trackParameters(),
                                                                                                Trk::ResidualPull::Unbiased)};
                    const double prevPull = prevPullObj->pull().front();
                    if (std::abs(pull) < std::abs(prevPull) ||
                        (tsos->type(Trk::TrackStateOnSurface::Measurement) &&
                        newStates.back()->type(Trk::TrackStateOnSurface::Outlier))) {
                        newStates.back() = std::move(tsos);
                    }
 
                }
            }
            chHoles.erase(mdtPrd->identify());
            knownLayers.insert(mdtPrd->identify());
        }
 
        for (const Identifier& hole : chHoles) {
            const Trk::Surface& surf{getDetectorElement(ctx, hole)->surface(hole)};
            std::unique_ptr<Trk::TrackParameters> exPars = m_extrapolator->extrapolateDirectly(ctx, pars, surf, Trk::anyDirection, false, Trk::muon);
            if (!exPars) {
                ATH_MSG_VERBOSE("Propagation to "<<m_idHelperSvc->toString(hole)<<" failed.");
                continue;
            }
            ATH_MSG_VERBOSE(__func__<<"() - Add hole "<<m_idHelperSvc->toString(hole));
            newStates.emplace_back(MuonTSOSHelper::createHoleTSOS(std::move(exPars)));
        }
    }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_adcCut

Gaudi::Property<double> Muon::MuonChamberHoleRecoveryTool::m_adcCut {this, "AdcCut", 50}

private

Definition at line 197 of file MuonChamberHoleRecoveryTool.h.

{this, "AdcCut", 50};

m_addMeasurements

Gaudi::Property<bool> Muon::MuonChamberHoleRecoveryTool::m_addMeasurements {this, "AddMeasurements", true}

private

Definition at line 192 of file MuonChamberHoleRecoveryTool.h.

{this, "AddMeasurements", true};

m_associationPullCutEta

Gaudi::Property<double> Muon::MuonChamberHoleRecoveryTool::m_associationPullCutEta {this, "AssociationPullCutEta", 3}

private

Definition at line 195 of file MuonChamberHoleRecoveryTool.h.

{this, "AssociationPullCutEta", 3};

m_associationPullCutPhi

Gaudi::Property<double> Muon::MuonChamberHoleRecoveryTool::m_associationPullCutPhi {this, "AssociationPullCutPhi", 10}

private

Definition at line 196 of file MuonChamberHoleRecoveryTool.h.

{this, "AssociationPullCutPhi", 10};

m_chamberGeoKey

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

private

Definition at line 190 of file MuonChamberHoleRecoveryTool.h.

{this, "ChamberGeoKey", "MuonStationIntersects", "Pointer to hole search service"};

m_clusRotCreator

ToolHandle<Muon::IMuonClusterOnTrackCreator> Muon::MuonChamberHoleRecoveryTool::m_clusRotCreator

private

Initial value:

{this, "ClusterRotCreator",
                                                                      "Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator",
                                                                      "IMuonClusterOnTrackCreator for RPC, TGC, NSW hits"}

Definition at line 173 of file MuonChamberHoleRecoveryTool.h.

                                                                   {this, "ClusterRotCreator",
                                                                      "Muon::MuonClusterOnTrackCreator/MuonClusterOnTrackCreator",
                                                                      "IMuonClusterOnTrackCreator for RPC, TGC, NSW hits"};

m_cscRotCreator

ToolHandle<Muon::IMuonClusterOnTrackCreator> Muon::MuonChamberHoleRecoveryTool::m_cscRotCreator

private

Initial value:

{
            this, "CscRotCreator", "", "IMuonClusterOnTrackCreator for cscs"}

Definition at line 171 of file MuonChamberHoleRecoveryTool.h.

                                                                  {
            this, "CscRotCreator", "", "IMuonClusterOnTrackCreator for cscs"};

m_detectBadSort

Gaudi::Property<bool> Muon::MuonChamberHoleRecoveryTool::m_detectBadSort {this, "DetectBadSorting", false}

private

Definition at line 193 of file MuonChamberHoleRecoveryTool.h.

{this, "DetectBadSorting", false};

m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> Muon::MuonChamberHoleRecoveryTool::m_DetectorManagerKey

private

Initial value:

{this, "DetectorManagerKey", "MuonDetectorManager",
                                                                                "Key of input MuonDetectorManager condition data"}

Definition at line 179 of file MuonChamberHoleRecoveryTool.h.

                                                                           {this, "DetectorManagerKey", "MuonDetectorManager",
                                                                                "Key of input MuonDetectorManager condition data"};

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<Muon::IMuonEDMHelperSvc> Muon::MuonChamberHoleRecoveryTool::m_edmHelperSvc

private

Initial value:

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

Definition at line 158 of file MuonChamberHoleRecoveryTool.h.

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

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extrapolator

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

private

Definition at line 167 of file MuonChamberHoleRecoveryTool.h.

{this, "Extrapolator", "Trk::Extrapolator/MuonExtrapolator"};

m_idHelperSvc

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

private

Definition at line 157 of file MuonChamberHoleRecoveryTool.h.

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

m_key_csc

SG::ReadHandleKey<Muon::CscPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_csc {this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"}

private

Definition at line 183 of file MuonChamberHoleRecoveryTool.h.

{this, "CscPrepDataContainer", "CSC_Clusters", "CSC PRDS"};

m_key_mdt

SG::ReadHandleKey<Muon::MdtPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_mdt {this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"}

private

Definition at line 182 of file MuonChamberHoleRecoveryTool.h.

{this, "MdtPrepDataContainer", "MDT_DriftCircles", "MDT PRDs"};

m_key_mm

SG::ReadHandleKey<Muon::MMPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_mm {this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"}

private

Definition at line 187 of file MuonChamberHoleRecoveryTool.h.

{this, "MMPrepDataContainer", "MM_Measurements", "MM PRDs"};

m_key_rpc

SG::ReadHandleKey<Muon::RpcPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_rpc {this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"}

private

Definition at line 185 of file MuonChamberHoleRecoveryTool.h.

{this, "RpcPrepDataContainer", "RPC_Measurements", "RPC PRDs"};

m_key_stgc

SG::ReadHandleKey<Muon::sTgcPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_stgc {this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"}

private

Definition at line 186 of file MuonChamberHoleRecoveryTool.h.

{this, "sTgcPrepDataContainer", "STGC_Measurements", "sTGC PRDs"};

m_key_tgc

SG::ReadHandleKey<Muon::TgcPrepDataContainer> Muon::MuonChamberHoleRecoveryTool::m_key_tgc {this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"}

private

Definition at line 184 of file MuonChamberHoleRecoveryTool.h.

{this, "TgcPrepDataContainer", "TGC_Measurements", "TGC PRDs"};

m_mdtRotCreator

ToolHandle<Muon::IMdtDriftCircleOnTrackCreator> Muon::MuonChamberHoleRecoveryTool::m_mdtRotCreator

private

Initial value:

{this, "MdtRotCreator",
                                                                        "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator",
                                                                        "IMdtDriftCircleOnTrackCreator full calibration"}

Definition at line 168 of file MuonChamberHoleRecoveryTool.h.

                                                                     {this, "MdtRotCreator",
                                                                        "Muon::MdtDriftCircleOnTrackCreator/MdtDriftCircleOnTrackCreator",
                                                                        "IMdtDriftCircleOnTrackCreator full calibration"};

m_printer

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

private

Definition at line 166 of file MuonChamberHoleRecoveryTool.h.

{this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"};

m_pullCalculator

ToolHandle<Trk::IResidualPullCalculator> Muon::MuonChamberHoleRecoveryTool::m_pullCalculator

private

Initial value:

{this, "PullCalculator",
                                                                  "Trk::ResidualPullCalculator/ResidualPullCalculator"}

Definition at line 176 of file MuonChamberHoleRecoveryTool.h.

                                                               {this, "PullCalculator",
                                                                  "Trk::ResidualPullCalculator/ResidualPullCalculator"};

m_trackingVolumesSvc

ServiceHandle<Trk::ITrackingVolumesSvc> Muon::MuonChamberHoleRecoveryTool::m_trackingVolumesSvc {this, "TrackingVolumesSvc", "Trk::TrackingVolumesSvc/TrackingVolumesSvc"}

private

Definition at line 161 of file MuonChamberHoleRecoveryTool.h.

{this, "TrackingVolumesSvc", "Trk::TrackingVolumesSvc/TrackingVolumesSvc"};

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:

• MuonChamberHoleRecoveryTool.h
• MuonChamberHoleRecoveryTool.cxx