EfficiencyScaleFactor.h

Go to the documentation of this file.

/*
 Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
#ifndef MUONEFFICIENCYCORRECITONS_EFFICIENCYSCALEFACTOR_H_
#define MUONEFFICIENCYCORRECITONS_EFFICIENCYSCALEFACTOR_H_
 
// EDM include(s):
#include "xAODMuon/Muon.h"
#include "xAODEventInfo/EventInfo.h"
#include "xAODMuon/MuonContainer.h"
 
#include <PATInterfaces/CorrectionCode.h>
#include <MuonEfficiencyCorrections/HistHandler.h>
#include <MuonEfficiencyCorrections/MuonEfficiencyType.h>
#include <MuonEfficiencyCorrections/KinematicSystHandler.h>
#include <PATInterfaces/ISystematicsTool.h>
 
#include <ColumnarCore/ColumnAccessor.h>
#include <ColumnarCore/ColumnarTool.h>
#include <ColumnarMuon/MuonDef.h>
#include <ColumnarCore/ObjectColumn.h>
 
// further ROOT includes
#include <TFile.h>
#include <TDirectory.h>
 
// STL includes
#include <string>
#include <iostream>
#include <exception>
#include <map>
#include <cmath>
#include <memory>
 
namespace CP {
    class SystematicSet;
}
 
namespace ADD_CMODE(CP) {
    
    class MuonEfficiencyScaleFactors;
    class EfficiencyScaleFactor : public columnar::ColumnarTool<> {

        public:
            EfficiencyScaleFactor(const MuonEfficiencyScaleFactors& ref_tool,
                                  const std::string &file, 
                                  const std::string &time_unit);
           
            EfficiencyScaleFactor(std::shared_ptr<EfficiencyScaleFactor> nominal,
                                  const MuonEfficiencyScaleFactors& ref_tool,
                                  const std::string& file,
                                  const std::string& time_unit,
                                  const std::string& syst_name,
                                  int syst_type_bitmap);
            EfficiencyScaleFactor(const EfficiencyScaleFactor&) =delete;
            EfficiencyScaleFactor& operator =(const EfficiencyScaleFactor&) =delete;
        
            
            bool CheckConsistency();
            
            int nBins() const;

            std::string GetBinName(int bin) const;
            
            int nOverFlowBins() const;
            bool isOverFlowBin(int b) const;
 

            int FindBinSF(const xAOD::Muon & mu) const;

            bool SetSystematicBin(int bin);
            
            bool separateBinSyst() const;
            bool IsUpVariation() const;
            


            CP::CorrectionCode ScaleFactor(const xAOD::Muon& mu, float & SF) const;
            CP::CorrectionCode ScaleFactor(columnar::MuonId mu, float & SF) const;
            CP::CorrectionCode ScaleFactorReplicas(const xAOD::Muon& mu, std::vector<float> & SF);
            
            CP::CorrectionCode ApplyScaleFactor(const xAOD::Muon& mu) const;
            CP::CorrectionCode ApplyScaleFactorReplicas(const xAOD::Muon& mu, int n_replicas);
            
            CP::CorrectionCode DataEfficiency(const xAOD::Muon& mu, float & Eff) const;
            CP::CorrectionCode DataEfficiencyReplicas(const xAOD::Muon& mu, std::vector<float> & eff);
            CP::CorrectionCode ApplyDataEfficiency(const xAOD::Muon& mu) const;
            CP::CorrectionCode ApplyDataEfficiencyReplicas(const xAOD::Muon& mu, int n_replicas);
            
            CP::CorrectionCode MCEfficiency(const xAOD::Muon& mu, float & Eff) const;
            CP::CorrectionCode MCEfficiencyReplicas(const xAOD::Muon& mu, std::vector<float> & eff);
            CP::CorrectionCode ApplyMCEfficiency(const xAOD::Muon& mu) const;
            CP::CorrectionCode ApplyMCEfficiencyReplicas(const xAOD::Muon& mu, int n_replicas);
            
            void DebugPrint() const;
 
          
            std::string sysname(bool with_direction = true) const;
           
            unsigned int firstRun() const;
            unsigned int lastRun() const;
            
            bool coversRunNumber(unsigned int run) const;
          
            void setFirstLastRun(unsigned int first, unsigned int last);
        private:
            
            typedef std::vector<std::unique_ptr<HistHandler>> SFReplicaVec;
           
            bool ReadFromFile(const std::string &file, const std::string& time_unit);
            std::unique_ptr<HistHandler> ReadHistFromFile(columnar::ColumnarTool<>* parent, const std::string& name, TFile* f, const std::string& time_unit);
            
            // use some maps for easy histo loading / arithmetics by name
            
            CP::CorrectionCode GetContentFromHist(const HistHandler* Hist, const xAOD::Muon& mu, float & SF, bool add_kine_syst) const;
            CP::CorrectionCode GetContentFromHist(const HistHandler* Hist, columnar::MuonId mu, float & SF, bool add_kine_syst) const;
            CP::CorrectionCode GetContentReplicasFromHist(EfficiencyScaleFactor::SFReplicaVec &replicas, const xAOD::Muon& mu, std::vector<float> & SF, bool add_kine_syst);
 
            
            // package a TH1 in a HistHandler
            std::unique_ptr<HistHandler> package_histo(columnar::ColumnarTool<>* parent, TH1* h);
 
            
            // replica generation
            void GenerateReplicas(int nrep, int seed);
            void GenerateReplicasFromHist(HistHandler* h, int nrep, int seed, EfficiencyScaleFactor::SFReplicaVec &repVector);
  
            MuonEfficiencyType m_measurement;
            std::string m_syst_name;
            
            bool m_is_up;
            bool m_is_lowpt;
            bool m_respond_to_kineDepSyst;
            bool m_separateBinSyst;
            std::unique_ptr<HistHandler> m_sf;
            std::unique_ptr<HistHandler> m_eff;
            std::unique_ptr<HistHandler> m_mc_eff;

            typedef SG::Decorator<float> FloatDecorator;
            typedef SG::Decorator<std::vector<float>> FloatVectorDecorator;
            
            std::unique_ptr<FloatDecorator> m_sf_decor;
            std::unique_ptr<FloatDecorator> m_eff_decor;           
            std::unique_ptr<FloatDecorator> m_mc_eff_decor;
            
            std::unique_ptr<FloatVectorDecorator> m_sf_rep_decor;
            std::unique_ptr<FloatVectorDecorator> m_eff_rep_decor;
            std::unique_ptr<FloatVectorDecorator> m_mc_eff_rep_decor;
 
            
            // these are for the continuous pt dependent systematic if we have one
            std::unique_ptr<IKinematicSystHandler> m_sf_KineDepsys;
   
            
            SFReplicaVec m_sf_replicas;
            SFReplicaVec m_eff_replicas;
            SFReplicaVec m_mc_eff_replicas;

            std::shared_ptr<EfficiencyScaleFactor> m_NominalFallBack;
            int m_SystematicBin;
            
            
            float m_default_eff;
            float m_default_eff_ttva;
            
            mutable std::atomic<unsigned int> m_warnsPrinted;
            static const unsigned int m_warningLimit;
            
            unsigned int m_firstRun;
            unsigned int m_lastRun;
 
        public:
 
            columnar::MuonAccessor<columnar::ObjectColumn> m_muons {*this, "Muons"};
            columnar::MuonAccessor<columnar::RetypeColumn<double,float>> ptAcc {*this, "pt"};
            columnar::MuonAccessor<columnar::RetypeColumn<double,float>> etaAcc {*this, "eta"};
            columnar::MuonAccessor<columnar::RetypeColumn<double,float>> phiAcc {*this, "phi"};
            columnar::MuonAccessor<columnar::RetypeColumn<xAOD::Muon::MuonType,std::uint16_t>> muonTypeAcc {*this, "muonType"};
    };
} /* namespace ADD_CMODE(CP) */
 
#endif /* EFFICIENCYSCALEFACTOR_H_ */