MuonR4::TrackSummaryTool Class Reference

#include <TrackSummaryTool.h>

Inheritance diagram for MuonR4::TrackSummaryTool:

Collaboration diagram for MuonR4::TrackSummaryTool:

Public Member Functions
virtual StatusCode	initialize () override final
virtual HitSummary	makeSummary (const EventContext &ctx, const ConstTrack_t trackProxy) const override final
virtual HitSummary	makeSummary (const EventContext &ctx, const std::vector< const xAOD::MuonSegment * > &segments) const override final
virtual HitSummary	makeSummary (const EventContext &ctx, const Trk::Track &track) const override final
virtual void	copySummary (const HitSummary &summary, const xAOD::IParticle &track) const override final

Private Types
using	Stat_t = HitSummary::Status

Private Member Functions
void	incrementSummary (const Identifier &hitId, const Stat_t status, const unsigned prdDim, HitSummary &summary) const
	Increments the hit summary based on the identifier extracted from the measurement.

Private Attributes
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "IdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
	IdHelperSvc to decode the Identifiers.
Gaudi::Property< bool >	m_fillHoles {this, "fillHoles", true}
	Toggle whether holes states shall be copied to the xAOD object.
Gaudi::Property< bool >	m_fillOutliers {this, "fillOutliers", true}
	Toggle whether outlier states shall be copied to the xAOD object.
Gaudi::Property< bool >	m_reDoSegments {this, "recomputeSegment", true}
	Toggle whether the segment summary shall be recomputed.

Detailed Description

Definition at line 20 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.h.

Member Typedef Documentation

Stat_t

using MuonR4::TrackSummaryTool::Stat_t = HitSummary::Status

private

Definition at line 38 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.h.

Member Function Documentation

copySummary()

void MuonR4::TrackSummaryTool::copySummary ( const HitSummary & summary, const xAOD::IParticle & track ) const

finaloverridevirtual

Precision hits

Trigger hits

Definition at line 187 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

                                                                         {
        ATH_MSG_DEBUG("Copy the summary \n "<<summary<<"\n pT: "<<(track.pt() * 1.e-3)
                      <<", eta: "<<track.eta()<<", phi: "<<track.phi());
        
        auto acc = [&track](const xAOD::MuonSummaryType type) -> std::uint8_t& {
            const std::string accName = SG::AuxTypeRegistry::instance().getName(
                xAOD::muonTrackSummaryAccessorV1(type).auxid());
            const SG::Decorator<std::uint8_t> dec{accName};
            return dec(track);
        };
        using enum xAOD::MuonSummaryType;
        acc(innerSmallHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Inner, true);
        acc(innerLargeHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Inner, false);
        acc(middleSmallHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Middle, true);
        acc(middleLargeHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Middle, false);
        acc(outerSmallHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Outer, true);
        acc(outerLargeHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Outer, false);
        acc(extendedSmallHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Extended, true);
        acc(extendedLargeHits) = summary.value(Cat_t::Precision, Stat_t::OnTrack, LayerIndex::Extended, false);
        if (m_fillHoles) {
            acc(innerSmallHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Inner, true);
            acc(innerLargeHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Inner, false);
            acc(middleSmallHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Middle, true);
            acc(middleLargeHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Middle, false);
            acc(outerSmallHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Outer, true);
            acc(outerLargeHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Outer, false);
            acc(extendedSmallHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Extended, true);
            acc(extendedLargeHoles) = summary.value(Cat_t::Precision, Stat_t::Hole, LayerIndex::Extended, false);
        }
        if (m_fillOutliers) {
            acc(innerOutBoundsPrecisionHits) = summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Inner, false)
                                             + summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Inner, true);
 
            acc(middleOutBoundsPrecisionHits) = summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Middle, false)
                                              + summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Middle, true);
 
            acc(outerOutBoundsPrecisionHits) = summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Outer, false)
                                             + summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Outer, true);
 
            acc(extendedOutBoundsPrecisionHits) = summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Extended, false)
                                                + summary.value(Cat_t::Precision, Stat_t::Outlier, LayerIndex::Extended, true);
        }

        acc(etaLayer1Hits) = summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Inner, true)
                           + summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Inner, false);
 
        acc(etaLayer2Hits) = summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Middle, true)
                           + summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Middle, false);
 
        acc(etaLayer3Hits) = summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Outer, true)
                          + summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Outer, false);
 
        acc(etaLayer4Hits) = summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Extended, true)
                           + summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, LayerIndex::Extended, false);
 
         if (m_fillHoles) {
            acc(etaLayer1Holes) = summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Inner, true)
                                + summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Inner, false);
 
            acc(etaLayer2Holes) = summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Middle, true)
                                + summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Middle, false);
 
            acc(etaLayer3Holes) = summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Outer, true)
                                + summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Outer, false);
 
            acc(etaLayer4Holes) = summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Extended, true)
                                + summary.value(Cat_t::TriggerEta, Stat_t::Hole, LayerIndex::Extended, false);
        }
        acc(phiLayer1Hits) = summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Inner, true)
                           + summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Inner, false);
 
        acc(phiLayer2Hits) = summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Middle, true)
                           + summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Middle, false);
 
        acc(phiLayer3Hits) = summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Outer, true)
                           + summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Outer, false);
 
        acc(phiLayer4Hits) = summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Extended, true)
                           + summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, LayerIndex::Extended, false);
        if (m_fillHoles) {
            acc(phiLayer1Holes) = summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Inner, true)
                                + summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Inner, false);
 
            acc(phiLayer2Holes) = summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Middle, true)
                                + summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Middle, false);
 
            acc(phiLayer3Holes) = summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Outer, true)
                                + summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Outer, false);
 
            acc(phiLayer4Holes) = summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Extended, true)
                                + summary.value(Cat_t::TriggerPhi, Stat_t::Hole, LayerIndex::Extended, false);
        }
    }     

