Muon::MuonTrackSelectorTool Class Reference

tool to select tracks More...

#include <MuonTrackSelectorTool.h>

Inheritance diagram for Muon::MuonTrackSelectorTool:

Collaboration diagram for Muon::MuonTrackSelectorTool:

Classes
struct	StationData
	internal data structure More...

Public Member Functions
	MuonTrackSelectorTool (const std::string &, const std::string &, const IInterface *)
	constructor
virtual	~MuonTrackSelectorTool ()=default
	destructor
StatusCode	initialize ()
	AlgTool initilize.
StatusCode	finalize ()
	AlgTool finalize.
std::vector< Identifier >	holesInChamber (const Trk::TrackParameters &pars, const Identifier &chId, const std::set< Identifier > &tubeIds) const
	calculate holes in a given chamber using local straight line extrapolation
bool	decision (Trk::Track &track) const
	returns true if the track satisfies the selection criteria else false
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

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
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
	EDM Helper tool.
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer
ToolHandle< Trk::ITrackSummaryHelperTool >	m_trackSummaryTool
Gaudi::Property< double >	m_holeHitRatioCutPerStation {this, "HolesToHitsRatioCutPerStation", 1.1}
Gaudi::Property< double >	m_chi2NDofCut {this, "Chi2NDofCut", 20}
Gaudi::Property< unsigned int >	m_minMdtHitsPerStation {this, "MinimumNumberOfMdtHitsPerStation", 3}
Gaudi::Property< unsigned int >	m_maxMdtHolesPerTwoStationTrack {this, "MaxMdtHolesOnTwoStationTrack", 5}
Gaudi::Property< unsigned int >	m_maxMdtHolesPerTrack {this, "MaxMdtHolesOnTrack", 5}
Gaudi::Property< unsigned int >	m_minCscHitsPerStation {this, "MinimumNumberOfCscHitsPerStation", 3 }
Gaudi::Property< bool >	m_useRPCHoles {this, "UseRPCHoles", true}
Gaudi::Property< bool >	m_useTGCHoles {this, "UseTGCHoles", true}
Gaudi::Property< bool >	m_useCSCHoles {this, "UseCSCHoles", true}
Gaudi::Property< bool >	m_useMDTHoles {this, "UseMDTHoles", true}
Gaudi::Property< bool >	m_ignoreTriggerHolesInLayersWithHits {this, "IgnoreTriggerHolesInChamberWithHits", true}
Gaudi::Property< bool >	m_useRPCTimeWindow {this, "ApplyRPCTimeWindow", false}
Gaudi::Property< bool >	m_removeTwoStationTrackWithoutTriggerHits {this, "RemoveTwoStationTrackWithoutTriggerHits", false}
Gaudi::Property< bool >	m_countMdtOutliersAsHoles {this, "CountMDTOutlierAsHoles", false}
Gaudi::Property< bool >	m_removeSingleStationTracks {this, "RemoveSingleStationTracks", false}
Gaudi::Property< bool >	m_tightSingleStationCuts {this, "TightSingleStationCuts", false}
Gaudi::Property< bool >	m_requireSanePerigee
std::atomic_uint	m_ntotalTracks {0}
	counter for statistics
std::atomic_uint	m_failedChi2NDofCut {0}
std::atomic_uint	m_failedSingleStationCut {0}
std::atomic_uint	m_failedRPCAveMinTimeCut {0}
std::atomic_uint	m_failedRPCAveMaxTimeCut {0}
std::atomic_uint	m_failedRPCSpreadTimeCut {0}
std::atomic_uint	m_failedTwoStationsCut {0}
std::atomic_uint	m_failedTwoStationsMaxMDTHoleCut {0}
std::atomic_uint	m_failedTwoStationsMaxHoleCut {0}
std::atomic_uint	m_failedTwoStationsGoodStationCut {0}
std::atomic_uint	m_failedTriggerStationCut {0}
std::atomic_uint	m_failedMaxMDTHoleCut {0}
std::atomic_uint	m_failedMaxHoleCut {0}
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 33 of file MuonTrackSelectorTool.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

