MuonCombined::MuonCandidateTool Class Reference

#include <MuonCandidateTool.h>

Inheritance diagram for MuonCombined::MuonCandidateTool:

Collaboration diagram for MuonCombined::MuonCandidateTool:

Public Member Functions
virtual	~MuonCandidateTool ()=default
virtual StatusCode	initialize () override
virtual void	create (const xAOD::TrackParticleContainer &tracks, MuonCandidateCollection &outputCollection, TrackCollection &outputTracks, const EventContext &ctx) const override
	IMuonCandidateTool interface: build a MuonCandidateCollection from a TrackCollection of spectrometer tracks. More...

Private Attributes
PublicToolHandle< Muon::MuonEDMPrinterTool >	m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
ToolHandle< Rec::ICombinedMuonTrackBuilder >	m_trackBuilder {this, "TrackBuilder", "", ""}
ToolHandle< Muon::IMuonTrackExtrapolationTool >	m_trackExtrapolationTool
ToolHandle< Trk::ITrackAmbiguityProcessorTool >	m_ambiguityProcessor
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}
ServiceHandle< Muon::IMuonIdHelperSvc >	m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
SG::ReadCondHandleKey< InDet::BeamSpotData >	m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}
SG::ReadHandleKey< Trk::SegmentCollection >	m_segmentKey {this, "SegmentContainer", ""}
	Retrieve the segment container to perform the segment association offline. More...
PublicToolHandle< MuonCombined::IMuonTrackToSegmentAssociationTool >	m_trackSegmentAssociationTool
Gaudi::Property< unsigned int >	m_extrapolationStrategy {this, "ExtrapolationStrategy", 0}
Gaudi::Property< bool >	m_commissioning

Detailed Description

Definition at line 25 of file MuonCandidateTool.h.

Constructor & Destructor Documentation

~MuonCandidateTool()

virtual MuonCombined::MuonCandidateTool::~MuonCandidateTool ( )

virtualdefault

Member Function Documentation

create()

void MuonCombined::MuonCandidateTool::create ( const xAOD::TrackParticleContainer &  tracks, MuonCandidateCollection &  outputCollection, TrackCollection &  outputTracks, const EventContext &  ctx  ) const

overridevirtual

IMuonCandidateTool interface: build a MuonCandidateCollection from a TrackCollection of spectrometer tracks.

Last but not least set the segments

