MuonLayerHough.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONLAYERHOUGH_H
#define MUONLAYERHOUGH_H
 
#include <cmath>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
#include "MuonLayerHough/Hit.h"
#include "MuonLayerHough/MuonLayerHoughSelector.h"
#include "MuonStationIndex/MuonStationIndex.h"
 
class TH1;
 
namespace MuonHough {
    using HitVec = std::vector<std::shared_ptr<MuonHough::Hit>>;
    

    struct RegionDescriptor {
        
        using DetRegIdx = Muon::MuonStationIndex::DetectorRegionIndex;
        using ChIdx =  Muon::MuonStationIndex::ChIndex; 
        
        RegionDescriptor(int sector_, DetRegIdx region_, ChIdx chIndex_,
                         float referencePosition_, float yMinRange_, 
                         float yMaxRange_, float yBinSize_, float thetaStep_,
                         unsigned int nthetaSamples_) :
            sector{sector_},
            region{region_},
            chIndex{chIndex_},
            referencePosition{referencePosition_},
            yMinRange{yMinRange_},
            yMaxRange{yMaxRange_},
            yBinSize{yBinSize_},
            thetaStep{thetaStep_},
            nthetaSamples{nthetaSamples_} {}
        RegionDescriptor() = default;
 
        int sector{0};
        DetRegIdx region{DetRegIdx::DetectorRegionUnknown};
        ChIdx chIndex{ChIdx::ChUnknown};
        float referencePosition{0};
        float yMinRange{0};
        float yMaxRange{0};
        float yBinSize{0};
        float thetaStep{0};
        unsigned int nthetaSamples{1};
    };
    
    using RegionDescriptionVec =  std::vector<RegionDescriptor>;
 
    
    struct MuonLayerHough {
        
        using DetRegIdx = Muon::MuonStationIndex::DetectorRegionIndex;
        using ChIdx =  Muon::MuonStationIndex::ChIndex; 
        struct Maximum {
            Maximum() = default;
 
            float max{0.};    // value of the maximum
            float pos{0.};    // spacial position
            float theta{0.};  // angle
 
            float refpos{0.};   // reference position
            DetRegIdx refregion{DetRegIdx::DetectorRegionUnknown};   // reference region
            ChIdx refchIndex{ChIdx::ChUnknown};  // reference chamber index
 
            int binpos{-1};           // position bin
            int binposmin{-1};        // lower edge of the maximum
            int binposmax{-1};        // upper edge of the maximu
            float binsize{0.};        // size of bin
            int bintheta{-1};         // theta bin
            int triggerConfirmed{0};  // number of in time trigger hits associated with the maximum
            HitVec hits;   // vector of associated hits
 
            const MuonLayerHough* hough{nullptr};  // pointer to the corresponding hough
 
            bool isEndcap() const {
                // refers to the chamber orientation!!!! so BEE is a barell in this def
                DetRegIdx region = hough->m_descriptor.region;
                ChIdx chIndex = hough->m_descriptor.chIndex;
                // need to make sure BEE's reference plane is the same as barrel
                if (region != DetRegIdx::Barrel && chIndex != ChIdx::BEE) { return true; }
                return false;
            };
            float getGlobalR() const {
                if (isEndcap()) { return pos; }
                return refpos;
            };
            float getGlobalZ() const {
                if (isEndcap()) { return refpos; }
                return pos;
            };
            float getGlobalTheta() const {
                if (isEndcap()) {
                    // return M_PI/2.0 - theta;
                    if (theta > 0) {
                        return M_PI / 2.0 - theta;
                    } else {
                        return -M_PI / 2.0 - theta;
                    }
                }
                return theta;
            };
        };

        MuonLayerHough(const RegionDescriptor& descriptor);

        ~MuonLayerHough() = default;

        void reset();

        void setDebug(bool d) { m_debug = d; }

        int bin(const Hit& hit) const;

        int bin(float x, float y) const;

        float yval(int posBin) const;

        void pars(int posBin, int /*thetaBin*/, float& x, float& y) const;

        float layerConfirmation(const Hit& hit, float range = 1000.) const;

        float layerConfirmation(float x, float y, float range = 1000.) const;

        std::pair<float, float> layerConfirmation(unsigned int thetaBin, float x, float y, float range = 1000.) const;

        bool findMaximum(Maximum& maximum, const MuonLayerHoughSelector& selector) const;

        void associateHitsToMaximum(Maximum& maximum, const HitVec& hits) const;

        std::pair<int, int> range(const float x, const float y1, const float y2, const int bintheta) const;

        std::pair<float, float> maximum(float x, float y, int& posbin, int& thetabin) const;

        void fill(const Hit& hit);

        void fill(float x, float y, float weight);

        void fillLayer(const HitVec& hits, bool substract = false);
 
        //  fill the hough space with a vector of hits using the layer mode
        void fillLayer2(const HitVec& hits, bool subtract = false);

        std::vector<TH1*> rootHistos(const std::string& prefix, const float* rmin = 0, const float* rmax = 0) const;
 
        // members
 
        float m_binsize{0};     
        float m_invbinsize{0};  
 
        // unsigned int m_nthetasamples;
        int m_nbins{-1};
 
        unsigned int max{0};
        int maxhist{-1};
        int maxbin{-1};
        bool m_debug{false};
        std::vector<std::unique_ptr<unsigned int[]> > m_histos;  // the maximum contents of all the histograms, overlayed
        RegionDescriptor m_descriptor;
    };
 
    inline int MuonLayerHough::bin(const Hit& hit) const { return bin(hit.x, hit.ymin); }
 
    inline int MuonLayerHough::bin(float x, float y) const {
        float yref = y * (m_descriptor.referencePosition - x) / x + y;
        int in = (yref - m_descriptor.yMinRange) / m_binsize;
        if (in < 0 || in >= m_nbins) in = -1;
        return in;
    }
 
    inline void MuonLayerHough::pars(int posBin, int /*thetaBin*/, float& x, float& y) const {
        x = m_descriptor.referencePosition;
        y = yval(posBin);
    }
 
    inline float MuonLayerHough::yval(int posBin) const { return m_descriptor.yMinRange + posBin * m_binsize; }
 
    inline float MuonLayerHough::layerConfirmation(const Hit& hit, float range) const { return layerConfirmation(hit.x, hit.ymin, range); }
 
    inline void MuonLayerHough::fill(const Hit& hit) { fill(hit.x, hit.ymin, hit.w); }
 
    // function for linear/parabolic extrapolation from maxima to maxima in a different station
    float extrapolate(const MuonLayerHough::Maximum& ref, const MuonLayerHough::Maximum& ex, bool doparabolic = false);
}  // namespace MuonHough
#endif