MuonTrackSelectorTool()

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

constructor

Definition at line 20 of file MuonTrackSelectorTool.cxx.

                                                                                                               :
        AthAlgTool(ty, na, pa) {}

~MuonTrackSelectorTool()

virtual Muon::MuonTrackSelectorTool::~MuonTrackSelectorTool ( )

virtualdefault

destructor

Member Function Documentation

decision()

bool Muon::MuonTrackSelectorTool::decision

(

Trk::Track &

track

)

const

returns true if the track satisfies the selection criteria else false

Definition at line 65 of file MuonTrackSelectorTool.cxx.

                                                              {
        // loop over track and calculate residuals
        const Trk::TrackStates* states = track.trackStateOnSurfaces();
        if (!states) {
            ATH_MSG_DEBUG(" track without states, discarding track ");
            return false;
        }
        if (m_requireSanePerigee) {
            if (!track.perigeeParameters() || !Amg::hasPositiveDiagElems(*track.perigeeParameters()->covariance())) return false;
        }
 
        ++m_ntotalTracks;
 
        ATH_MSG_VERBOSE(" new track " << m_printer->print(track) << std::endl << m_printer->printStations(track));
 
        // get reduced chi2
        const Trk::FitQuality* fq = track.fitQuality();
        if (!fq) return false;
        double reducedChi2 = fq->numberDoF() != 0. ? fq->chiSquared() / fq->numberDoF() : 1.;
        if (reducedChi2 > m_chi2NDofCut) {
            ++m_failedChi2NDofCut;
            ATH_MSG_DEBUG(" Track discarded: too large chi2 " << reducedChi2);
            return false;
        }
 
        if (m_useRPCTimeWindow) {
            int nrpcs = 0;
            double aveRpcTime = 0.;
            double minTime = 1e9;
            double maxTime = -1e9;
 
            // loop over TSOSs
            Trk::TrackStates::const_iterator tsit = states->begin();
            Trk::TrackStates::const_iterator tsit_end = states->end();
            for (; tsit != tsit_end; ++tsit) {
                if (!(*tsit)->type(Trk::TrackStateOnSurface::Measurement)) continue;
 
                // check wther state is a measurement
                const Trk::MeasurementBase* meas = (*tsit)->measurementOnTrack();
                if (!meas) continue;
 
                const RpcClusterOnTrack* rpc = dynamic_cast<const RpcClusterOnTrack*>(meas);
                if (!rpc) {
                    const CompetingMuonClustersOnTrack* crot = dynamic_cast<const CompetingMuonClustersOnTrack*>(meas);
                    if (crot) { rpc = dynamic_cast<const RpcClusterOnTrack*>(crot->containedROTs().front()); }
                }
                if (rpc) {
                    double time = rpc->prepRawData()->time() - rpc->globalPosition().mag() / 300.;
                    ++nrpcs;
                    aveRpcTime += time;
                    if (time < minTime) minTime = time;
                    if (time > maxTime) maxTime = time;
                }
            }
 
            if (nrpcs != 0) {
                aveRpcTime /= nrpcs;
                double timeMinCut = -2.;
                double timeMaxCut = 20.;
                ATH_MSG_VERBOSE(" ave RPC time " << aveRpcTime << "  min " << minTime << " max " << maxTime);
                if (aveRpcTime < timeMinCut) {
                    ATH_MSG_VERBOSE(" rejecting due too small average RPC time ");
                    ++m_failedRPCAveMinTimeCut;
                    return false;
                }
                if (aveRpcTime > timeMaxCut) {
                    ATH_MSG_VERBOSE(" rejecting due too large average RPC time ");
                    ++m_failedRPCAveMaxTimeCut;
                    return false;
                }
                if (maxTime > timeMaxCut && minTime < timeMinCut) {
                    ATH_MSG_VERBOSE(" rejecting due too larger RPC time spread ");
                    ++m_failedRPCSpreadTimeCut;
                    return false;
                }
            }
        }
 
        unsigned int mdtHoles = 0;
        unsigned int mdtOutliers = 0;
        unsigned int nholes = 0;
        std::map<MuonStationIndex::StIndex, StationData> stations;
 
        Trk::TrackSummary* summary = track.trackSummary();
        Trk::MuonTrackSummary muonSummary;
        if (summary) {
            if (summary->muonTrackSummary())
                muonSummary = *summary->muonTrackSummary();
            else {
                m_trackSummaryTool->addDetailedTrackSummary(track, *summary);
                if (summary->muonTrackSummary()) muonSummary = *summary->muonTrackSummary();
            }
        } else {
            Trk::TrackSummary tmpSummary;
            m_trackSummaryTool->addDetailedTrackSummary(track, tmpSummary);
            if (tmpSummary.muonTrackSummary()) muonSummary = *tmpSummary.muonTrackSummary();
        }
 
        std::vector<Trk::MuonTrackSummary::ChamberHitSummary>::const_iterator chit = muonSummary.chamberHitSummary().begin();
        std::vector<Trk::MuonTrackSummary::ChamberHitSummary>::const_iterator chit_end = muonSummary.chamberHitSummary().end();
        for (; chit != chit_end; ++chit) {
            const Identifier& chId = chit->chamberId();
 
            bool isMdt = m_idHelperSvc->isMdt(chId);
            bool isCsc = m_idHelperSvc->isCsc(chId);
            bool isRpc = m_idHelperSvc->isRpc(chId);
            bool isTgc = m_idHelperSvc->isTgc(chId);
            bool issTgc = m_idHelperSvc->issTgc(chId);
            bool isMM = m_idHelperSvc->isMM(chId);
 
            // check whether we should use holes in this chamber
            bool useHoles = false;
            if ((isMdt && m_useMDTHoles) || (isTgc && m_useTGCHoles) || (isRpc && m_useRPCHoles) || (isCsc && m_useCSCHoles))
                useHoles = true;
 
            if (isMdt) {
                MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chId);
                StationData& stData = stations[stIndex];
                stData.netaHits += chit->nhits();
                if (useHoles) stData.netaHoles += chit->nholes();
                if (!stData.mdtHasHitsinMl1 && chit->mdtMl1().nhits > 0) stData.mdtHasHitsinMl1 = true;
                if (!stData.mdtHasHitsinMl2 && chit->mdtMl2().nhits > 0) stData.mdtHasHitsinMl2 = true;
 
                if (useHoles) {
                    mdtHoles += chit->nholes();
                    nholes += chit->nholes();
                    mdtOutliers += chit->noutliers();
                }
 
                stData.isMdt = true;
 
            } else if (isCsc || issTgc || isMM) {
                MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chId);
                StationData& stData = stations[stIndex];
                stData.netaHits += chit->etaProjection().nhits;
                if (useHoles) {
                    stData.netaHoles += chit->etaProjection().nholes;
                    stData.nphiHoles += chit->phiProjection().nholes;
                    nholes += chit->nholes();
                }
                stData.nphiHits += chit->phiProjection().nhits;
                stData.isCsc = isCsc;
                stData.isNSW = issTgc || isMM;
 
            } else if (isRpc || isTgc) {
                MuonStationIndex::StIndex stIndex = m_idHelperSvc->stationIndex(chId);
                StationData& stData = stations[stIndex];
                stData.netaTrigHits += chit->etaProjection().nhits > 0 ? 1 : 0;
                stData.nphiTrigHits += chit->phiProjection().nhits > 0 ? 1 : 0;
                if (useHoles) {
                    // add trigger holes
                    if (!m_ignoreTriggerHolesInLayersWithHits || chit->etaProjection().nhits == 0) {
                        stData.netaTrigHoles += chit->etaProjection().nholes;
                        nholes += chit->etaProjection().nholes;
                    }
                    if (!m_ignoreTriggerHolesInLayersWithHits || chit->phiProjection().nhits == 0) {
                        stData.nphiTrigHoles += chit->phiProjection().nholes;
                        nholes += chit->phiProjection().nholes;
                    }
                }
 
                // make sure this station is not already present as MDT or CSC station
                if (!stData.isMdt && !stData.isCsc) stData.isTrigger = true;
            }
        }
 
        unsigned int nGoodStations = 0;
        unsigned int nstations = 0;
        unsigned int nTwoMlStations = 0;
        unsigned int nGoodCscStations = 0;
        unsigned int nGoodTriggerStations = 0;
 
        std::map<MuonStationIndex::StIndex, StationData>::iterator sit = stations.begin();
        std::map<MuonStationIndex::StIndex, StationData>::iterator sit_end = stations.end();
        for (; sit != sit_end; ++sit) {
            StationData& stData = sit->second;
 
            if (stData.nphiTrigHits != 0 && stData.netaTrigHits != 0) { ++nGoodTriggerStations; }
 
            if (stData.isMdt) {
                if (stData.netaHits < m_minMdtHitsPerStation) {
                    ATH_MSG_VERBOSE(" Not counting MDT station too few MDT hits: nhits " << stData.netaHits << " cut "
                                                                                         << m_minMdtHitsPerStation);
                    continue;
                }
                ++nstations;
                double holeHitRatio = (double)stData.netaHoles / stData.netaHits;
                if (holeHitRatio > m_holeHitRatioCutPerStation) {
                    ATH_MSG_VERBOSE(" Not counting MDT station too many holes: nhits " << stData.netaHits << "  nholes " << stData.netaHoles
                                                                                       << "  ratio " << holeHitRatio << " cut "
                                                                                       << m_holeHitRatioCutPerStation);
                    continue;
                }
                if (stData.mdtHasHitsinBothMl()) ++nTwoMlStations;
            } else if (stData.isCsc || stData.isNSW) {
                if (stData.isCsc && stData.nphiHits == 0) {
                    ATH_MSG_VERBOSE(" Not counting CSC station no phi hits: netaHits " << stData.netaHits << "  nphiHits "
                                                                                       << stData.nphiHits);
                    continue;
                }
 
                if (stData.netaHits < m_minCscHitsPerStation) {
                    ATH_MSG_VERBOSE(" Not counting CSC station too few hits: netaHits "
                                    << stData.netaHits << "  nphiHits " << stData.nphiHits << " cut " << m_minCscHitsPerStation);
                    continue;
                }
                ++nstations;
                ++nGoodCscStations;
            }
 
            ++nGoodStations;
        }
 
        ATH_MSG_DEBUG(" good stations " << nGoodStations << " MDT stations with two ml " << nTwoMlStations << " MDT holes " << mdtHoles
                                        << " outliers " << mdtOutliers << " good CSC stations " << nGoodCscStations << " trigger stations "
                                        << nGoodTriggerStations);
 
        if (m_removeSingleStationTracks && stations.size() < 2) {
            ATH_MSG_DEBUG(" Track discarded: too few stations " << stations.size());
            ++m_failedSingleStationCut;
            return false;
        }
 
        // special treatment of single station tracks
        if (stations.size() == 1) {
            using namespace MuonStationIndex;
            if (!stations.count(StIndex::EM)) return false;
 
            StationData& stData = stations[StIndex::EM];
 
            unsigned int nExpectedTriggerStations = m_tightSingleStationCuts ? 3 : 2;
            unsigned int maxHolesSingle = m_tightSingleStationCuts ? 0 : 1;
 
            ATH_MSG_DEBUG(" Single station track:  trigger phi " << stData.nphiTrigHits << " eta " << stData.netaTrigHits << " cut "
                                                                 << nExpectedTriggerStations << " holes " << stData.netaHoles << " cut "
                                                                 << maxHolesSingle);
 
            bool ok = true;
            // require two multi layers in MDT
            if (nTwoMlStations == 0) ok = false;
 
            // require all three trigger layers
            if (stData.nphiTrigHits < nExpectedTriggerStations || stData.netaTrigHits < nExpectedTriggerStations) ok = false;
 
            // no holes
            if (stData.netaHoles > maxHolesSingle) ok = false;
 
            if (!ok) {
                ATH_MSG_DEBUG(" Track discarded: failed single track cuts ");
                ++m_failedSingleStationCut;
            }
            return ok;
        }
 
        if (nGoodStations < 2) {
            ATH_MSG_DEBUG(" Track discarded: too few good stations " << nGoodStations);
            ++m_failedTwoStationsCut;
            return false;
        }
 
        if (m_countMdtOutliersAsHoles) mdtHoles += mdtOutliers;
 
        if (nstations < 3) {
            if (mdtHoles > m_maxMdtHolesPerTwoStationTrack) {
                ATH_MSG_DEBUG(" Track discarded: good stations " << nGoodStations << " and " << mdtHoles << " mdt holes ");
                ++m_failedTwoStationsMaxMDTHoleCut;
                return false;
            }
            if (nholes > m_maxMdtHolesPerTwoStationTrack) {
                ATH_MSG_DEBUG(" Track discarded: good stations " << nGoodStations << " and " << nholes << " holes ");
                ++m_failedTwoStationsMaxHoleCut;
                return false;
            }
            if (nTwoMlStations == 0 && nGoodCscStations == 0) {
                ATH_MSG_DEBUG(" Track discarded: good stations "
                              << nGoodStations << " but no MDT station with hits in two multilayers nor good CSC station ");
                ++m_failedTwoStationsGoodStationCut;
                return false;
            }
            if (m_removeTwoStationTrackWithoutTriggerHits && nGoodTriggerStations == 0) {
                ATH_MSG_DEBUG(" Track discarded: stations " << nstations << " but no trigger hits nor good CSC station ");
                ++m_failedTriggerStationCut;
                return false;
            }
        } else {
            if (mdtHoles > m_maxMdtHolesPerTrack) {
                ATH_MSG_DEBUG(" Track discarded: good stations " << nGoodStations << " and " << mdtHoles << " mdt holes ");
                ++m_failedMaxMDTHoleCut;
                return false;
            }
            if (nholes > m_maxMdtHolesPerTrack) {
                ATH_MSG_DEBUG(" Track discarded: good stations " << nGoodStations << " and " << nholes << " holes ");
                ++m_failedMaxHoleCut;
                return false;
            }
        }
 
        ATH_MSG_DEBUG(" Track passed selection ");
 
        return true;
    }

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

