MuonHoughPatternFinderTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONHOUGHPATTERNALGS_MUONHOUGHPATTERNFINDERTOOL_H
#define MUONHOUGHPATTERNALGS_MUONHOUGHPATTERNFINDERTOOL_H
 
#include <TFile.h>
#include <TH1.h>
 
#include <iostream>
#include <string>
#include <vector>
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "MuonIdHelpers/IMuonIdHelperSvc.h"
#include "MuonPattern/MuonPatternCollection.h"
#include "MuonPattern/MuonPatternCombinationCollection.h"
#include "MuonRecHelperTools/MuonEDMPrinterTool.h"
#include "MuonRecToolInterfaces/IMuonCombinePatternTool.h"
#include "MuonRecToolInterfaces/IMuonHoughPatternFinderTool.h"
#include "MuonRecToolInterfaces/IMuonHoughPatternTool.h"
#include "MuonSegment/MuonSegmentCombinationCollection.h"
#include "TrkDriftCircleMath/DriftCircle.h"
 
class MuonHoughHitContainer;
 
namespace Muon {
 
    class MuonHoughPatternFinderTool : virtual public IMuonHoughPatternFinderTool, public AthAlgTool {
    public:
 
        using PrepDataSet =  IMuonCombinePatternTool::PrepDataSet;
        using EtaPhiHitAssocMap = IMuonCombinePatternTool::EtaPhiHitAssocMap;
 
 
        MuonHoughPatternFinderTool(const std::string&, const std::string&, const IInterface*);
 
        virtual ~MuonHoughPatternFinderTool();
 
        virtual StatusCode initialize() override;
        virtual StatusCode finalize() override;
 
        using MuonPatternHoughPair = std::pair<std::unique_ptr<MuonPatternCombinationCollection>, std::unique_ptr<Muon::HoughDataPerSectorVec>>;
        
        MuonPatternHoughPair find(
            const std::vector<const MdtPrepDataCollection*>& mdtCols, const std::vector<const CscPrepDataCollection*>& cscCols,
            const std::vector<const TgcPrepDataCollection*>& tgcCols, const std::vector<const RpcPrepDataCollection*>& rpcCols,
            const MuonSegmentCombinationCollection* cscSegmentCombis, const EventContext& ctx) const override;
 
        MuonPatternHoughPair find(
            const MdtPrepDataContainer* mdtCont, const CscPrepDataContainer* cscCols, const TgcPrepDataContainer* tgcCont,
            const RpcPrepDataContainer* rpcCont, const sTgcPrepDataContainer* stgcCont, const MMPrepDataContainer* mmCont,
            const EventContext& ctx) const override;
 
    private:
        MuonPatternHoughPair find(const EventContext& ctx, 
                                  const std::vector<const MdtPrepDataCollection*>& mdtCols, 
                                  const std::vector<const CscPrepDataCollection*>& cscCols,
                                  const std::vector<const TgcPrepDataCollection*>& tgcCols, 
                                  const std::vector<const RpcPrepDataCollection*>& rpcCols,
                                  const std::vector<const sTgcPrepDataCollection*>& stgcCols,
                                  const std::vector<const MMPrepDataCollection*>& mmCols,
                                  const MuonSegmentCombinationCollection* cscSegmentCombis) const;
       
        template <class T> std::vector<const MuonPrepDataCollection<T>*> stdVec(const MuonPrepDataContainerT<T>* cont) const;
 
        std::unique_ptr<MuonHoughHitContainer> getAllHits(
            const std::vector<const MdtPrepDataCollection*>& mdtCols, const std::vector<const TgcPrepDataCollection*>& tgcCols, 
            const std::vector<const RpcPrepDataCollection*>& rpcCols, const MuonSegmentCombinationCollection* cscSegmentCombis, 
            std::map<int, std::vector<std::pair<int, int>>>& rpcmdtstationmap,
            std::map<int, std::vector<std::pair<int, int>>>& tgcmdtstationmap,
            EtaPhiHitAssocMap& phietahitassociation) const;
 
        std::unique_ptr<MuonPatternCombinationCollection> analyse( const EventContext& ctx,
            const MuonHoughHitContainer& hitcontainer,
            const EtaPhiHitAssocMap& phietahitassociation) const;
 
    private:
        void record(std::unique_ptr<MuonPrdPatternCollection>& patCol, const SG::WriteHandleKey<MuonPrdPatternCollection>& key,
                    const EventContext& ctx) const;
 
        void addRpcCollection(
            const RpcPrepDataCollection* rpc_coll, MuonHoughHitContainer& hitcontainer,
            std::map<int, std::vector<std::pair<int, int>>>& rpcmdtstationmap,
            EtaPhiHitAssocMap& phietahitassociation) const;
        
 
        void addMdtCollection(const MdtPrepDataCollection* mdt_coll, MuonHoughHitContainer& hitcontainer,
                              std::map<int, std::vector<std::pair<int, int>>>& rpcmdtstationmap,
                              std::map<int, std::vector<std::pair<int, int>>>& tgcmdtstationmap) const;
        void addCscCollection(
            const CscPrepDataCollection* csc_coll, MuonHoughHitContainer& hitcontainer,
            EtaPhiHitAssocMap& phietahitassociation) const;
        
        
     