Definition at line 41 of file MuonCandidateTool.cxx.

                                                                                                 {
        ATH_MSG_DEBUG("Producing MuonCandidates for " << tracks.size());
        unsigned int ntracks = 0;
 
        SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle{m_beamSpotKey, ctx};
        if (!beamSpotHandle.isValid()) {
            ATH_MSG_ERROR("Could not retrieve the BeamSpot data from key " << m_beamSpotKey.objKey());
            return;
        }
 
        ATH_MSG_DEBUG("Beamspot position bs_x=" << beamSpotHandle->beamPos());
 
        std::vector<track_link> trackLinks;
 
        unsigned int index = -1;
        // Loop over MS tracks
        for (const auto* track : tracks) {
            ++index;
 
            if (!track->trackLink().isValid() || !track->track()) {
                ATH_MSG_WARNING("MuonStandalone track particle without Trk::Track");
                continue;
            }
            const Trk::Track& msTrack = *track->track();
 
            ATH_MSG_VERBOSE("Re-Fitting track " << std::endl
                                                << m_printer->print(msTrack) << std::endl
                                                << m_printer->printStations(msTrack));
            std::unique_ptr<Trk::Track> standaloneTrack;
            if (m_extrapolationStrategy == 0u) {
                standaloneTrack = m_trackBuilder->standaloneFit(ctx, msTrack, beamSpotHandle->beamPos(), nullptr);
            } else {
                standaloneTrack = m_trackExtrapolationTool->extrapolate(msTrack, ctx);
            }
            if (standaloneTrack) {
                // Reject the track if its fit quality is much (much much) worse than that of the non-extrapolated track
                if (standaloneTrack->fitQuality()->doubleNumberDoF() == 0) {
                    standaloneTrack.reset();
                    ATH_MSG_DEBUG("extrapolated track has no DOF, don't use it");
                } else {
                    double mschi2 = 2.5;  // a default we should hopefully never have to use (taken from CombinedMuonTrackBuilder)
                    if (msTrack.fitQuality()->doubleNumberDoF() > 0)
                        mschi2 = msTrack.fitQuality()->chiSquared() / msTrack.fitQuality()->doubleNumberDoF();
                    // choice of 1000 is slightly arbitrary, the point is that the fit should be really be terrible
                    if (standaloneTrack->fitQuality()->chiSquared() / standaloneTrack->fitQuality()->doubleNumberDoF() > 1000 * mschi2) {
                        standaloneTrack.reset();
                        ATH_MSG_DEBUG("extrapolated track has a degraded fit, don't use it");
                    }
                }
            }
            if (standaloneTrack) {
                standaloneTrack->info().setParticleHypothesis(Trk::muon);
                standaloneTrack->info().setPatternRecognitionInfo(Trk::TrackInfo::MuidStandAlone);
                ATH_MSG_VERBOSE("Extrapolated track " << std::endl
                                                      << m_printer->print(*standaloneTrack) << std::endl
                                                      << m_printer->printStations(*standaloneTrack));
                ++ntracks;
                if (!standaloneTrack->perigeeParameters())
                    ATH_MSG_WARNING(" Track without perigee " << (*standaloneTrack));
                else if (!standaloneTrack->perigeeParameters()->covariance())
                    ATH_MSG_WARNING(" Track with perigee without covariance " << (*standaloneTrack));
                trackLinks.emplace_back(std::move(standaloneTrack), index, true);
            } else {
                // We can create tracks from EM segments+TGC hits
                // If these are not successfully extrapolated, they are too low quality to be useful
                // So only make candidates from un-extrapolated tracks if they are not EM-only
                bool skipTrack = true;
                const Trk::MuonTrackSummary* msMuonTrackSummary = nullptr;
                std::unique_ptr<Trk::TrackSummary> msTrackSummary;
                // If reading from an ESD, the track will not have a track summary yet
                if (!msTrack.trackSummary()) {
                    msTrackSummary = m_trackSummaryTool->summary(msTrack);
                    msMuonTrackSummary = msTrackSummary->muonTrackSummary();
                } else
                    msMuonTrackSummary = msTrack.trackSummary()->muonTrackSummary();
                for (const auto& chs : msMuonTrackSummary->chamberHitSummary()) {
                    using namespace Muon::MuonStationIndex;
                    if ((chs.isMdt() && m_idHelperSvc->stationIndex(chs.chamberId()) != StIndex::EM) ||
                        m_idHelperSvc->isCsc(chs.chamberId())) {
                        skipTrack = false;
                        break;
                    }
                }
                if (!skipTrack) { trackLinks.emplace_back(std::make_unique<Trk::Track>(msTrack), index, false); }
            }
        }
        std::unique_ptr<TrackCollection> extrapTracks = std::make_unique<TrackCollection>(SG::VIEW_ELEMENTS);
        extrapTracks->reserve(trackLinks.size());
        for (const track_link& link : trackLinks) extrapTracks->push_back(link.track.get());
        ATH_MSG_DEBUG("Finished back-tracking, total number of successfull fits " << ntracks);
 
        // Resolve ambiguity between extrapolated tracks (where available)
        std::unique_ptr<const TrackCollection> resolvedTracks(m_ambiguityProcessor->process(extrapTracks.get()));
 
        ATH_MSG_DEBUG("Finished ambiguity solving: " << extrapTracks->size() << " track(s) in -> " << resolvedTracks->size()
                                                     << " track(s) out");
 
        const Trk::SegmentCollection* segments{nullptr};
        if (!m_segmentKey.empty()) {
            SG::ReadHandle<Trk::SegmentCollection> readHandle{m_segmentKey, ctx};
            if (!readHandle.isValid()) {
                ATH_MSG_WARNING("Failed to retrieve the segment container " << m_segmentKey.fullKey());
            } else
                segments = readHandle.cptr();
        }
 
        // Loop over resolved tracks and build MuonCondidate collection
        for (const Trk::Track* track : *resolvedTracks) {
            std::vector<track_link>::iterator tLink =
                std::find_if(trackLinks.begin(), trackLinks.end(), [&track](const track_link& link) { return link.track.get() == track; });
 
            if (tLink == trackLinks.end()) {
                ATH_MSG_WARNING("Unable to find internal link between MS and SA tracks!");
                continue;
            }
 
            std::unique_ptr<MuonCandidate> muon_candidate;
            ElementLink<xAOD::TrackParticleContainer> MS_TrkLink{tracks, tLink->container_index, ctx};
            if (tLink->extp_succeed) {
                outputTracks.push_back(std::move(tLink->track));
                ElementLink<TrackCollection> saLink(outputTracks, outputTracks.size() - 1, ctx);
                muon_candidate = std::make_unique<MuonCandidate>(MS_TrkLink, saLink, outputTracks.size() - 1);
                // remove track from set so it is not deleted
            } else {
                // in this case the extrapolation failed
                muon_candidate = std::make_unique<MuonCandidate>(MS_TrkLink);
            }
            muon_candidate->setCommissioning(m_commissioning);
            if (segments) {
                std::vector<const Muon::MuonSegment*> assoc_segs;
                m_trackSegmentAssociationTool->associatedSegments(*muon_candidate->primaryTrack(), segments, assoc_segs);
                muon_candidate->setSegments(std::move(assoc_segs));
            }
 
            outputCollection.push_back(std::move(muon_candidate));
        }
    }