finalize()

StatusCode Muon::MuonTrackSelectorTool::finalize

(

)

AlgTool finalize.

Definition at line 31 of file MuonTrackSelectorTool.cxx.

                                               {
        // print counters
        ATH_MSG_INFO(" Number of tracks handled by selector " << m_ntotalTracks);
        if (m_ntotalTracks != 0) {
            double failedChi2NDofCutFraction = (double)m_failedChi2NDofCut / (double)m_ntotalTracks;
            double failedRPCAveMinTimeCutFraction = (double)m_failedRPCAveMinTimeCut / (double)m_ntotalTracks;
            double failedRPCAveMaxTimeCutFraction = (double)m_failedRPCAveMaxTimeCut / (double)m_ntotalTracks;
            double failedRPCSpreadTimeCutFraction = (double)m_failedRPCSpreadTimeCut / (double)m_ntotalTracks;
            double failedSingleStationsCutFraction = (double)m_failedSingleStationCut / (double)m_ntotalTracks;
            double failedTwoStationsCutFraction = (double)m_failedTwoStationsCut / (double)m_ntotalTracks;
            double failedTwoStationsMaxMDTHoleCutFraction = (double)m_failedTwoStationsMaxMDTHoleCut / (double)m_ntotalTracks;
            double failedTwoStationsMaxHoleCutFraction = (double)m_failedTwoStationsMaxHoleCut / (double)m_ntotalTracks;
            double failedTwoStationsGoodStationCutFraction = (double)m_failedTwoStationsGoodStationCut / (double)m_ntotalTracks;
            double failedTriggerStationCutFraction = (double)m_failedTriggerStationCut / (double)m_ntotalTracks;
            double failedMaxMDTHoleCutFraction = (double)m_failedMaxMDTHoleCut / (double)m_ntotalTracks;
            double failedMaxHoleCutFraction = (double)m_failedMaxHoleCut / (double)m_ntotalTracks;
            ATH_MSG_INFO(" Fractions failing selection cuts: "
                         << endmsg << std::setw(30) << " Chi2/Ndof Cut                 " << failedChi2NDofCutFraction << endmsg
                         << std::setw(30) << " RPC AveMin Time Cut           " << failedRPCAveMinTimeCutFraction << endmsg << std::setw(30)
                         << " RPC AveMax Time Cut           " << failedRPCAveMaxTimeCutFraction << endmsg << std::setw(30)
                         << " RPC Spread Time Cut           " << failedRPCSpreadTimeCutFraction << endmsg << std::setw(30)
                         << " Single station Cut            " << failedSingleStationsCutFraction << endmsg << std::setw(30)
                         << " Two station Cut               " << failedTwoStationsCutFraction << endmsg << std::setw(30)
                         << " Two station Max MDT hole Cut  " << failedTwoStationsMaxMDTHoleCutFraction << endmsg << std::setw(30)
                         << " Two station Max hole Cut      " << failedTwoStationsMaxHoleCutFraction << endmsg << std::setw(30)
                         << " Two station good station Cut  " << failedTwoStationsGoodStationCutFraction << endmsg << std::setw(30)
                         << " Trigger station cut           " << failedTriggerStationCutFraction << endmsg << std::setw(30)
                         << " MDT hole Cut                  " << failedMaxMDTHoleCutFraction << endmsg << std::setw(30)
                         << " Max hole Cut                  " << failedMaxHoleCutFraction);
        }
 
        return StatusCode::SUCCESS;
    }

