KinematicSystHandler.h

Go to the documentation of this file.

/*
 Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef MUONEFFICIENCYCORRECTION_SYSTHANDLER_H
#define MUONEFFICIENCYCORRECTION_SYSTHANDLER_H
 
// EDM include(s):
#include "xAODMuon/Muon.h"
 
#include <PATInterfaces/CorrectionCode.h>
#include <MuonEfficiencyCorrections/HistHandler.h>
#include <MuonEfficiencyCorrections/MuonEfficiencyType.h>
#include <PATInterfaces/ISystematicsTool.h>
 
#include <ColumnarCore/ColumnAccessor.h>
#include <ColumnarCore/ColumnarTool.h>
#include <ColumnarCore/ObjectColumn.h>
#include <ColumnarMuon/MuonDef.h>
 
// further ROOT includes
#include <TFile.h>
#include <TDirectory.h>
#include <TH1.h>
#include <TF1.h>
 
// STL includes
#include <string>
#include <iostream>
#include <memory>
#include <map>
#include <cmath>
 
namespace CP {
 
    //Interface class to retrieve the Muon dependent systematics
    class IKinematicSystHandler : public columnar::ColumnarTool<> {
        public:
            virtual CorrectionCode GetKineDependent(columnar::MuonId mu, float& Eff) const = 0;
            virtual void SetSystematicWeight(float SystWeight) = 0;
            
            virtual bool initialize() = 0;
            virtual ~IKinematicSystHandler() =default;
            
            typedef float (IKinematicSystHandler::*KinVariable)(columnar::MuonId mu) const;
            KinVariable GetMuonVariableToUse(const std::string &name);
 
            float Eta(columnar::MuonId mu) const;
            float Pt(columnar::MuonId mu) const;
            float PtGeV(columnar::MuonId mu) const;
            float AbsEta(columnar::MuonId mu) const;
 
            columnar::MuonAccessor<columnar::ObjectColumn> muonsHandle {*this, "Muons"};
            columnar::MuonAccessor<float> ptAcc {*this, "pt"};
            columnar::MuonAccessor<float> etaAcc {*this, "eta"};
    };

    class PtKinematicSystHandler : public IKinematicSystHandler {
        public:
             CorrectionCode GetKineDependent(columnar::MuonId mu, float& eff) const override;
            
            void SetSystematicWeight(float syst_weight) override;
            
            bool initialize() override;
            
            PtKinematicSystHandler(std::unique_ptr<HistHandler> pt_flatnesss, std::unique_ptr<HistHandler> energy_loss);
        private:
            std::unique_ptr<HistHandler> m_flatness;
            std::unique_ptr<HistHandler> m_loss;
            float m_SystWeight;
    };

    
    class PrimodialPtSystematic: public IKinematicSystHandler {
        public:
            CorrectionCode GetKineDependent(columnar::MuonId mu, float& Eff) const override;
    
            void SetSystematicWeight(float SystWeight) override;
 
            bool initialize() override;
            PrimodialPtSystematic(std::unique_ptr<HistHandler> HistHandler);
        private:
            std::unique_ptr<HistHandler> m_Handler;
            float m_SystWeight;
    };

    class TTVAClosureSysHandler: public IKinematicSystHandler {
        public:
            TTVAClosureSysHandler(std::unique_ptr<HistHandler> HistHandler);
            
            void SetSystematicWeight( float SystWeight) override;
            bool initialize() override;
            CorrectionCode GetKineDependent(columnar::MuonId mu, float& Eff) const override;
        private:
            std::unique_ptr<HistHandler> m_Handler;
            float m_SystWeight;
    };
 
    class BadMuonVetoSystHandler: public IKinematicSystHandler {
        public:
             CorrectionCode GetKineDependent(columnar::MuonId mu, float& Eff) const override;
             void SetSystematicWeight(float SystWeight)override;
 
            bool initialize() override;
            BadMuonVetoSystHandler(TDirectory* InDir_3Stations, TDirectory* InDir_2Stations = nullptr);
            virtual ~BadMuonVetoSystHandler();
 
        private:
            typedef std::pair<float, float> Ranges;
            
            CP::CorrectionCode findAppropiatePolynomial(const xAOD::Muon& mu, TF1* &Poly) const;
            
            std::string getNextProperty(std::string &sstr) const;
            void fillMap(TDirectory* InDir, std::map<Ranges, std::unique_ptr<TF1>>& systPolynomials); 
            
            std::map<Ranges, std::unique_ptr<TF1>> m_syst3Stations;
            std::map<Ranges, std::unique_ptr<TF1>> m_syst2Stations;
            
            KinVariable m_uncertVar;
            KinVariable m_polySelVar;
            float m_SystWeight;
    };
    
} /* namespace CP */
 
#endif /* EFFICIENCYSCALEFACTOR_H_ */