initialize()

StatusCode MuonCombined::MuonCandidateTool::initialize ( )

overridevirtual

Definition at line 28 of file MuonCandidateTool.cxx.

                                             {
        ATH_CHECK(m_printer.retrieve());
        ATH_CHECK(m_trackBuilder.retrieve(EnableTool{!m_trackBuilder.empty()}));
        ATH_CHECK(m_trackExtrapolationTool.retrieve(EnableTool{!m_trackExtrapolationTool.empty()}));
        ATH_CHECK(m_ambiguityProcessor.retrieve());
        ATH_CHECK(m_trackSummaryTool.retrieve());
        ATH_CHECK(m_idHelperSvc.retrieve());
        ATH_CHECK(m_beamSpotKey.initialize());
 
        ATH_CHECK(m_segmentKey.initialize(!m_segmentKey.empty()));
        ATH_CHECK(m_trackSegmentAssociationTool.retrieve(EnableTool{!m_segmentKey.empty()}));
        return StatusCode::SUCCESS;
    }

Member Data Documentation

m_ambiguityProcessor

ToolHandle<Trk::ITrackAmbiguityProcessorTool> MuonCombined::MuonCandidateTool::m_ambiguityProcessor

private

Initial value:

{this, "AmbiguityProcessor",
                                                                           "Trk::TrackSelectionProcessorTool/MuonAmbiProcessor"}

Definition at line 41 of file MuonCandidateTool.h.

m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> MuonCombined::MuonCandidateTool::m_beamSpotKey {this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot"}

private

Definition at line 47 of file MuonCandidateTool.h.

m_commissioning

Gaudi::Property<bool> MuonCombined::MuonCandidateTool::m_commissioning

private

Initial value:

{this, "Commissioning", false,
                                              "Flag deciding whether the candidate belongs to the comissioning."}

Definition at line 56 of file MuonCandidateTool.h.

m_extrapolationStrategy

Gaudi::Property<unsigned int> MuonCombined::MuonCandidateTool::m_extrapolationStrategy {this, "ExtrapolationStrategy", 0}

private

Definition at line 54 of file MuonCandidateTool.h.

m_idHelperSvc

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

private

Definition at line 45 of file MuonCandidateTool.h.

m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> MuonCombined::MuonCandidateTool::m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}

private

Definition at line 37 of file MuonCandidateTool.h.

m_segmentKey

SG::ReadHandleKey<Trk::SegmentCollection> MuonCombined::MuonCandidateTool::m_segmentKey {this, "SegmentContainer", ""}

private

Retrieve the segment container to perform the segment association offline.

Definition at line 50 of file MuonCandidateTool.h.

m_trackBuilder

ToolHandle<Rec::ICombinedMuonTrackBuilder> MuonCombined::MuonCandidateTool::m_trackBuilder {this, "TrackBuilder", "", ""}

private

Definition at line 38 of file MuonCandidateTool.h.

m_trackExtrapolationTool

ToolHandle<Muon::IMuonTrackExtrapolationTool> MuonCombined::MuonCandidateTool::m_trackExtrapolationTool

private

Initial value:

{this, "TrackExtrapolationTool",
                                                                               "ExtrapolateMuonToIPTool/ExtrapolateMuonToIPTool"}

Definition at line 39 of file MuonCandidateTool.h.

m_trackSegmentAssociationTool

PublicToolHandle<MuonCombined::IMuonTrackToSegmentAssociationTool> MuonCombined::MuonCandidateTool::m_trackSegmentAssociationTool

private

Initial value:

{
            this, "TrackSegmentAssociationTool", "MuonCombined::TrackSegmentAssociationTool/TrackSegmentAssociationTool"}

Definition at line 51 of file MuonCandidateTool.h.

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> MuonCombined::MuonCandidateTool::m_trackSummaryTool {this, "TrackSummaryTool", "MuonTrackSummaryTool"}

private

Definition at line 43 of file MuonCandidateTool.h.

---

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

• MuonCandidateTool.h
• MuonCandidateTool.cxx