holesInChamber()

std::vector< Identifier > Muon::MuonTrackSelectorTool::holesInChamber	(	const Trk::TrackParameters &	pars,
		const Identifier &	chId,
		const std::set< Identifier > &	tubeIds ) const

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

initialize()

StatusCode Muon::MuonTrackSelectorTool::initialize

(

)

AlgTool initilize.

Definition at line 23 of file MuonTrackSelectorTool.cxx.

                                                 {
        ATH_CHECK(m_edmHelperSvc.retrieve());
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_trackSummaryTool.retrieve());
 
        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.

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

m_chi2NDofCut

Gaudi::Property<double> Muon::MuonTrackSelectorTool::m_chi2NDofCut {this, "Chi2NDofCut", 20}

private

Definition at line 70 of file MuonTrackSelectorTool.h.

{this, "Chi2NDofCut", 20};

m_countMdtOutliersAsHoles

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_countMdtOutliersAsHoles {this, "CountMDTOutlierAsHoles", false}

private

Definition at line 83 of file MuonTrackSelectorTool.h.

{this, "CountMDTOutlierAsHoles", false};

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::MuonTrackSelectorTool::m_edmHelperSvc

private

Initial value:

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

EDM Helper tool.

Definition at line 61 of file MuonTrackSelectorTool.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_failedChi2NDofCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedChi2NDofCut {0}

