MuonHoughPatternTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONHOUGHPATTERNTOOLS_MUONHOUGHPATTERNTOOL_H
#define MUONHOUGHPATTERNTOOLS_MUONHOUGHPATTERNTOOL_H
 
#include <TFile.h>
#include <TH2.h>
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "MuonHoughPatternEvent/MuonHoughMathUtils.h"
#include "MuonRecToolInterfaces/IMuonHoughPatternTool.h"
 
class MuonHoughTransformSteering;
class MuonHoughTransformer;
 
class MuonHoughPatternTool : virtual public IMuonHoughPatternTool, public AthAlgTool {
public:
    MuonHoughPatternTool(const std::string& type, const std::string& name, const IInterface* parent);
    virtual ~MuonHoughPatternTool() = default;
 
    virtual void makePatterns(const MuonHoughHitContainer& hitcontainer, MuonHoughPatternContainerShip& houghpatterns) const override;
 
    virtual StatusCode initialize() override;
 
    virtual StatusCode finalize() override;
 
    virtual std::unique_ptr<MuonPrdPatternCollection> getPhiMuonPatterns(MuonHoughPatternContainerShip& houghpatterns) const override;
    virtual std::unique_ptr<MuonPrdPatternCollection> getEtaMuonPatterns(MuonHoughPatternContainerShip& houghpatterns) const override;
 
    virtual MuonHoughPatternContainerShip emptyHoughPattern() const override;
 
private:
    void makePatterns(int id_number, double weightmdt, const MuonHoughHitContainer& event,
                      MuonHoughPatternContainerShip& houghpatterns) const;
 
    std::unique_ptr<MuonPrdPatternCollection> getCurvedMuonPatterns(MuonHoughPatternContainerShip& houghpatterns) const;
 
    static void resetAssociation(const MuonHoughHitContainer& event);
 
    void useIPMuons();
 
    bool analyseHisto(int id_number, int level, const std::unique_ptr<MuonHoughHitContainer>& event_to_analyse,
                      std::unique_ptr<MuonHoughTransformSteering>& houghtransform, MuonHoughPatternContainerShip& houghpatterns) const;
 
    static bool hitsLeft(const MuonHoughHitContainer& event);
 
    int numberOfHits(const MuonHoughHitContainer& event) const;
 
    bool hitInHoughPattern(const std::shared_ptr<MuonHoughHit>& hit, const MuonHoughPatternContainer& houghpattern) const;
 
    static std::unique_ptr<MuonHoughHitContainer> hitsNotInPattern(const MuonHoughHitContainer& event, int id_number);
 
    void weightRescaling(const MuonHoughHitContainer& event, int id_number, int level) const;
 
    void calculateWeights(const MuonHoughHitContainer& event, double weightmdt) const;
 
    int overlapHoughPatterns(const MuonHoughPattern& houghpattern1, const MuonHoughPattern& houghpattern2) const;
 
    std::unique_ptr<MuonHoughHitContainer> whichEventHough(int id, const MuonHoughHitContainer& event, double weightmdt) const;
 
    std::unique_ptr<MuonHoughHitContainer> whichEventAssociation(int id, const MuonHoughHitContainer& event) const;
 
    std::unique_ptr<MuonHoughTransformSteering> whichHoughTransform(int id) const;
 
    std::vector<int> maxLevelHoughPattern(const MuonHoughPatternContainerShip& houghpattern) const;
 
    int maxLevelHoughPattern(const MuonHoughPatternContainerShip& houghpattern, int id_number) const;
 
    static void transformCoordsMaximum(std::pair<double, double>& coordsmaximum, double r0_true) ;
 
    std::unique_ptr<Muon::MuonPrdPattern> houghPatternToEtaPattern(const MuonHoughPattern& houghpattern) const;
    std::unique_ptr<Muon::MuonPrdPattern> houghPatternToPhiPattern(const MuonHoughPattern& houghpattern) const;
    std::unique_ptr<Muon::MuonPrdPattern> houghPatternsToOneEtaPattern(const MuonHoughPattern& houghpattern1,
                                                                       const MuonHoughPattern& houghpattern2) const;
    std::unique_ptr<Muon::MuonPrdPattern> houghPatternsToOnePhiPattern(const MuonHoughPattern& houghpattern1,
                                                                       const MuonHoughPattern& houghpattern2) const;
    std::unique_ptr<Muon::MuonPrdPattern> houghPatternToCleanPhiPattern(MuonHoughPattern& houghpattern) const;
 
    unsigned int getThresholdHoughPattern(int id_number) const;
    double getThresholdHisto(int id_number) const;
 
    void setWeightMdtCutValue(const MuonHoughHitContainer& event, double& weightmdt) const;
 
    bool hitThroughCut(const std::shared_ptr<MuonHoughHit>& hit, double weightmdt) const;
 
