FFJetSmearingTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef FFJETSMEARINGTOOL_FFJETSMEARINGTOOL_H
#define FFJETSMEARINGTOOL_FFJETSMEARINGTOOL_H
 
 
// Framework includes
#include "AsgTools/AsgTool.h"
#include "AsgTools/ToolHandle.h"
#include "PATInterfaces/CorrectionTool.h"
 
 
//includes for systematics ATLAS structure
#include "PATInterfaces/SystematicsTool.h"//To set the systematics as it is done in JetJvtEfficiency
 
#include "AsgMessaging/StatusCode.h"
#include "PATInterfaces/SystematicRegistry.h"
#include "PATInterfaces/SystematicVariation.h"
 
 
//xAOD EDM classes
#include "xAODJet/JetContainer.h"
 
 
// Other packages includes
#include "JetCPInterfaces/ICPJetCorrectionTool.h"
 
// Local includes
#include "JetUncertainties/Helpers.h"
#include "JetUncertainties/JetHelpers.h"
 
 
// Other includes
#include <TFile.h>
#include <TH2.h>
#include <TH3.h>
#include "TEnv.h"
 
#include <memory> //to use make_unique
#include <string>
#include <map>

 
 
 
namespace JetTools{
    enum class FFJetAllowedMassDefEnum
    {
        Calo,     
        TA,       
        Comb,     
        UFO,      
    };
    inline StatusCode stringToEnum(const TString& name, FFJetAllowedMassDefEnum& result)
    {
        if (name.EqualTo("Calo",TString::kIgnoreCase)){
            result = FFJetAllowedMassDefEnum::Calo;
            return StatusCode::SUCCESS;
        }
        if (name.EqualTo("TA",TString::kIgnoreCase)){
            result = FFJetAllowedMassDefEnum::TA;
            return StatusCode::SUCCESS;
        }
        if (name.EqualTo("Comb",TString::kIgnoreCase)){
            result = FFJetAllowedMassDefEnum::Comb;
            return StatusCode::SUCCESS;
        }
        if (name.EqualTo("UFO",TString::kIgnoreCase)){
            result = FFJetAllowedMassDefEnum::UFO;
            return StatusCode::SUCCESS;
        }
        return StatusCode::FAILURE;
    }
    inline TString enumToString(const FFJetAllowedMassDefEnum type)
    {
        switch (type)
        {
            case FFJetAllowedMassDefEnum::Calo:         return "Calo";
            case FFJetAllowedMassDefEnum::TA:           return "TA";
            case FFJetAllowedMassDefEnum::Comb:         return "Comb";
            case FFJetAllowedMassDefEnum::UFO:          return "UFO";
            default:           return "";
        }
    } 
 
}
 
namespace CP {
    class FFJetSmearingTool : public asg::AsgTool, virtual public ICPJetCorrectionTool 
    {

        ASG_TOOL_CLASS( FFJetSmearingTool,  ICPJetCorrectionTool  )
 
        public:
            // Constructor/destructor/init
            FFJetSmearingTool(const std::string& name);      
            virtual ~FFJetSmearingTool(); 
 
            virtual StatusCode initialize() override;
 
 
 
            //New systematic functions

            virtual bool isAffectedBySystematic(const CP::SystematicVariation& systematic) const override;

            virtual CP::SystematicSet affectingSystematics() const override;
       
            virtual CP::SystematicSet recommendedSystematics() const override;

            virtual StatusCode applySystematicVariation
            (const CP::SystematicSet& systematics) override;

 
 
            virtual CP::CorrectionCode applyCorrection(xAOD::Jet& jet_reco) const override;// The user has to use this function to smear it's jet mass
            virtual CP::CorrectionCode correctedCopy(const xAOD::Jet& input, xAOD::Jet*& output) const override;
            virtual CP::CorrectionCode applyContainerCorrection(xAOD::JetContainer& inputs) const override;
 
            StatusCode getMatchedTruthJet( xAOD::Jet& jet_reco, xAOD::Jet& jet_truth_matched) const;
 
        private:
 
 
            StatusCode readFFJetSmearingToolSimplifiedData(TEnv& settings);
 
            StatusCode getJMSJMR( xAOD::Jet& jet_reco, double jet_mass,  JetTools::FFJetAllowedMassDefEnum MassDef_of_syst ,const std::string& jetTopology, double& JMS_err, double& JMR_err) const;
 
            StatusCode getJetTopology( xAOD::Jet& jet_reco, std::string& jetTopology) const;
 
            double Read3DHistogram(const TH3* histo, double x, double y, double z) const;
            double Interpolate2D(const TH2* histo, double x, double y) const;
 
            void replaceAllOccurrences(std::string& str, const std::string& to_find, const std::string& to_replace);
 
            // Private members
            bool m_isInit{};
            std::string m_release;
            std::string m_truth_jetColl;
            std::string m_truthlabelaccessor;
            std::string m_supportedmctypes;
            float m_EtaRange{};
            float m_MaxMass{};
            float m_MaxPt{};
            std::string m_calibArea;
            std::string m_histFileName;
            std::string m_MassDef_string;
            std::string m_MCType_string;
            JetTools::FFJetAllowedMassDefEnum m_MassDef{};
            std::string m_configFile;
            std::string m_path;
            std::string m_HistogramsFilePath;
 
            //Response matrix
            bool m_doGaussianSmearing{};
            std::unique_ptr<TH2> m_CALO_ResponseMap;
            std::unique_ptr<TH2> m_TA_ResponseMap;
            std::unique_ptr<TH2> m_UFO_ResponseMap;
 
            //Two histograms to extract the Calo and TA weights in the Combined mass of the jet
            std::unique_ptr<TH3F> m_caloMassWeight;
            std::unique_ptr<TH3F> m_TAMassWeight;
 
 
            //The list of systemaics
            CP::SystematicSet  m_SysList{};
 
            //Maps that relates the systematic name with some of its caracteristics
            std::map<std::string,std::string> m_Syst_MassDefAffected_map;
            std::map<std::string,std::string> m_Syst_TopologyAffected_map;
            std::map<std::string,std::string> m_Syst_HistPath_map;
            std::map<std::string,std::unique_ptr<TH2>> m_Syst_Hist_map;
            std::map<std::string,std::unique_ptr<TH3F>> m_Syst_Hist_map3d;
            std::map<std::string,std::string> m_Syst_HistTAPath_map;
            std::map<std::string,std::unique_ptr<TH2>> m_Syst_HistTA_map;
            std::map<std::string,std::unique_ptr<TH3F>> m_Syst_HistTA_map3d;
            std::map<std::string,std::string> m_Syst_Affects_JMSorJMR;
            std::map<std::string,std::string> m_Syst_uncertparam;
 
            //The current systematic configuration
            struct SysData final
            {
                std::string SysBaseName {"None"};
                float SysParameter {0};
            };
            std::unordered_map<CP::SystematicSet,SysData> m_sysData;
            SysData *m_currentSysData{nullptr};
 
            static constexpr float m_MeVtoGeV = 1.e-3;
 
    }; // Class FFJetSmearingTool
 
} // namespace CP
 
#endif