mutableprivate

Definition at line 113 of file MuonTrackSelectorTool.h.

{0};

m_failedMaxHoleCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedMaxHoleCut {0}

mutableprivate

Definition at line 124 of file MuonTrackSelectorTool.h.

{0};

m_failedMaxMDTHoleCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedMaxMDTHoleCut {0}

mutableprivate

Definition at line 123 of file MuonTrackSelectorTool.h.

{0};

m_failedRPCAveMaxTimeCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedRPCAveMaxTimeCut {0}

mutableprivate

Definition at line 116 of file MuonTrackSelectorTool.h.

{0};

m_failedRPCAveMinTimeCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedRPCAveMinTimeCut {0}

mutableprivate

Definition at line 115 of file MuonTrackSelectorTool.h.

{0};

m_failedRPCSpreadTimeCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedRPCSpreadTimeCut {0}

mutableprivate

Definition at line 117 of file MuonTrackSelectorTool.h.

{0};

m_failedSingleStationCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedSingleStationCut {0}

mutableprivate

Definition at line 114 of file MuonTrackSelectorTool.h.

{0};

m_failedTriggerStationCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedTriggerStationCut {0}

mutableprivate

Definition at line 122 of file MuonTrackSelectorTool.h.

{0};

m_failedTwoStationsCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedTwoStationsCut {0}