incrementSummary()

void MuonR4::TrackSummaryTool::incrementSummary ( const Identifier & hitId, const Stat_t status, const unsigned prdDim, HitSummary & summary ) const

private

Increments the hit summary based on the identifier extracted from the measurement.

Parameters

hitId	Identifier from the measurement or the hole for which the summary needs to be incremented
status	Contribution of the measurement towards the track fit
prdDim	Dimension of the measurement 0 -> combined measurement (eta + phi), 2 (eta +phi)
summary	Reference to the summary where the counts shall be incremented

Hit is not a muon hit

Mdt twin tubes

Combined measurement or it's a 2D BI strip

Definition at line 66 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

                                                                       {
        using TechIdx = Muon::MuonStationIndex::TechnologyIndex;
        const TechIdx techIdx = m_idHelperSvc->technologyIndex(hitId);

        if (techIdx == TechIdx::TechnologyUnknown) {
            return;
        }
        const ChIndex chIdx = m_idHelperSvc->chamberIndex(hitId);
        const LayerIndex layer{toLayerIndex(chIdx)};
        const bool small{isSmall(chIdx)};
 
        Cat_t cat1{Cat_t::nCategories}, cat2{Cat_t::nCategories};
 
        if (techIdx == TechIdx::MDT || techIdx == TechIdx::MM) {
            cat1 = Cat_t::Precision;
            if (prdDim == 2){
                cat2 = Cat_t::TriggerPhi;
            }
        } else if (techIdx == TechIdx::RPC || techIdx == TechIdx::TGC) {
            if (prdDim == 0 || prdDim == 2) {
                cat1 = Cat_t::TriggerEta;
                cat2 = Cat_t::TriggerPhi;
            } else if (m_idHelperSvc->measuresPhi(hitId)) {
                cat1 = Cat_t::TriggerPhi;
            } else {
                cat1 = Cat_t::TriggerEta;
            }
        } else if (techIdx == TechIdx::STGC) {
            switch(m_idHelperSvc->stgcIdHelper().channelType(hitId)) {
                case sTgcIdHelper::sTgcChannelTypes::Pad:{
                    cat1 = Cat_t::sTgcPad;
                    break;
                } case sTgcIdHelper::sTgcChannelTypes::Wire: {
                    cat1 = Cat_t::TriggerPhi;
                    break;
                }  case sTgcIdHelper::sTgcChannelTypes::Strip:{
                    cat1 = Cat_t::Precision;
                    break;
                } default: {
                    ATH_MSG_ERROR(__FILE__ << ":" << __LINE__ << " Unknown stgc channel type");
                    break;
                }
            }            
        } else {
            ATH_MSG_ERROR(__FILE__ << ":" << __LINE__ << "  Unkown technology index "<<static_cast<int>(techIdx));
            return;
        }
 
        if (cat1 != Cat_t::nCategories){
            ATH_MSG_VERBOSE("Increment "<<summary.toString(cat1)<<", "<<summary.toString(status)<<", layer: "
                <<Muon::MuonStationIndex::layerName(layer)<<", small: "<<(small ? "yes" : "no"));
            ++summary.value(cat1, status, layer, small);
        }
        if (cat2 != Cat_t::nCategories) {
            ATH_MSG_VERBOSE("Increment "<<summary.toString(cat2)<<", "<<summary.toString(status)<<", layer: "
                    <<Muon::MuonStationIndex::layerName(layer)<<", small: "<<(small ? "yes" : "no"));
            ++summary.value(cat2, status, layer, small);
        }
    }

