MuonR4::SegmentSelectionTool Class Reference

#include <SegmentSelectionTool.h>

Inheritance diagram for MuonR4::SegmentSelectionTool:

Collaboration diagram for MuonR4::SegmentSelectionTool:

Public Types
using	HitSummary = Segment::HitSummary

Public Member Functions
virtual StatusCode	initialize () override final
virtual bool	passSeedingQuality (const EventContext &ctx, const Segment &segment) const override final
virtual bool	passTrackQuality (const EventContext &ctx, const Segment &segment) const override final
virtual bool	compatibleForTrack (const EventContext &ctx, const Segment &segA, const Segment &segB) const override final

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	IdHelperSvc to decode the Identifiers.
Gaudi::Property< unsigned >	m_nMdtSeedHitCut {this, "minMdtSeedHits" , 4}
	Cut on minimum number of Mdt hits to consider the segment for seeding.
Gaudi::Property< unsigned >	m_nMdtMinHitCut {this, "minMdtHits" , 3}
	Cut on minimum number of Mdt hits to consider the segment for tracking.
Gaudi::Property< unsigned >	m_nNswMinHitCut {this, "minNswHits", 5}
	Minimum number of Nsw hits.
Gaudi::Property< unsigned >	m_nMmSeedMinHitCut {this, "minMMSeedHits", 6}
	Minimum number of Nsw hits for seeding.
Gaudi::Property< unsigned >	m_nStgcSeedMinHitCut {this, "minsTgcSeedHits", 6}
Gaudi::Property< unsigned >	m_nMdtSeedOutlierCut { this, "maxMdtOutliers", 15}
	Minimun.
Gaudi::Property< unsigned >	m_nRpcPhiSeedHitCutBI { this, "minRpcPhiSeedHitsBI", 2}
	Minimum number of Rpc phi hits in BI to consider the segment for seeding.
Gaudi::Property< unsigned >	m_nRpcPhiSeedHitCutBM { this, "minRpcPhiSeedHitsBM", 2}
	Minimum number of Rpc phi hits in BM to consider the segment for seeding.
Gaudi::Property< unsigned >	m_nRpcPhiSeedHitCutBO { this, "minRpcPhiSeedHitsBO", 1}
	Minimum number of Rpc phi hits in BO to consider the segment for seeding.
Gaudi::Property< unsigned >	m_nTgcPhiSeedHitCutEI {this, "minTgcPhiSeedHitsEI", 1}
	Minimum number of Tgc phi hits in EI to consider the segment for seeding.
Gaudi::Property< unsigned >	m_nTgcPhiSeedHitCutEM {this, "minTgcPhiSeedHitsEM", 2}
	Minimum number of Tgc phi hits in EM to consider the segment for seeding.
const Muon::MuonSectorMapping	m_sectorMap {}

Detailed Description

Definition at line 16 of file SegmentSelectionTool.h.

Member Typedef Documentation

HitSummary

using MuonR4::SegmentSelectionTool::HitSummary = Segment::HitSummary

Definition at line 19 of file SegmentSelectionTool.h.

Member Function Documentation

compatibleForTrack()

bool MuonR4::SegmentSelectionTool::compatibleForTrack ( const EventContext & ctx, const Segment & segA, const Segment & segB ) const

finaloverridevirtual

Segment is on the same spectrometer layer

If both segments don't have phi information, then they may be compatible

If one segment has phi information and the other doesn't then just check whether it's possible that the segment with phi is also in the same sector as the other

Both segments have phi information. Ensure that their phi is within 5 degrees

Accept only segments that are 5 degree apart

