SegmentSelectionTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#include "SegmentSelectionTool.h"
#include "xAODMuonPrepData/sTgcMeasurement.h"
 
namespace {
    using LayIdx_t = Muon::MuonStationIndex::LayerIndex;
 
    // std::string print(0)
}
 
 
namespace MuonR4{
 
    StatusCode SegmentSelectionTool::initialize(){
        ATH_CHECK(m_idHelperSvc.retrieve());
        return StatusCode::SUCCESS;
    } 
    bool SegmentSelectionTool::passSeedingQuality(const EventContext& /* ctx*/,
                                                  const Segment& segment) const {
        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;
    }
 
    bool SegmentSelectionTool::passTrackQuality(const EventContext& /*ctx*/,
                                                const Segment& segment) const {
        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;
    }
    bool SegmentSelectionTool::compatibleForTrack(const EventContext& /*ctx*/,
                                                  const Segment& segA,
                                                  const Segment& segB) const {
        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;
    }
 
}