mutableprivate

Definition at line 118 of file MuonTrackSelectorTool.h.

{0};

m_failedTwoStationsGoodStationCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedTwoStationsGoodStationCut {0}

mutableprivate

Definition at line 121 of file MuonTrackSelectorTool.h.

{0};

m_failedTwoStationsMaxHoleCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedTwoStationsMaxHoleCut {0}

mutableprivate

Definition at line 120 of file MuonTrackSelectorTool.h.

{0};

m_failedTwoStationsMaxMDTHoleCut

std::atomic_uint Muon::MuonTrackSelectorTool::m_failedTwoStationsMaxMDTHoleCut {0}

mutableprivate

Definition at line 119 of file MuonTrackSelectorTool.h.

{0};

m_holeHitRatioCutPerStation

Gaudi::Property<double> Muon::MuonTrackSelectorTool::m_holeHitRatioCutPerStation {this, "HolesToHitsRatioCutPerStation", 1.1}

private

Definition at line 69 of file MuonTrackSelectorTool.h.

{this, "HolesToHitsRatioCutPerStation", 1.1};

m_idHelperSvc

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

private

Definition at line 60 of file MuonTrackSelectorTool.h.

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

m_ignoreTriggerHolesInLayersWithHits

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_ignoreTriggerHolesInLayersWithHits {this, "IgnoreTriggerHolesInChamberWithHits", true}