initialize()

StatusCode MuonR4::TrackSummaryTool::initialize ( )

finaloverridevirtual

Definition at line 24 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

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

makeSummary() [1/3]

HitSummary MuonR4::TrackSummaryTool::makeSummary ( const EventContext & ctx, const ConstTrack_t trackProxy ) const

finaloverridevirtual

Surface is not active

Definition at line 28 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

                                                                                   {
        HitSummary summary{};
        trackProxy.container().trackStateContainer().visitBackwards(trackProxy.tipIndex(), 
            [&](const auto& state){
                Stat_t status{Stat_t::OnTrack};
                if (state.typeFlags().isOutlier()){
                    status = Stat_t::Outlier;
                } else if (state.typeFlags().isHole()) {
                    status = Stat_t::Hole;
                }
                if (state.hasUncalibratedSourceLink()) {
                    const auto* uncalib = dynamic_cast<const xAOD::MuonMeasurement*>(xAODUncalibMeasCalibrator::unpack(state.getUncalibratedSourceLink()));
                    // for the combined sTgc space point we have to fill the primary and secondary measuremment seperately to resolve the strip/pad/wire combinations
                    if(uncalib->type() == xAOD::UncalibMeasType::sTgcStripType && uncalib->numDimensions() == 0){
                        const auto* combinedMeas = dynamic_cast<const xAOD::CombinedMuonStrip*>(uncalib);
                        incrementSummary(combinedMeas->primaryStrip()->identify(), status, combinedMeas->primaryStrip()->numDimensions(), summary);
                        incrementSummary(combinedMeas->secondaryStrip()->identify(), status, combinedMeas->secondaryStrip()->numDimensions(), summary);
                        
                    } else {
                        incrementSummary(uncalib->identify(), status, uncalib->numDimensions(), summary);
                    }
                } else if (state.hasReferenceSurface()) {
                    const Acts::Surface& surf{state.referenceSurface()};
                    const auto* detEl = dynamic_cast<const ActsTrk::IDetectorElementBase*>(surf.surfacePlacement());
                    if (!detEl) {
                        return;
                    }
                    incrementSummary(detEl->identify(), status, 1, summary);
                }
        });
        ATH_MSG_DEBUG("Obtained track summary from track with "<<Acts::toString(trackProxy.fourMomentum())
                      <<", q: "<<trackProxy.qOverP()
                      <<", chi2: "<<(trackProxy.chi2()/ std::max(trackProxy.nDoF(), 1u))
                      <<", nDoF: "<<trackProxy.nDoF()<<"\n"<<summary);
        return summary;                   
    }

makeSummary() [2/3]

HitSummary MuonR4::TrackSummaryTool::makeSummary ( const EventContext & ctx, const std::vector< const xAOD::MuonSegment * > & segments ) const

finaloverridevirtual