Definition at line 86 of file SegmentSelectionTool.cxx.

                                                                             {
        if(segA.msSector() == segB.msSector()) {
            return false;
        }
        const HitSummary& sumA = segA.summary();
        const HitSummary& sumB = segB.summary();
        if (!sumA.nPhiHits && !sumB.nPhiHits) {
            return true;
        } 
        else if (sumA.nPhiHits && !sumB.nPhiHits) {
            if (!m_sectorMap.insideSector(segB.msSector()->sector(), segA.position().phi())){
                return false;
            }
        } else if (!sumA.nPhiHits && sumB.nPhiHits) {
            if (!m_sectorMap.insideSector(segA.msSector()->sector(), segB.position().phi())) {
                return false;
            }
        } 
        else {        
            const double dPhi = std::abs(segA.position().deltaPhi(segB.position()));
            if (dPhi > 5. * Gaudi::Units::deg) {
                return false;
            }
        }
        return true;
    }

initialize()

StatusCode MuonR4::SegmentSelectionTool::initialize ( )

finaloverridevirtual

Definition at line 16 of file SegmentSelectionTool.cxx.

                                               {
        ATH_CHECK(m_idHelperSvc.retrieve());
        return StatusCode::SUCCESS;
    } 

passSeedingQuality()

bool MuonR4::SegmentSelectionTool::passSeedingQuality ( const EventContext & ctx, const Segment & segment ) const

finaloverridevirtual

Apply a minimal threshold on the rpc phi trigger hits

Apply another threshold on the TGC trigger hits

Definition at line 20 of file SegmentSelectionTool.cxx.

                                                                                {
        const HitSummary& summary = segment.summary();
 
        switch (summary.tech) {
            case xAOD::UncalibMeasType::MdtDriftCircleType: {
                if (summary.nPrecHits < m_nMdtSeedHitCut || summary.nPrecOutlier > m_nMdtSeedOutlierCut){
                    return false;
                }
                const LayIdx_t layIdx {Muon::MuonStationIndex::toLayerIndex(segment.msSector()->chamberIndex())};
                if (segment.msSector()->barrel()) {
                    switch (layIdx) {
                        case LayIdx_t::Inner:
                        case LayIdx_t::BarrelExtended:
                            return summary.nPhiHits >= m_nRpcPhiSeedHitCutBI;
                        case LayIdx_t::Middle:
                            return summary.nPhiHits >= m_nRpcPhiSeedHitCutBM;
                        case LayIdx_t::Outer:
                            return summary.nPhiHits >= m_nRpcPhiSeedHitCutBO;
                        default:
                            break;
                    }
                } else {
                    switch (layIdx) {
                        case LayIdx_t::Extended:
                            return true;
                        case LayIdx_t::Inner:
                            return summary.nPhiHits >= m_nTgcPhiSeedHitCutEI;
                        case LayIdx_t::Middle:
                            return summary.nPhiHits >= m_nTgcPhiSeedHitCutEM;
                        default:
                            break;
                    }
                }
                break;
            }
            case xAOD::UncalibMeasType::MMClusterType: {
                return summary.nPrecHits >= m_nMmSeedMinHitCut;
            }
            case xAOD::UncalibMeasType::sTgcStripType:{
                return summary.nPrecHits >= m_nStgcSeedMinHitCut;
            }
            default:
                break;
        }
        return false;
    }

passTrackQuality()

bool MuonR4::SegmentSelectionTool::passTrackQuality ( const EventContext & ctx, const Segment & segment ) const

finaloverridevirtual

Definition at line 70 of file SegmentSelectionTool.cxx.

                                                                              {
        const HitSummary& summary = segment.summary();
        switch (summary.tech) {
            case xAOD::UncalibMeasType::MdtDriftCircleType: {
                return summary.nPrecHits >= m_nMdtMinHitCut;
            }
            case xAOD::UncalibMeasType::MMClusterType:
            case xAOD::UncalibMeasType::sTgcStripType:{
                return summary.nPrecHits >= m_nMdtMinHitCut;
            }
            default:
                break;
        }
        return false;
    }

Member Data Documentation

m_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonR4::SegmentSelectionTool::m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}

private