private

Definition at line 80 of file MuonTrackSelectorTool.h.

{this, "IgnoreTriggerHolesInChamberWithHits", true};

m_maxMdtHolesPerTrack

Gaudi::Property<unsigned int> Muon::MuonTrackSelectorTool::m_maxMdtHolesPerTrack {this, "MaxMdtHolesOnTrack", 5}

private

Definition at line 73 of file MuonTrackSelectorTool.h.

{this, "MaxMdtHolesOnTrack", 5};

m_maxMdtHolesPerTwoStationTrack

Gaudi::Property<unsigned int> Muon::MuonTrackSelectorTool::m_maxMdtHolesPerTwoStationTrack {this, "MaxMdtHolesOnTwoStationTrack", 5}

private

Definition at line 72 of file MuonTrackSelectorTool.h.

{this, "MaxMdtHolesOnTwoStationTrack", 5};

m_minCscHitsPerStation

Gaudi::Property<unsigned int> Muon::MuonTrackSelectorTool::m_minCscHitsPerStation {this, "MinimumNumberOfCscHitsPerStation", 3 }

private

Definition at line 74 of file MuonTrackSelectorTool.h.

{this, "MinimumNumberOfCscHitsPerStation", 3 };

m_minMdtHitsPerStation

Gaudi::Property<unsigned int> Muon::MuonTrackSelectorTool::m_minMdtHitsPerStation {this, "MinimumNumberOfMdtHitsPerStation", 3}

