ElectronPhotonVariableCorrectionBase.h

Go to the documentation of this file.

/*
    Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ElectronPhotonVariableCorrectionBase_H
#define ElectronPhotonVariableCorrectionBase_H
 
//ATLAS includes
#include "AsgTools/AsgTool.h"
#include "PATInterfaces/CorrectionCode.h"
 
//EDM includes
#include "xAODEgamma/Electron.h"
#include "xAODEgamma/Photon.h"
 
//Root includes
#include "TFormula.h"
 
// forward declarations
class TObject;
class TGraph;
class TH2;
class TEnv;
class TRandom3;
 
// ===========================================================================
// Class ElectronPhotonVariableCorrectionBase
// ===========================================================================
 
class ElectronPhotonVariableCorrectionBase : public asg::AsgTool
{
 
public:
    ElectronPhotonVariableCorrectionBase(const std::string& myname);
    ~ElectronPhotonVariableCorrectionBase() {};
 
    virtual StatusCode initialize() override;
 
    const CP::CorrectionCode applyCorrection( xAOD::Photon& photon ) const;
 
    const CP::CorrectionCode applyCorrection( xAOD::Electron& electron ) const;
 
    const CP::CorrectionCode correctedCopy( const xAOD::Photon& in_photon, xAOD::Photon*& out_photon ) const;
 
    const CP::CorrectionCode correctedCopy( const xAOD::Electron& in_electron, xAOD::Electron*& out_electron) const;
 
    const std::string& getCorrectionVariable() { return m_correctionVariable; };
 
    enum class EGammaObjects{
        Failure = 0,
        unconvertedPhotons = 1,
        convertedPhotons,
        allPhotons,
        allElectrons,
        allEGammaObjects
    }; //end enum EGammaObjects
 
    ElectronPhotonVariableCorrectionBase::EGammaObjects isAppliedTo() { return m_applyToObjects; };
 
    bool applyToConvertedPhotons() const;
 
    bool applyToUnconvertedPhotons() const;
 
    bool applyToElectrons() const; //check if passed flag is compatible with electron
 
private:
    enum class parameterType{
        Failure = 0,
        EtaDependentTGraph = 1,
        PtDependentTGraph,
        EtaBinned,
        PtBinned,
        EtaTimesPtBinned,
        EtaTimesPhiTH2,
        EventDensity
    }; // end enum ParameterType
    std::string m_configFile;
    std::string m_correctionVariable;
    bool m_doGaussianSmearing = false;
    mutable boost::thread_specific_ptr<TRandom3> m_TRandom_tls;
    std::vector<float> m_uncorrectedDiscontinuities;
    std::string m_correctionFunctionString;
    std::unique_ptr<TFormula> m_correctionFunctionTFormula;
    int m_numberOfFunctionParameters{};
    std::vector<parameterType> m_ParameterTypeVector;
    std::vector<TGraph*> m_graphCopies;
    std::vector<TH2*> m_TH2Copies;
    std::vector<float> m_useAbsEtaTH2;
    std::vector<std::vector<float>> m_binValues;
    std::vector<float> m_etaBins;
    bool m_useAbsEtaBinned{};
    std::vector<float> m_ptBins;
    std::vector<bool> m_interpolatePtFlags;
    ElectronPhotonVariableCorrectionBase::EGammaObjects m_applyToObjects;
    bool m_retrievedEtaBinning = false;
    bool m_retrievedPtBinning = false;
    std::unique_ptr<SG::AuxElement::Accessor<float>> m_variableToCorrect;
    std::unique_ptr<SG::AuxElement::Accessor<float>> m_originalVariable;
 
    ElectronPhotonVariableCorrectionBase::parameterType stringToParameterType( const std::string& input ) const;
 
    ElectronPhotonVariableCorrectionBase::EGammaObjects stringToEGammaObject( const std::string& input ) const;
 
    bool passedCorrectPhotonType(const xAOD::Photon& photon) const;
 
    bool isEqualToUncorrectedDiscontinuity(const float value) const;
 
    const StatusCode getParameterInformationFromConf(TEnv& env, const int parameter_number, const ElectronPhotonVariableCorrectionBase::parameterType type);
 
    const StatusCode getEtaPtBinningsFromConf(const bool getEtaBins, const bool getPtBins, const TString& binValues, const TString& interpolate, TEnv& env, const int parameter_number);
 
    const StatusCode getObjectFromRootFile(TEnv& env, const int parameter_number, const TString& filePathKey, const TString& nameKey, std::unique_ptr<TObject>& return_object);
 
    const StatusCode getCorrectionParameters(const float pt, const float eta, const float ph,
                                             std::vector<float>& properties) const;
 
    const StatusCode get1DBinnedParameter(float& return_parameter_value, const float evalPoint, const std::vector<float>& binning, const int parameter_number) const;
 
    const StatusCode get2DBinnedParameter(float& return_parameter_value, const float etaEvalPoint, const float ptEvalPoint, const int parameter_number) const;
 
    const StatusCode get2DHistParameter(float& return_parameter_value, const float etaEvalPoint, const float phiEvalPoint, const int parameter_number) const;
 
    static const StatusCode findBin(int& return_bin, const float evalPoint, const std::vector<float>& binning) ;
 
    bool getInterpolationFlag(const int parameter_number) const;
 
    const StatusCode interpolate(float& return_parameter_value, const float evalPoint, const int bin, const std::vector<float>& binning, const std::vector<float>& binValues) const;
 
    const StatusCode getBinCenter(float& return_bin_center, const std::vector<float>& binning, const int bin_int) const;
 
    static float interpolate_function(const float value, const float left_bin_center, const float left_bin_value, const float right_bin_center, const float right_bin_value) ;
 
    const StatusCode getDensity(float& value, const std::string& eventShapeContainer) const;
 
    const StatusCode getKinematicProperties(const xAOD::Egamma& egamma_object, float& pt, float& eta, float& phi) const;
 
    void correct(float& return_corrected_variable, const float original_variable,
                 const std::vector<float>& properties, unsigned int rndSeed = 0) const;
 
    TRandom3* getTLSRandomGen(unsigned int seed) const;
 
}; //end class ElectronPhotonVariableCorrectionBase
 
#endif