Definition at line 132 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

                                                                                                       {
        HitSummary summary{};
        for (const xAOD::MuonSegment* seg : segments) {
            const LayerIndex lay = toLayerIndex(seg->chamberIndex());
            const bool small = isSmall(seg->chamberIndex());
            if (!m_reDoSegments) {
                summary.value(Cat_t::Precision, Stat_t::OnTrack, lay, small) = seg->nPrecisionHits();
                summary.value(Cat_t::TriggerEta, Stat_t::OnTrack, lay, small) = seg->nTrigEtaLayers();
                summary.value(Cat_t::TriggerPhi, Stat_t::OnTrack, lay, small) = seg->nPhiLayers();
            } else {
                const std::size_t nHits = nMeasurements(*seg);
                for (std::size_t hit = 0; hit < nHits; ++hit) {
                    Stat_t state = isOutlierMeasurement(*seg, hit) ? Stat_t::Outlier : Stat_t::OnTrack;
                    const auto* uncalibMeas = dynamic_cast<const xAOD::MuonMeasurement*>(getMeasurement(*seg, hit));
                    // for the combined sTgc space point we have to fill the primary and secodnray measuremment seperately to resolve the strip/pad/wire combinations
                    if(uncalibMeas->type() == xAOD::UncalibMeasType::sTgcStripType && uncalibMeas->numDimensions() == 0){
                        const auto* combinedMeas = static_cast<const xAOD::CombinedMuonStrip*>(uncalibMeas);
                        incrementSummary(combinedMeas->primaryStrip()->identify(), state, combinedMeas->primaryStrip()->numDimensions(), summary);
                        incrementSummary(combinedMeas->secondaryStrip()->identify(), state, combinedMeas->secondaryStrip()->numDimensions(), summary);
                        
                    } else {
                        incrementSummary(uncalibMeas->identify(), state, uncalibMeas->numDimensions(), summary);
                    }
                }
            }
        }
        return summary;
    }

makeSummary() [3/3]

HitSummary MuonR4::TrackSummaryTool::makeSummary ( const EventContext & ctx, const Trk::Track & track ) const

finaloverridevirtual

Definition at line 161 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx.

                                                                          {
        HitSummary summary{};
        for (const Trk::TrackStateOnSurface* tsos : *track.trackStateOnSurfaces()) {
            using enum Trk::TrackStateOnSurface::TrackStateOnSurfaceType;
            if (tsos->type(Hole)){
                incrementSummary(tsos->surface().associatedDetectorElementIdentifier(),
                                 Stat_t::Hole, 1, summary);
                continue;
            } 
            const auto* meas = tsos->measurementOnTrack();
            if (!meas) {
                continue;
            }
            Stat_t state = tsos->type(Outlier) ? Stat_t::Outlier : Stat_t::OnTrack;
            if (const auto* rot = dynamic_cast<const Trk::RIO_OnTrack*>(meas); rot != nullptr) {
                incrementSummary(rot->identify(), state, 1, summary);
            } else if (const auto* rot = dynamic_cast<const Trk::CompetingRIOsOnTrack*>(meas); rot != nullptr) {
                for (unsigned n = 0; n <rot->numberOfContainedROTs(); ++n) {
                    incrementSummary(rot->rioOnTrack(n).identify(), state, 1, summary);
                }
            }
        }
        return summary;
    }

Member Data Documentation

m_fillHoles

Gaudi::Property<bool> MuonR4::TrackSummaryTool::m_fillHoles {this, "fillHoles", true}

private

Toggle whether holes states shall be copied to the xAOD object.

Definition at line 51 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.h.

{this, "fillHoles", true};

m_fillOutliers

Gaudi::Property<bool> MuonR4::TrackSummaryTool::m_fillOutliers {this, "fillOutliers", true}

private

Toggle whether outlier states shall be copied to the xAOD object.

Definition at line 53 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.h.

{this, "fillOutliers", true};

m_idHelperSvc

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

private

IdHelperSvc to decode the Identifiers.

Definition at line 49 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.h.

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

m_reDoSegments

Gaudi::Property<bool> MuonR4::TrackSummaryTool::m_reDoSegments {this, "recomputeSegment", true}

private

Toggle whether the segment summary shall be recomputed.

Definition at line 55 of file MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.h.

{this, "recomputeSegment", true};

---

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

• MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.h
• MuonSpectrometer/MuonPhaseII/MuonTrackBuilding/MuonTrackFindingTools/src/TrackSummaryTool.cxx