    std::unique_ptr<TFile> m_file;
    MuonHoughMathUtils m_muonhoughmathutils;
 
    Gaudi::Property<bool> m_use_histos{this, "UseHistos", false};
    Gaudi::Property<bool> m_use_cosmics{this, "UseCosmics", false};
    Gaudi::Property<bool> m_use_csc_in_pattern{this, "UseCscInPattern", true};
    Gaudi::Property<bool> m_use_csc_in_hough{this, "UseCscInHough", true};
    Gaudi::Property<bool> m_use_negative_weights{this, "UseNegativeWeights", false};
    Gaudi::Property<bool> m_use_curvedhough{this, "UseCurvedHough", true};
 
    int m_number_of_ids{7};
 
    Gaudi::Property<int> m_number_of_maxima{this, "NumberOfMaximaPerIterations", 5};
 
    // const bool m_use_rpc_measures_phi;
    static constexpr bool m_use_rpc_measures_eta{true};
    bool m_use_ip{false};
 
    Gaudi::Property<unsigned int> m_thresholdpattern_xyz{this, "SetThresholdPatternRPhi", 1};
    Gaudi::Property<unsigned int> m_thresholdpattern_rz{this, "SetThresholdPatternREta", 3};
 
    // hittosegment association:
 
    static constexpr double m_maximum_residu_mm{500.};
    static constexpr double m_maximum_residu_mm_cosmics{2000.};
    static constexpr double m_maximum_residu_angle{3.};
 
    static constexpr int m_maximum_level{5};
    // for hough_correction:
    // const bool m_use_hough_correction;
    static constexpr double m_z_cor_constant{-10000.};
    static constexpr double m_z_cor_constant2{6000.};
    static constexpr double m_theta_cor_constant{-0.042};
    static constexpr double m_theta_cor_constant2{4000.};
 
    // detectorsizes:
 
    double m_detectorsize_xy{0.};
    double m_detectorsize_yz{0.};
    double m_detectorsize_rz{0.};
    static constexpr double m_detectorsize_xy_full{15000.};
    static constexpr double m_detectorsize_yz_full{25000.};
    static constexpr double m_detectorsize_rz_full{27750.};
 
    static constexpr double m_detectorsize_xy_ip{600.};
    static constexpr double m_detectorsize_yz_ip{1000.};
    static constexpr double m_detectorsize_rz_ip{1500.};
 
    static constexpr double m_detectorsize_angle_xyz{360.};
    static constexpr double m_detectorsize_angle_rz{180.};
    // const double m_detectorsize_inv_sqrt_curvature;
 
    // properties of histograms:
 
    static constexpr double m_stepsize_xy{75.};
    static constexpr double m_stepsize_yz{250.};
    static constexpr double m_stepsize_rz{75.};
    static constexpr double m_stepsize_xy_cosmics{150.};
    static constexpr double m_stepsize_rz_cosmics{150.};
    static constexpr double m_stepsize_per_angle_xyz{0.25};
    static constexpr double m_stepsize_per_angle_rz{0.25};
    static constexpr double m_stepsize_per_angle_xy_cosmics{1.};
    static constexpr double m_stepsize_per_angle_rz_cosmics{2.};
    // const double m_stepsize_per_inv_sqrt_curvature;
 
    static constexpr int m_nbins_curved{160};
 
    Gaudi::Property<bool> m_weightcut{this, "ApplyWeightCut", true};
 
    Gaudi::Property<double> m_weight{this, "WeightCut", 0.25};  // cut all hits under 0.25
 
    Gaudi::Property<bool> m_weightcutmdt{this, "ApplyWeightCutMdt",
                                         true};  // cut all mdt hits under a certain weight (dependent on number of mdt hits in event
 
    Gaudi::Property<double> m_thresholdhisto_xyz{this, "SetThresholdHistoRPhi", 0.9};
    Gaudi::Property<double> m_thresholdhisto_rz{this, "SetThresholdHistoREta", 2.1};
 
    Gaudi::Property<int> m_number_of_sectors_xyz{this, "SetNumberOfSectorsRPhi", 12};
    Gaudi::Property<int> m_number_of_sectors_rz{this, "SetNumberOfSectorsREta", 16};
    int m_number_of_sectors_rz_cosmics{12};
 
    Gaudi::Property<int> m_printlevel{this, "Printlevel", 0};
 
    mutable std::atomic_uint m_ncalls{0};
 
    Gaudi::Property<int> m_maxNumberOfPhiHits{this, "MaximumNumberOfPhiHits", -1};
 
    void printPattern(Muon::MuonPrdPattern* muonpattern) const;
};
 
#endif  // MUONHOUGHPATTERNTOOLS_MUONHOUGHPATTERNTOOL_H