IdHelperSvc to decode the Identifiers.

Definition at line 34 of file SegmentSelectionTool.h.

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

m_nMdtMinHitCut

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nMdtMinHitCut {this, "minMdtHits" , 3}

private

Cut on minimum number of Mdt hits to consider the segment for tracking.

Definition at line 38 of file SegmentSelectionTool.h.

{this, "minMdtHits" , 3};

m_nMdtSeedHitCut

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nMdtSeedHitCut {this, "minMdtSeedHits" , 4}

private

Cut on minimum number of Mdt hits to consider the segment for seeding.

Definition at line 36 of file SegmentSelectionTool.h.

{this, "minMdtSeedHits" , 4};

m_nMdtSeedOutlierCut

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nMdtSeedOutlierCut { this, "maxMdtOutliers", 15}

private

Minimun.

Cont on maximum number of outlies to consider the segment for seeding

Definition at line 46 of file SegmentSelectionTool.h.

{ this, "maxMdtOutliers", 15};

m_nMmSeedMinHitCut

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nMmSeedMinHitCut {this, "minMMSeedHits", 6}

private

Minimum number of Nsw hits for seeding.

Definition at line 42 of file SegmentSelectionTool.h.

{this, "minMMSeedHits", 6};

m_nNswMinHitCut

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nNswMinHitCut {this, "minNswHits", 5}

private

Minimum number of Nsw hits.

Definition at line 40 of file SegmentSelectionTool.h.

{this, "minNswHits", 5};

m_nRpcPhiSeedHitCutBI

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nRpcPhiSeedHitCutBI { this, "minRpcPhiSeedHitsBI", 2}

private

Minimum number of Rpc phi hits in BI to consider the segment for seeding.

Definition at line 48 of file SegmentSelectionTool.h.

{ this, "minRpcPhiSeedHitsBI", 2};

m_nRpcPhiSeedHitCutBM

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nRpcPhiSeedHitCutBM { this, "minRpcPhiSeedHitsBM", 2}

private

Minimum number of Rpc phi hits in BM to consider the segment for seeding.

Definition at line 50 of file SegmentSelectionTool.h.

{ this, "minRpcPhiSeedHitsBM", 2};

m_nRpcPhiSeedHitCutBO

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nRpcPhiSeedHitCutBO { this, "minRpcPhiSeedHitsBO", 1}

private

Minimum number of Rpc phi hits in BO to consider the segment for seeding.

Definition at line 52 of file SegmentSelectionTool.h.

{ this, "minRpcPhiSeedHitsBO", 1};

m_nStgcSeedMinHitCut

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nStgcSeedMinHitCut {this, "minsTgcSeedHits", 6}

private

Definition at line 43 of file SegmentSelectionTool.h.

{this, "minsTgcSeedHits", 6};

m_nTgcPhiSeedHitCutEI

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nTgcPhiSeedHitCutEI {this, "minTgcPhiSeedHitsEI", 1}

private

Minimum number of Tgc phi hits in EI to consider the segment for seeding.

Definition at line 54 of file SegmentSelectionTool.h.

{this, "minTgcPhiSeedHitsEI", 1};

m_nTgcPhiSeedHitCutEM

Gaudi::Property<unsigned> MuonR4::SegmentSelectionTool::m_nTgcPhiSeedHitCutEM {this, "minTgcPhiSeedHitsEM", 2}

private

Minimum number of Tgc phi hits in EM to consider the segment for seeding.

Definition at line 56 of file SegmentSelectionTool.h.

{this, "minTgcPhiSeedHitsEM", 2};

m_sectorMap

const Muon::MuonSectorMapping MuonR4::SegmentSelectionTool::m_sectorMap {}

private

Definition at line 58 of file SegmentSelectionTool.h.

{};

---

The documentation for this class was generated from the following files:

• SegmentSelectionTool.h
• SegmentSelectionTool.cxx