MuonR4::SegmentSelectionTool Class Reference

#include <SegmentSelectionTool.h>

Inheritance diagram for MuonR4::SegmentSelectionTool:

Collaboration diagram for MuonR4::SegmentSelectionTool:

Public Member Functions
virtual StatusCode	initialize () override final
virtual bool	passSeedingQuality (const EventContext &ctx, const xAOD::MuonSegment &segment) const override final
	Returns whether a segment provides enough mdt & phi measurements to use it for track finding seeding.
virtual bool	passTrackQuality (const EventContext &ctx, const xAOD::MuonSegment &segment) const override final
	Returns whether a segment passes the base selection quality in order to be picked up onto a track.
virtual bool	compatibleForTrack (const EventContext &ctx, const xAOD::MuonSegment &segA, const xAOD::MuonSegment &segB) const override final
	Returns whether two segments are compatible enough to be put both onto the track seed.

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.

Detailed Description

Definition at line 16 of file SegmentSelectionTool.h.

Member Function Documentation

compatibleForTrack()

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

finaloverridevirtual

Returns whether two segments are compatible enough to be put both onto the track seed.

Parameters

ctx	Event context to access conditions & geometry data
segment	Reference to the segment to consider

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 88 of file SegmentSelectionTool.cxx.

                                                                                     {
        if(segA.chamberIndex() == segB.chamberIndex() ||
           segA.etaIndex() * segB.etaIndex() < 0) {
            return false;
        }
        if (!segA.nPhiLayers() && !segB.nPhiLayers()) {
            return true;
        } 
        else if (segA.nPhiLayers() && !segB.nPhiLayers()) {
            if (!ExpandedSector{segA.position().phi()}.isNeighbour(
                 ExpandedSector{static_cast<unsigned>(segB.sector()), ExpandedSector::SectorProjector::center})){
                return false;
            }
        } else if (!segA.nPhiLayers() && segB.nPhiLayers()) {
            if (!ExpandedSector{segB.position().phi()}.isNeighbour(
                 ExpandedSector{static_cast<unsigned>(segA.sector()), ExpandedSector::SectorProjector::center})){
                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 15 of file SegmentSelectionTool.cxx.

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

passSeedingQuality()

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

finaloverridevirtual

Returns whether a segment provides enough mdt & phi measurements to use it for track finding seeding.

Parameters

ctx	Event context to access conditions & geometry data
segment	Reference to the segment to consider

Apply a minimal threshold on the rpc phi trigger hits

Apply another threshold on the TGC trigger hits

Definition at line 19 of file SegmentSelectionTool.cxx.

                                                                                        {
 
        switch (segment.technology()) {
            using enum TechnologyIndex;
            case MDT: {
                if (segment.nPrecisionHits() < m_nMdtSeedHitCut || 
                    segment.nPrecisionOutliers() > m_nMdtSeedOutlierCut){
                    return false;
                }
                const LayerIndex layIdx {toLayerIndex(segment.chamberIndex())};
                if (isBarrel(segment.chamberIndex())) {
                    switch (toLayerIndex(segment.chamberIndex())) {
                        using enum LayerIndex;
                        case Inner:
                        case BarrelExtended:
                            return segment.nPhiLayers() >= m_nRpcPhiSeedHitCutBI;
                        case Middle:
                            return segment.nPhiLayers() >= m_nRpcPhiSeedHitCutBM;
                        case Outer:
                            return segment.nPhiLayers() >= m_nRpcPhiSeedHitCutBO;
                        default:
                            break;
                    }
                } else {
                    switch (layIdx) {
                        using enum LayerIndex;
                        case Extended:
                            return true;
                        case Inner:
                            return segment.nPhiLayers() >= m_nTgcPhiSeedHitCutEI;
                        case Middle:
                            return segment.nPhiLayers() >= m_nTgcPhiSeedHitCutEM;
                        default:
                            break;
                    }
                }
                break;
            }
            case MM: {
                return segment.nPrecisionHits() >= m_nMmSeedMinHitCut;
            }
            case STGC: {
                return segment.nPrecisionHits() >= m_nStgcSeedMinHitCut;
            }
            default:
                break;
        }
        return false;
    }

passTrackQuality()

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

finaloverridevirtual

Returns whether a segment passes the base selection quality in order to be picked up onto a track.

Parameters

ctx	Event context to access conditions & geometry data
segment	Reference to the segment to consider

Definition at line 72 of file SegmentSelectionTool.cxx.

                                                                                      {
        switch (segment.technology()) {
            using enum TechnologyIndex;
            case MDT: {
                return segment.nPrecisionHits() >= m_nMdtMinHitCut;
            }
            case MM:
            case STGC:{
                return segment.nPrecisionHits() >= 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 35 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 39 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 37 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 47 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 43 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 41 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 49 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 51 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 53 of file SegmentSelectionTool.h.

{ this, "minRpcPhiSeedHitsBO", 1};

m_nStgcSeedMinHitCut

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

private

Definition at line 44 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 55 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 57 of file SegmentSelectionTool.h.

{this, "minTgcPhiSeedHitsEM", 2};

---

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

• SegmentSelectionTool.h
• SegmentSelectionTool.cxx