MuonHoughTransformer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONHOUGHPATTERNEVENT_MUONHOUGHTRANSFORMER_H
#define MUONHOUGHPATTERNEVENT_MUONHOUGHTRANSFORMER_H
 
#include <cmath>
#include <map>
 
#include "MuonHoughPatternEvent/MuonHoughHisto2DContainer.h"
#include "MuonHoughPatternEvent/MuonHoughHitContainer.h"
#include "MuonHoughPatternEvent/MuonHoughMathUtils.h"
#include "MuonHoughPatternEvent/MuonHoughPattern.h"
 
 
 
class MuonHoughTransformer: public AthMessaging {
public:
    virtual ~MuonHoughTransformer();
 
    virtual float weightHoughTransform(double r0) const = 0;
    virtual void fill(const MuonHoughHitContainer& event, bool subtract = false);
    virtual void fillHit(const std::shared_ptr<MuonHoughHit>& hit, double weight = 1.) = 0;
    virtual int fillHisto(double coord1, double coord2, double weight = 1., int sector = 0) = 0;
 
    std::unique_ptr<MuonHoughPattern> associateHitsToMaximum(const MuonHoughHitContainer& event, double residu_mm,
                                                             double residu_grad, int maximum_number) const;
 
    std::unique_ptr<MuonHoughPattern> associateHitsToCoords(const MuonHoughHitContainer& event, std::pair<double, double> coords, double residu_mm,
                                            double residu_angle, int sector = 0) const;  
                                            // residu_mm for id=0,1,2 ; residu_angle for id=3,4
 
    std::unique_ptr<MuonHoughPattern> associateHitsToBinnumber(const MuonHoughHitContainer& event, int binnumber, double maximum_residu_mm,
                                               double maximum_residu_angle, int sector = 0) const;
 
    void resetHisto();
    void useNegativeWeights(bool use_negative_weights);
 
    std::vector<std::pair<int, int> > getMaxima(int max_patterns) const;
 
    void setIP(bool ip_setting);
 
    const MuonHoughHisto2DContainer& histos() const { return m_histos; }
 
protected:
    MuonHoughTransformer(const std::string& tr_name, 
                         int nbins, int nbins_angle, double detectorsize, double detectorsize_angle, double threshold_histo,
                         int number_of_sectors = 1);
 
    virtual std::unique_ptr<MuonHoughPattern> hookAssociateHitsToMaximum(const MuonHoughHitContainer& event, std::pair<double, double> coordsmaximum,
                                                         double residu_mm, double residu_angle, int sector) const = 0;
 
    std::pair<double, double> getEndPointsFillLoop(double radius, double stepsize, int sector) const;
 
    virtual int sector(const std::shared_ptr<MuonHoughHit>& hit) const = 0;
 
    MuonHoughHisto2DContainer m_histos;
 
    double m_threshold_histo;
 
    unsigned int m_eventsize;
    double m_eventsize_weightfactor;
 
    bool m_add_weight_angle;
    double m_weight_constant_angle;
    bool m_add_weight_radius;
    double m_weight_constant_radius;
 
    bool m_use_negative_weights;
 
    MuonHoughMathUtils m_muonhoughmathutils;
 
    const int m_nbins;
    const int m_nbins_plus3;
    const int m_nbins_angle;
    const double m_detectorsize;
    const double m_detectorsize_angle;
    double m_binwidthx;
    double m_binwidthy;
 
    double m_stepsize;
    double m_stepsize_per_angle;
 
    bool m_ip_setting;
 
    const int m_number_of_sectors;
 
private:
    
    class maximaCompare {
    public:
        bool operator()(const std::pair<std::pair<int, int>, double>& lhs, const std::pair<std::pair<int, int>, double>& rhs) const {
            return lhs.second > rhs.second;
        }
    };
};
 
inline void MuonHoughTransformer::setIP(bool ip_setting) { m_ip_setting = ip_setting; }
inline void MuonHoughTransformer::useNegativeWeights(bool use_negative_weights) { m_use_negative_weights = use_negative_weights; }
 
#endif  // MUONHOUGHPATTERNEVENT_MUONHOUGHTRANSFORMER_H