MuonHoughHisto2D.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONHOUGHPATTERNEVENT_MUONHOUGHHISTO2D_H
#define MUONHOUGHPATTERNEVENT_MUONHOUGHHISTO2D_H
 
#include <AthenaBaseComps/AthMessaging.h>
#include <memory.h>
 
#include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <set>
#include <vector>
class TH2F;
 
class MuonHoughHisto2D: public AthMessaging {
public:
    ~MuonHoughHisto2D() = default;
    MuonHoughHisto2D(int nbinsx, double xmin, double xmax, int nbinsy, double ymin, double ymax, int number_of_maxima = 1);
 
    int fill(double x, double y, double weight = 1.);
 
    void fill(int binnumber, double weight = 1.);
 
    int getNbinsX() const;
    int getNbinsY() const;
 
    double getXmin() const;
    double getXmax() const;
 
    double getBinWidthX() const;
 
    double getBinWidthY() const;
 
    double getBinContent(int binnumber) const;
 
    void reset();
 
    void findMaxima();
 
    std::pair<int, double> getMax() const;
    std::pair<int, double> getMaximumBin(unsigned int maximum_number = 0);
    std::pair<double, double> getCoordsMaximum(unsigned int maximum_number = 0);
 
    bool checkIfMaximumAlreadyUsed(int binnumber) const;
    bool checkIfMaximum(int binnumber, double& maximum, int& maxbin) const;
 
    int distanceBins(int binnumber1, int binnumber2) const;
 
    double getMaximum(unsigned int maximum_number = 0);
    int getMaxBin(unsigned int maximum_number = 0);
 
    double content_Bin_Area(int binnumber) const;
 
    // histogram functions:
 
    std::pair<double, double> binnumberToCoords(int binnumber, int printlevel = 0) const;  // <x-point, y-point>
    double binnumberToXCoord(int binnumber) const;
    double binnumberToYCoord(int binnumber) const;
 
    int coordToBinnumber(double x, double y) const;
    int coordToBinx(double x) const;
    int coordToBiny(double y) const;
 
    int binInHistogram(unsigned int bin) const;
 
    void setThreshold(double threshold);
    double getThreshold() const;
 
    std::unique_ptr<TH2F> bookAndFillRootHistogram(const std::string& hname) const;
 
    void setMaximumIsValid(bool flag) { m_maximumIsValid = flag; }
 
private:
    void init();
 
    void resetHisto();
 
    std::unique_ptr<unsigned int []> m_histBuffer{};
    unsigned int m_size{0};
 
    unsigned int m_nbinsx{0};
    unsigned int m_nbinsx_plus2{0};
    double m_xmin{0};
    double m_xmax{0};
    unsigned int m_nbinsy{0};
    unsigned int m_nbinsy_plus2{0};
    double m_ymin{0.};
    double m_ymax{0.};
 
    double m_binwidthx{0.};
    double m_binwidthy{0.};
 
    double m_invbinwidthx{0.};
    double m_invbinwidthy{0.};
 
    std::set<int> m_bins_above_threshold{};
 
    std::vector<int> m_maximumbins{};
 
 
    const int m_number_of_maxima{0};
 
    unsigned int m_scale{0};  // conversion from double -> unsigned int
    unsigned int m_threshold{0};
 
    const int m_distance_to_next_maximum{0};
 
    bool m_maxima_found{false};
 
    int m_maximumBin{-1};
    unsigned int m_maximum{0};
    bool m_maximumIsValid{true};  // flag whether the maximum can be trusted
    void setBinContent(int binnumber, double value);
    void setBinContent(int binx, int biny, double value);
 
    MuonHoughHisto2D& operator=(const MuonHoughHisto2D& right);
    MuonHoughHisto2D(const MuonHoughHisto2D&);
};
 
inline int MuonHoughHisto2D::fill(double x, double y, double w) {
    int binnumber = coordToBinnumber(x, y);
    fill(binnumber, w);
    return binnumber;
}
 
inline void MuonHoughHisto2D::fill(int binnumber, double weight) {
    unsigned int& binval = m_histBuffer[binnumber];
    binval += m_scale * weight;
    if (binval > m_maximum) {
        m_maximum = binval;
        m_maximumBin = binnumber;
    }
}
inline void MuonHoughHisto2D::setBinContent(int binnumber, double value) { m_histBuffer[binnumber] = m_scale * value; }
inline double MuonHoughHisto2D::getBinContent(int binnumber) const { return m_histBuffer[binnumber] / m_scale; }
inline double MuonHoughHisto2D::content_Bin_Area(int binnumber) const { return getBinContent(binnumber); }
inline int MuonHoughHisto2D::getNbinsX() const { return m_nbinsx; }
inline int MuonHoughHisto2D::getNbinsY() const { return m_nbinsy; }
inline double MuonHoughHisto2D::getXmin() const { return m_xmin; }
inline double MuonHoughHisto2D::getXmax() const { return m_xmax; }
inline double MuonHoughHisto2D::getBinWidthX() const { return m_binwidthx; }
inline double MuonHoughHisto2D::getBinWidthY() const { return m_binwidthy; }
inline void MuonHoughHisto2D::setThreshold(double threshold) { m_threshold = m_scale * threshold; }
inline double MuonHoughHisto2D::getThreshold() const { return m_threshold; }
inline double MuonHoughHisto2D::getMaximum(unsigned int maximum_number) {
    return getMaximumBin(maximum_number).second;
}
inline int MuonHoughHisto2D::getMaxBin(unsigned int maximum_number) {
    return getMaximumBin(maximum_number).first;
}
inline int MuonHoughHisto2D::coordToBinx(double x) const { return static_cast<int>((x - m_xmin) * m_invbinwidthx) + 1; }
inline int MuonHoughHisto2D::coordToBiny(double y) const { return static_cast<int>((y - m_ymin) * m_invbinwidthy) + 1; }
inline int MuonHoughHisto2D::coordToBinnumber(double x, double y) const {
    int biny = coordToBiny(y);
    int binx = coordToBinx(x);
    return binx + biny * m_nbinsx_plus2;
}
inline double MuonHoughHisto2D::binnumberToXCoord(int binnumber) const {
    return m_xmin + m_binwidthx * (-0.5 + (binnumber) % m_nbinsx_plus2);
}
inline double MuonHoughHisto2D::binnumberToYCoord(int binnumber) const {
    return m_ymin + m_binwidthy * (-0.5 + (binnumber) / m_nbinsx_plus2);
}
inline void MuonHoughHisto2D::resetHisto() { memset(m_histBuffer.get(), 0, sizeof(unsigned int) * m_size); }
 
#endif  // MUONHOUGHPATTERNEVENT_MUONHOUGHHISTO2D_H