MuonInDetToMuonSystemExtensionAlg.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONCOMBINEDALGS_MUONINDETSYSTEMEXTENSIONALG_H
#define MUONCOMBINEDALGS_MUONINDETSYSTEMEXTENSIONALG_H
 
#include <map>
#include <string>
 
#include "AthenaBaseComps/AthReentrantAlgorithm.h"
#include "GaudiKernel/ToolHandle.h"
#include "MuonCombinedEvent/CombinedFitTag.h"
#include "MuonCombinedEvent/InDetCandidateCollection.h"
#include "MuonCombinedEvent/InDetCandidateToTagMap.h"
#include "MuonDetDescrUtils/MuonSectorMapping.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonPrepRawData/MuonPrepDataContainer.h"
#include "MuonRecHelperTools/IMuonEDMHelperSvc.h"
#include "MuonRecToolInterfaces/HoughDataPerSec.h"
#include "MuonRecToolInterfaces/IMuonSystemExtensionTool.h"
#include "MuonSegment/MuonSegment.h"
#include "MuonSegmentMakerToolInterfaces/IMuonSegmentSelectionTool.h"
#include "MuonStationIndex/MuonStationIndex.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/WriteHandleKey.h"
 
class MuonInDetToMuonSystemExtensionAlg : public AthReentrantAlgorithm {
public:
    MuonInDetToMuonSystemExtensionAlg(const std::string& name, ISvcLocator* pSvcLocator);
    ~MuonInDetToMuonSystemExtensionAlg() = default;
 
    StatusCode initialize() override;
    StatusCode execute(const EventContext& ctx) const override;
 
private:
    SG::ReadHandleKey<InDetCandidateCollection> m_inputCandidate{this, "InputInDetCandidates", "InDetCandidates"};
 
    SG::WriteHandleKey<InDetCandidateCollection> m_bulkInDetCandKey{this, "WriteInDetCandidates", "InDetCandidatesSystemExtened"};
    SG::WriteHandleKey<InDetCandidateCollection> m_stauInDetCandKey{this, "WriteStauCandidates", ""};
 
    SG::ReadHandleKey<Muon::HoughDataPerSectorVec> m_houghDataPerSectorVecKey{this, "LayerHoughKey", "HoughDataPerSectorVec",
                                                                              "HoughDataPerSectorVec key"};
    SG::ReadHandleKey<Trk::SegmentCollection> m_segmentKey{this, "MuonSegmentLocation", "TrackMuonSegments",
                                                           "name of muon segment container"};
 
    PublicToolHandle<Muon::IMuonSegmentSelectionTool> m_segmentSelector{this, "MuonSegmentSelectionTool",
                                                                        "Muon::MuonSegmentSelectionTool/MuonSegmentSelectionTool"};
 
    ToolHandle<Muon::IMuonSystemExtensionTool> m_muonSystemExtensionTool{this, "MuonSystemExtensionTool", "", "Muon system extension tool"};
    SG::ReadHandleKey<MuonCombined::InDetCandidateToTagMap> m_combTagMap{this, "CombinedTagMap", "muidcoTagMap", "Combined muon tag map"};
 
    ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
 
    ServiceHandle<Muon::IMuonEDMHelperSvc> m_edmHelperSvc{this, "edmHelper", "Muon::MuonEDMHelperSvc/MuonEDMHelperSvc",
                                                          "Handle to the service providing the IMuonEDMHelperSvc interface"};
    struct MuidCoCache {
        const MuonCombined::InDetCandidate* id_trk{nullptr};
        const MuonCombined::CombinedFitTag* cmb_trk{nullptr};
        MuidCoCache(const MuonCombined::InDetCandidate* _id, const MuonCombined::CombinedFitTag* _cb) : id_trk{_id}, cmb_trk{_cb} {}
    };
    using MuidCoVector = std::vector<MuidCoCache>;
 
    struct InDetCandidateCache {
        const InDetCandidateCollection* input_candidates{nullptr};
 
        std::set<const MuonCombined::InDetCandidate*> excluded_trks;
        MuidCoVector tag_map;
        std::set<const Muon::MuonSegment*> combined_segs{};
 
        std::unique_ptr<InDetCandidateCollection> outputContainer = std::make_unique<InDetCandidateCollection>(SG::OWN_ELEMENTS);
 
        std::map<Muon::MuonStationIndex::DetectorRegionIndex, std::set<int>> hit_sectors;
 
        std::map<int, std::vector<double>> eta_seeds{};
 
        std::map<unsigned int, std::set<Identifier>> consumed_hits{};
 
        std::vector<const Muon::MuonSegment*> candidate_segments{};
    };
 
    Gaudi::Property<bool> m_restrictExtension{this, "UseOnlyHitSectors", false};
    Gaudi::Property<int> m_houghMin{this, "minHoughHits", 4, "Minimum number of hits required for a hough maximum to be accepted"};
 
    Gaudi::Property<int> m_segmentQuality{this, "segQuality", 1, "Quality cut on the segment."};
    Gaudi::Property<bool> m_excludeNSW{this, "noNSWforSeeding", false, "Ignore hits/segments from the NSW"};
    Gaudi::Property<float> m_extThreshold{this, "ExtensionPtThreshold", 2500};
    Gaudi::Property<bool> m_extendSAF{this, "ExtendSAF", false};
    Gaudi::Property<bool> m_extendBulk{this, "ExtendBulk", true};
 
    const Muon::MuonSectorMapping m_sector_mapping{};
 
    StatusCode selectCandidates(const EventContext& ctx, InDetCandidateCache& cache) const;
    StatusCode findHitSectors(const EventContext& ctx, InDetCandidateCache& output_cache) const;
    StatusCode findSegments(const EventContext& ctx, InDetCandidateCache& output_cache) const;
 
    bool hasMatchingSegment(const MuonCombined::InDetCandidate& id_cand, const InDetCandidateCache& cache) const;
    bool hasMatchingSeed(const MuonCombined::InDetCandidate& id_cand, const InDetCandidateCache& cache) const;
 
    StatusCode create(const EventContext& ctx, InDetCandidateCache& cache) const;
 
    StatusCode createStaus(const EventContext& ctx, const InDetCandidateCollection* ext_candidates, const MuidCoVector& tag_map) const;
    void maskHits(const Muon::MuonSegment* muon_seg, InDetCandidateCache& output_cache) const;
};
 
#endif