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>
 
// 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;
    class MuonEfficiencyScaleFactors;
    class EfficiencyScaleFactor {
 
        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;
            
 
 
            CorrectionCode ScaleFactor(const xAOD::Muon& mu, float & SF) const;
            CorrectionCode ScaleFactorReplicas(const xAOD::Muon& mu, std::vector<float> & SF);
            
            CorrectionCode ApplyScaleFactor(const xAOD::Muon& mu) const;
            CorrectionCode ApplyScaleFactorReplicas(const xAOD::Muon& mu, int n_replicas);
            
            CorrectionCode DataEfficiency(const xAOD::Muon& mu, float & Eff) const;
            CorrectionCode DataEfficiencyReplicas(const xAOD::Muon& mu, std::vector<float> & eff);
            CorrectionCode ApplyDataEfficiency(const xAOD::Muon& mu) const;
            CorrectionCode ApplyDataEfficiencyReplicas(const xAOD::Muon& mu, int n_replicas);
            
            CorrectionCode MCEfficiency(const xAOD::Muon& mu, float & Eff) const;
            CorrectionCode MCEfficiencyReplicas(const xAOD::Muon& mu, std::vector<float> & eff);
            CorrectionCode ApplyMCEfficiency(const xAOD::Muon& mu) const;
            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(const std::string& name, TFile* f, const std::string& time_unit);
            
            // use some maps for easy histo loading / arithmetics by name
            
            CorrectionCode GetContentFromHist(const HistHandler* Hist, const xAOD::Muon& mu, float & SF, bool add_kine_syst) const;
            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(TH1* h);
 
            
            // replica generation
            void GenerateReplicas(int nrep, int seed);
            void GenerateReplicasFromHist(HistHandler* h, int nrep, int seed, EfficiencyScaleFactor::SFReplicaVec &repVector);
  
            CP::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::AuxElement::Decorator<float> FloatDecorator;
            typedef SG::AuxElement::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;
    };
} /* namespace CP */
 
#endif /* EFFICIENCYSCALEFACTOR_H_ */