        template <class CollContainer> void addCollection(const CollContainer& cont,
                                                          MuonHoughHitContainer& hitcontainer,
                                                          EtaPhiHitAssocMap& phietahitassociation) const;
        template <class CollContainer> void addCollections(const std::vector<const CollContainer*>& colls,
                                                          MuonHoughHitContainer& hitcontainer,
                                                          EtaPhiHitAssocMap& phietahitassociation) const;
 
        void addTgcCollection(
            const Muon::TgcPrepDataCollection*, MuonHoughHitContainer& hitcontainer,
            std::map<int, std::vector<std::pair<int, int>>>& tgcmdtstationmap,
            EtaPhiHitAssocMap& phietahitassociation) const;
 
        void fastSegmentFinder(TrkDriftCircleMath::DCVec& dcs, int& nl1, int& nl2, double& angleDif, std::vector<int>& sel) const;
 
        int calculateStationCode(const Identifier) const;
 
        void updateRpcMdtStationMap(const Identifier rpcid, int hit_begin, int hit_end,
                                    std::map<int, std::vector<std::pair<int, int>>>& rpcmdtstationmap) const;
 
        void updateTgcMdtStationMap(const Identifier tgcid, int hit_begin, int hit_end,
                                    std::map<int, std::vector<std::pair<int, int>>>& tgcmdtstationmap) const;
 
        int stationCode(const Identifier& id) const;
 
        static int stationCode(int stationname, int phi, int eta);
 
        static void addToStationMap(std::map<int, std::vector<std::pair<int, int>>>& stationmap,
                                    std::map<int, std::vector<std::pair<int, int>>>::iterator& it, int& stationcode, const int& hit_begin,
                                    const int& hit_end);
 
        ToolHandle<IMuonHoughPatternTool> m_muonHoughPatternTool{this, "muonHoughPatternTool",""};  
        ToolHandle<Muon::IMuonCombinePatternTool> m_muonCombinePatternTool{this, "muonCombinePatternTool",
                                                                           ""};  
        ServiceHandle<Muon::IMuonIdHelperSvc> m_idHelperSvc{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};
        PublicToolHandle<Muon::MuonEDMPrinterTool> m_printer{this, "printerTool", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool",
                                                       "ToolHandle for EDM printing of segments"};
 
        Gaudi::Property<bool> m_hit_reweights{this, "HitReweights", true};
        Gaudi::Property<bool> m_mdt_adc_cut{this, "MDT_ADC_cut", true};
        Gaudi::Property<int> m_mdt_adc_min{this, "MDT_ADC_value", 50};
        Gaudi::Property<bool> m_mdt_tdc_cut{this, "MDT_TDC_cut", true};
 
        Gaudi::Property<bool> m_use_rpc{this, "RPC", true};
        Gaudi::Property<bool> m_use_tgc{this, "TGC", true};
        Gaudi::Property<bool> m_use_csc{this, "CSC", true};
        Gaudi::Property<bool> m_use_mdt{this, "MDT", true};
        /*  use the micromega prepraw data */
        Gaudi::Property<bool> m_use_mm{this, "MM", true};
        /*  use the stgc prepraw data */
        Gaudi::Property<bool> m_use_stgc{this, "STGC", true};
        double m_weight_csc_on_segment{2.};
 
        Gaudi::Property<bool> m_showerskip{this, "ShowerSkipping", true};
        Gaudi::Property<double> m_showerskipperc{this, "ShowerSkipPercentage", 0.3};
 
        Gaudi::Property<bool> m_use_histos{this, "UseHistos", false};
 
        Gaudi::Property<bool> m_summary{this, "DoSummary", false};
 
        Gaudi::Property<bool> m_recordAllOutput{this, "RecordAll", false};
 
        Gaudi::Property<std::string> m_cscAssoOutputLocation{this, "PatCscSegAssMapOutputLocation", "MuonPatCscSegAssMap"};  // Not used
 
        // const MuonSegmentCombinationCollection* m_csc_segments;
 
        struct Hists {
            std::unique_ptr<TFile> m_file{};
            std::unique_ptr<TH1> m_weighthistogram{};
            std::unique_ptr<TH1> m_weighthistogrammdt{};
            std::unique_ptr<TH1> m_weighthistogramrpc{};
            std::unique_ptr<TH1> m_weighthistogramtgc{};
            std::unique_ptr<TH1> m_weighthistogramcsc{};
            std::unique_ptr<TH1> m_weighthistogramstgc{};
            std::unique_ptr<TH1> m_weighthistogrammm{};
            
        };
        std::unique_ptr<Hists> m_h;
        Hists& getHists() const;
 
        SG::WriteHandleKey<MuonPrdPatternCollection> m_CosmicPhiPatternsKey{this, "CosmicPhiKey", "CosmicPhiPatterns"};
        SG::WriteHandleKey<MuonPrdPatternCollection> m_CosmicEtaPatternsKey{this, "CosmicEtaPatterns", "CosmicEtaPatterns"};
        SG::WriteHandleKey<MuonPrdPatternCollection> m_COMBINED_PATTERNSKey{this, "PATTERNS", "COMBINED_PATTERNS"};
 
        std::map<int, int> m_RpcToMdtOuterStDict{};
        std::map<int, int> m_RpcToMdtInnerStDict{};
    };
 
}  // namespace Muon
 
#endif  // MUONHOUGHPATTERNALGS_MUONHOUGHPATTERNALG_H