private

Definition at line 71 of file MuonTrackSelectorTool.h.

{this, "MinimumNumberOfMdtHitsPerStation", 3};

m_ntotalTracks

std::atomic_uint Muon::MuonTrackSelectorTool::m_ntotalTracks {0}

mutableprivate

counter for statistics

Definition at line 112 of file MuonTrackSelectorTool.h.

{0};

m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> Muon::MuonTrackSelectorTool::m_printer

private

Initial value:

{this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
                                                       "helper to nicely print out tracks"}

Definition at line 64 of file MuonTrackSelectorTool.h.

                                                          {this, "EDMPrinter", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
                                                       "helper to nicely print out tracks"};

m_removeSingleStationTracks

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_removeSingleStationTracks {this, "RemoveSingleStationTracks", false}

private

Definition at line 84 of file MuonTrackSelectorTool.h.

{this, "RemoveSingleStationTracks", false};

m_removeTwoStationTrackWithoutTriggerHits

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_removeTwoStationTrackWithoutTriggerHits {this, "RemoveTwoStationTrackWithoutTriggerHits", false}

private

Definition at line 82 of file MuonTrackSelectorTool.h.

{this, "RemoveTwoStationTrackWithoutTriggerHits", false};

m_requireSanePerigee

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_requireSanePerigee

private

Initial value:

{this,"RequireSanePerigee", true, 
                                                  "Ensures that the covariance of the perigee parameters has a positive trace"}

Definition at line 87 of file MuonTrackSelectorTool.h.

                                                {this,"RequireSanePerigee", true, 
                                                  "Ensures that the covariance of the perigee parameters has a positive trace"};

m_tightSingleStationCuts

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_tightSingleStationCuts {this, "TightSingleStationCuts", false}

private

Definition at line 85 of file MuonTrackSelectorTool.h.

{this, "TightSingleStationCuts", false};

m_trackSummaryTool

ToolHandle<Trk::ITrackSummaryHelperTool> Muon::MuonTrackSelectorTool::m_trackSummaryTool

private

Initial value:

{this, "TrackSummaryHelperTool",
                                                                    "Muon::MuonTrackSummaryHelperTool/MuonTrackSummaryHelperTool"}

Definition at line 66 of file MuonTrackSelectorTool.h.

                                                                 {this, "TrackSummaryHelperTool",
                                                                    "Muon::MuonTrackSummaryHelperTool/MuonTrackSummaryHelperTool"};

m_useCSCHoles

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_useCSCHoles {this, "UseCSCHoles", true}

private

Definition at line 78 of file MuonTrackSelectorTool.h.

{this, "UseCSCHoles", true};

m_useMDTHoles

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_useMDTHoles {this, "UseMDTHoles", true}

private

Definition at line 79 of file MuonTrackSelectorTool.h.

{this, "UseMDTHoles", true};

m_useRPCHoles

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_useRPCHoles {this, "UseRPCHoles", true}

private

Definition at line 76 of file MuonTrackSelectorTool.h.

{this, "UseRPCHoles", true};

m_useRPCTimeWindow

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_useRPCTimeWindow {this, "ApplyRPCTimeWindow", false}

private

Definition at line 81 of file MuonTrackSelectorTool.h.

{this, "ApplyRPCTimeWindow", false};

m_useTGCHoles

Gaudi::Property<bool> Muon::MuonTrackSelectorTool::m_useTGCHoles {this, "UseTGCHoles", true}

private

Definition at line 77 of file MuonTrackSelectorTool.h.

{this, "UseTGCHoles", true};

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:

• MuonTrackSelectorTool.h
• MuonTrackSelectorTool.cxx