HistHandler.h

Go to the documentation of this file.

/*
 Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef MUONEFFICIENCYCORRECTIONS_HISTOHANDLER_H
#define MUONEFFICIENCYCORRECTIONS_HISTOHANDLER_H
 
// EDM include(s):
#include "xAODMuon/Muon.h"
 
// supported SF histogram types
#include <TH1D.h>
#include <TH2D.h>
#include <TH3D.h>
#include <TH2Poly.h>
 
#include "CxxUtils/checker_macros.h"
#include "PATInterfaces/CorrectionCode.h"
// further ROOT includes
#include <TFile.h>
#include <TDirectory.h>
 
// STL includes
#include <string>
#include <iostream>
#include <exception>
#include <map>
#include <memory>
#include <cmath>
 
namespace CP {
    
    class AxisHandler;
   
    
    class HistHandler {
        public:
 
            inline  double GetBinContent(int bin) const{
                if (!m_H) return DBL_MAX;
                return m_H->GetBinContent(bin);
            }
            
            void SetBinContent(int bin, float val);
            
            inline  double GetBinError(int bin) const{
                if (!m_H) return DBL_MAX;
                return m_H->GetBinError(bin);
            }
            
            inline TH1* GetHist() const{
                return m_H.get();
            }
 
            void SetBinError(int bin, float val);
            
            virtual CorrectionCode FindBin(const xAOD::Muon & muon, int & bin) const = 0;
            virtual int nBins() const = 0;
            virtual int nOverFlowBins() const = 0;
            virtual bool isOverFlowBin(int b) const =0;
            virtual std::string GetBinName(unsigned int bin) const=0;
 
            virtual ~HistHandler();
        protected:
            HistHandler(TH1* Hist);
            HistHandler(const HistHandler & other);
            void Copy(const HistHandler & other);
        private:
            std::unique_ptr<TH1> m_H;
 
    };
 
    
 
    class HistHandler_TH1: public HistHandler {
 
        public:
 
            HistHandler_TH1(TH1* hist);
            HistHandler_TH1(const HistHandler_TH1 & other);
            virtual HistHandler_TH1 & operator =(const HistHandler_TH1 & other);
            virtual ~HistHandler_TH1();
 
             int nBins() const override;
             
             int nOverFlowBins() const override;
             bool isOverFlowBin(int b) const override;
 
 
             std::string GetBinName(unsigned int bin) const override;
             CorrectionCode FindBin(const xAOD::Muon & muon, int & bin) const override;
        private:
            std::unique_ptr<AxisHandler> m_x_handler;
    };
 
    class HistHandler_TH2: public HistHandler {
 
        public:
            HistHandler_TH2(TH1* hist);
            HistHandler_TH2(const HistHandler_TH2 & other);
            virtual HistHandler_TH2 & operator =(const HistHandler_TH2 & other);
            virtual ~HistHandler_TH2();
 
             int nBins() const override;
           
             int nOverFlowBins() const override;
             bool isOverFlowBin(int b) const override;
           
             std::string GetBinName(unsigned int bin) const override;
 
             CorrectionCode FindBin(const xAOD::Muon & muon, int & bin) const override;
        private:
            std::unique_ptr<AxisHandler> m_x_handler;
            std::unique_ptr<AxisHandler> m_y_handler;
    };
 
    class HistHandler_TH3: public HistHandler {
 
        public:
            
            HistHandler_TH3(TH1* hist);
            HistHandler_TH3(const HistHandler_TH3 & other);
            virtual HistHandler_TH3 & operator =(const HistHandler_TH3 & other);
            virtual ~HistHandler_TH3();
 
             int nBins() const override;
             
             int nOverFlowBins() const override;
             bool isOverFlowBin(int b) const override;
 
 
             std::string GetBinName(unsigned int bin) const override;
 
             CorrectionCode FindBin(const xAOD::Muon & muon, int & bin) const override;
 
        private:
            std::unique_ptr<AxisHandler> m_x_handler;
            std::unique_ptr<AxisHandler> m_y_handler;
            std::unique_ptr<AxisHandler> m_z_handler;
    };
 
    class HistHandler_TH2Poly: public HistHandler {
 
        public:
            HistHandler_TH2Poly(TH2Poly* hist);
            HistHandler_TH2Poly(const HistHandler_TH2Poly & other);
            virtual HistHandler_TH2Poly & operator =(const HistHandler_TH2Poly & other);
            virtual ~HistHandler_TH2Poly();
 
             int nOverFlowBins() const override;
             bool isOverFlowBin(int b) const override;
 
             int nBins() const override;
             std::string GetBinName(unsigned int bin) const override;
             CorrectionCode FindBin(const xAOD::Muon & muon, int & bin) const override;
 
        private:
            TH2Poly* m_h;
            std::unique_ptr<AxisHandler> m_x_handler;
            std::unique_ptr<AxisHandler> m_y_handler;
    };
 
    class AxisHandler {
        public:
            virtual CorrectionCode GetBinningParameter(const xAOD::Muon & mu, float & value) const =0;
            virtual ~AxisHandler()= default;
    };
    class AxisHandlerProvider {
        public:
            static std::unique_ptr<AxisHandler> GetAxisHandler(const TAxis* axis);
    };
 
    class PtAxisHandler: public AxisHandler {
        public:
            CorrectionCode GetBinningParameter(const xAOD::Muon & mu, float & value) const override;
            virtual ~PtAxisHandler() = default;
    };
 
    class ChargeAxisHandler: public AxisHandler {
        public:
            CorrectionCode GetBinningParameter(const xAOD::Muon & mu, float & value) const override;
            virtual ~ChargeAxisHandler() = default;
    };
    
    class EtaAxisHandler: public AxisHandler {
        public:
            CorrectionCode GetBinningParameter(const xAOD::Muon & mu, float & value) const override;
            virtual ~EtaAxisHandler() = default;
    };
    class AbsEtaAxisHandler: public AxisHandler {
        public:
            CorrectionCode GetBinningParameter(const xAOD::Muon & mu, float & value) const override; 
            virtual ~AbsEtaAxisHandler() = default;
    };
    class PhiAxisHandler: public AxisHandler {
        public:
            CorrectionCode GetBinningParameter(const xAOD::Muon & mu, float & value) const override;
            virtual ~PhiAxisHandler() = default;
    };
    class dRJetAxisHandler: public AxisHandler {
        public:
            dRJetAxisHandler();
            
            CorrectionCode GetBinningParameter(const xAOD::Muon & mu, float & value) const override;
            virtual ~dRJetAxisHandler() = default;
            
            //this method must be called only before any object creation, since it sets the static variable s_close_jet_decor, that is used only to initialize the m_acc member variable, and for nothing else; using it after object creation will not change the behaviour of the class
            static void set_close_jet_decorator(const std::string& decor_name);
            //this method must be called only before any object creation, since it sets the static variable s_use_2D_sf, that is used only to initialize the m_use_2D_sf member variable, and for nothing else; using it after object creation will not change the behaviour of the class
            static void set_use_2D_sf(const bool);
            
        private:
            //this static variable is safe because it is only used during object creation (to set the value of m_acc) and avoiding it would require a significant rewrite
            static std::string s_close_jet_decor ATLAS_THREAD_SAFE;
            //this static variable is safe because it is only used during object creation (to set the value of m_use_2D_sf) and avoiding it would require a significant rewrite
            static bool s_use_2D_sf ATLAS_THREAD_SAFE;
            
            SG::AuxElement::ConstAccessor<float> m_acc;
            bool m_use_2D_sf;
    };
    class UndefinedAxisHandler: public AxisHandler {
        public:
            CorrectionCode GetBinningParameter(const xAOD::Muon &, float &) const override;
            virtual ~UndefinedAxisHandler() = default;
    };
 
} // namespace CP
#endif