ATLAS Offline Software
Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
AtlasRoot::egammaEnergyCorrectionTool Class Reference

#include <egammaEnergyCorrectionTool.h>

Inheritance diagram for AtlasRoot::egammaEnergyCorrectionTool:
Collaboration diagram for AtlasRoot::egammaEnergyCorrectionTool:

Public Types

typedef unsigned int RandomNumber
 

Public Member Functions

 egammaEnergyCorrectionTool ()
 
virtual ~egammaEnergyCorrectionTool ()
 
void setESModel (egEnergyCorr::ESModel val)
 
int initialize ()
 
void setFileName (const std::string &val)
 
void setRunNumber (long int runn=0)
 
void useStatErrorScaling (bool flag)
 
void use_temp_correction201215 (bool flag)
 
void use_temp_correction201516 (bool flag)
 
void use_uA2MeV_2015_first2weeks_correction (bool flag)
 
double applyMCCalibration (double eta, double ET, PATCore::ParticleType::Type ptype) const
 
double getCorrectedMomentum (PATCore::ParticleDataType::DataType dataType, PATCore::ParticleType::Type ptype, double momentum, double trk_eta, egEnergyCorr::Scale::Variation scaleVar=egEnergyCorr::Scale::None, double varSF=1.0) const
 take eta and uncorrected energy of electron, return corrected energy, apply given variation, for given particle type Note : energies in MeV This is the main method for users. More...
 
double getCorrectedEnergy (unsigned int runnumber, PATCore::ParticleDataType::DataType dataType, PATCore::ParticleType::Type ptype, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, RandomNumber seed, egEnergyCorr::Scale::Variation scaleVar=egEnergyCorr::Scale::None, egEnergyCorr::Resolution::Variation resVar=egEnergyCorr::Resolution::None, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90, double varSF=1.0) const
 
double resolution (double energy, double cl_eta, double cl_etaCalo, PATCore::ParticleType::Type ptype, bool withCT, bool fast, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
 
double getResolutionError (PATCore::ParticleDataType::DataType dataType, double energy, double eta, double etaCalo, PATCore::ParticleType::Type ptype, egEnergyCorr::Resolution::Variation value, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
 
void setApplyL2GainCorrection ()
 
void setApplyL2GainInterpolation ()
 
void setApplyLeakageCorrection (bool interpt=false)
 
void setADCTool (std::shared_ptr< LinearityADC > t)
 
const TAxis & get_ZeeStat_eta_axis () const
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

Static Public Member Functions

static std::string variationName (egEnergyCorr::Scale::Variation &var)
 
static std::string variationName (egEnergyCorr::Resolution::Variation &var)
 

Private Member Functions

double getAlphaValue (long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getAlphaUncertainty (long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getSmearingCorrection (double eta, double etaCalo, double energy, RandomNumber seed, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, PATCore::ParticleDataType::DataType dataType=PATCore::ParticleDataType::Full, egEnergyCorr::Resolution::Variation value=egEnergyCorr::Resolution::Nominal, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
 smearing corrections More...
 
double applyAFtoG4 (double eta, double ptGeV, PATCore::ParticleType::Type ptype) const
 MC calibration corrections. More...
 
double applyFStoG4 (double eta) const
 
double dataConstantTerm (double eta) const
 
double dataConstantTermError (double eta) const
 
double dataConstantTermOFCError (double eta) const
 
double dataZPeakResolution (double cl_eta) const
 
double mcZPeakResolution (double cl_eta) const
 
double dataConstantTermCorError (double cl_eta) const
 
void resolutionError (double energy, double cl_eta, double &errUp, double &errDown) const
 
double getZeeMeanET (double cl_eta) const
 
double getAlphaZee (long int runnumber, double eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getE4NonLinearity (double cl_eta, double meanE, PATCore::ParticleType::Type) const
 
double getWtots1Uncertainty (double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
 
double getLayerUncertainty (int iLayer, double cl_eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getLayerNonLinearity (int iLayer, double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
 
double getDeltaX (double cl_eta, egEnergyCorr::MaterialCategory imat, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal) const
 
double getAlphaMaterial (double cl_eta, egEnergyCorr::MaterialCategory imat, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getMaterialEffect (egEnergyCorr::Geometry geo, PATCore::ParticleType::Type ptype, double cl_eta, double ET) const
 
double getMaterialNonLinearity (double cl_eta, double energy, egEnergyCorr::MaterialCategory imat, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getAlphaLeakage (double cl_eta, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getAlphaLeakage2D (double cl_eta, double et, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
std::pair< double, double > getAlphaUncAlpha (const TH1 &hh, double cl_eta, double et, bool useInterp) const
 
double getAlphaConvSyst (double cl_eta, double energy, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getAlphaPedestal (double cl_eta, double energy, double eraw, PATCore::ParticleType::Type ptype, bool isRef, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double getLayerPedestal (double cl_eta, PATCore::ParticleType::Type ptype, int iLayer, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
 
double get_ZeeSyst (double eta) const
 
double get_OFCSyst (double eta) const
 
double getInterpolateConvSyst2D (const TH2 &conv_hist, double aeta, double ET) const
 
void getResolution_systematics (int particle_type, double energy, double eta, double etaCalo, int syst_mask, double &resolution, double &resolution_error, double &resolution_error_up, double &resolution_error_down, int resol_type=0, bool fast=false) const
 get resolution and its uncertainty) More...
 
double pileUpTerm (double energy, double eta, int particle_type) const
 
void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Static Private Member Functions

static double mcSamplingTerm (double cl_eta)
 
static double mcSamplingTermRelError (double cl_eta)
 
static double mcNoiseTerm (double cl_eta)
 
static double mcConstantTerm (double cl_eta)
 
static double fcn_sigma (double energy, double Cdata, double Cdata_er, double S, double S_er)
 
static double getE4Uncertainty (double eta)
 
static bool isInCrack (double cl_eta)
 
static double nearestEtaBEC (double cl_eta)
 

Private Attributes

std::unique_ptr< egGain::GainTool > m_gain_tool
 
std::unique_ptr< egGain::GainUncertainty > m_gain_tool_run2
 
std::shared_ptr< LinearityADC > m_ADCLinearity_tool
 
std::unique_ptr< eg_resolution > m_resolution_tool
 
std::unique_ptr< get_MaterialResolutionEffect > m_getMaterialDelta
 
std::unique_ptr< e1hg_systematics > m_e1hg_tool
 
std::string m_rootFileName
 
unsigned int m_begRunNumber
 
unsigned int m_endRunNumber
 
unsigned int m_RunNumber
 
std::unique_ptr< TH1 > m_trkSyst
 
std::unique_ptr< TH1 > m_aPSNom
 
std::unique_ptr< TH1 > m_daPSCor
 
std::unique_ptr< TH1 > m_daPSb12
 
std::unique_ptr< TH1 > m_aS12Nom
 
std::unique_ptr< TH1 > m_daS12Cor
 
std::unique_ptr< TH1 > m_zeeNom
 
std::unique_ptr< TH1 > m_zeeNom_data2015
 
std::unique_ptr< TH1 > m_zeeNom_data2016
 
std::unique_ptr< TH1 > m_zeeNom_data2017
 
std::unique_ptr< TH1 > m_zeeNom_data2018
 
std::unique_ptr< const TH1 > m_zeeFwdk
 
std::unique_ptr< const TH1 > m_zeeFwdb
 
std::unique_ptr< TH1 > m_zeeSyst
 
std::unique_ptr< TH1 > m_zeeSystOFC
 
std::unique_ptr< TH1 > m_zeePhys
 
std::unique_ptr< TH1 > m_uA2MeV_2015_first2weeks_correction
 
std::unique_ptr< TProfile > m_meanZeeProfile
 
std::unique_ptr< TH1 > m_resNom
 
std::unique_ptr< TH1 > m_resSyst
 
std::unique_ptr< TH1 > m_resSystOFC
 
std::unique_ptr< TH1 > m_peakResData
 
std::unique_ptr< TH1 > m_peakResMC
 
std::unique_ptr< TH1 > m_dX_ID_Nom
 
std::unique_ptr< TH1 > m_dX_IPPS_Nom
 
std::unique_ptr< TH1 > m_dX_IPPS_LAr
 
std::unique_ptr< TH1 > m_dX_IPAcc_Nom
 
std::unique_ptr< TH1 > m_dX_IPAcc_G4
 
std::unique_ptr< TH1 > m_dX_IPAcc_LAr
 
std::unique_ptr< TH1 > m_dX_IPAcc_GL1
 
std::unique_ptr< TH1 > m_dX_PSAcc_Nom
 
std::unique_ptr< TH1 > m_dX_PSAcc_G4
 
std::unique_ptr< TH1 > m_dX_PSAcc_LAr
 
std::unique_ptr< TAxis > m_psElectronEtaBins
 
std::unique_ptr< TList > m_psElectronGraphs
 
std::unique_ptr< TAxis > m_psUnconvertedEtaBins
 
std::unique_ptr< TList > m_psUnconvertedGraphs
 
std::unique_ptr< TAxis > m_psConvertedEtaBins
 
std::unique_ptr< TList > m_psConvertedGraphs
 
std::unique_ptr< TAxis > m_E4ElectronEtaBins
 
std::unique_ptr< TList > m_E4ElectronGraphs
 
std::unique_ptr< TAxis > m_E4UnconvertedEtaBins
 
std::unique_ptr< TList > m_E4UnconvertedGraphs
 
std::unique_ptr< TAxis > m_E4ConvertedEtaBins
 
std::unique_ptr< TList > m_E4ConvertedGraphs
 
std::unique_ptr< TAxis > m_s12ElectronEtaBins
 
std::unique_ptr< TList > m_s12ElectronGraphs
 
std::unique_ptr< TAxis > m_s12UnconvertedEtaBins
 
std::unique_ptr< TList > m_s12UnconvertedGraphs
 
std::unique_ptr< TAxis > m_s12ConvertedEtaBins
 
std::unique_ptr< TList > m_s12ConvertedGraphs
 
std::unique_ptr< TAxis > m_EaccElectronEtaBins
 
std::unique_ptr< TList > m_EaccElectronGraphs
 
std::unique_ptr< TAxis > m_EaccUnconvertedEtaBins
 
std::unique_ptr< TList > m_EaccUnconvertedGraphs
 
std::unique_ptr< TAxis > m_EaccConvertedEtaBins
 
std::unique_ptr< TList > m_EaccConvertedGraphs
 
std::unique_ptr< TH1 > m_pedestalL0
 
std::unique_ptr< TH1 > m_pedestalL1
 
std::unique_ptr< TH1 > m_pedestalL2
 
std::unique_ptr< TH1 > m_pedestalL3
 
std::unique_ptr< TH1 > m_pedestals_es2017
 
std::unique_ptr< TH1 > m_convRadius
 
std::unique_ptr< TH1 > m_convFakeRate
 
std::unique_ptr< TH1 > m_convRecoEfficiency
 
std::unique_ptr< TH2 > m_convFakeRate_2D
 
std::unique_ptr< TH2 > m_convRecoEfficiency_2D
 
std::unique_ptr< TH1 > m_leakageConverted
 
std::unique_ptr< TH1 > m_leakageUnconverted
 
std::unique_ptr< TH1 > m_leakageElectron
 
std::unique_ptr< TH1 > m_zeeES2Profile
 
std::unique_ptr< TH2 > m_pp0_elec
 
std::unique_ptr< TH2 > m_pp0_unconv
 
std::unique_ptr< TH2 > m_pp0_conv
 
std::unique_ptr< TH1 > m_wstot_slope_A_data
 
std::unique_ptr< TH1 > m_wstot_slope_B_MC
 
std::unique_ptr< TH1 > m_wstot_pT_data_p0_electrons
 
std::unique_ptr< TH1 > m_wstot_pT_data_p1_electrons
 
std::unique_ptr< TH1 > m_wstot_pT_data_p0_unconverted_photons
 
std::unique_ptr< TH1 > m_wstot_pT_data_p1_unconverted_photons
 
std::unique_ptr< TH1 > m_wstot_pT_data_p0_converted_photons
 
std::unique_ptr< TH1 > m_wstot_pT_data_p1_converted_photons
 
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_electrons
 
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_electrons
 
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_unconverted_photons
 
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_unconverted_photons
 
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_converted_photons
 
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_converted_photons
 
std::vector< std::unique_ptr< TH1 > > m_matElectronScale
 
std::vector< std::unique_ptr< TH1 > > m_matUnconvertedScale
 
std::vector< std::unique_ptr< TH1 > > m_matConvertedScale
 
std::vector< std::unique_ptr< TH1 > > m_matElectronCstTerm
 
std::vector< std::unique_ptr< TH1 > > m_matX0Additions
 
std::unique_ptr< TAxis > m_matElectronEtaBins
 
std::vector< std::unique_ptr< TList > > m_matElectronGraphs
 
std::unique_ptr< TH2 > m_electronBias_ConfigA
 
std::unique_ptr< TH2 > m_electronBias_ConfigEpLp
 
std::unique_ptr< TH2 > m_electronBias_ConfigFpMX
 
std::unique_ptr< TH2 > m_electronBias_ConfigN
 
std::unique_ptr< TH2 > m_electronBias_ConfigIBL
 
std::unique_ptr< TH2 > m_electronBias_ConfigPP0
 
std::unique_ptr< TH2 > m_unconvertedBias_ConfigA
 
std::unique_ptr< TH2 > m_unconvertedBias_ConfigEpLp
 
std::unique_ptr< TH2 > m_unconvertedBias_ConfigFpMX
 
std::unique_ptr< TH2 > m_unconvertedBias_ConfigN
 
std::unique_ptr< TH2 > m_unconvertedBias_ConfigIBL
 
std::unique_ptr< TH2 > m_unconvertedBias_ConfigPP0
 
std::unique_ptr< TH2 > m_convertedBias_ConfigA
 
std::unique_ptr< TH2 > m_convertedBias_ConfigEpLp
 
std::unique_ptr< TH2 > m_convertedBias_ConfigFpMX
 
std::unique_ptr< TH2 > m_convertedBias_ConfigN
 
std::unique_ptr< TH2 > m_convertedBias_ConfigIBL
 
std::unique_ptr< TH2 > m_convertedBias_ConfigPP0
 
std::unique_ptr< TH1 > m_G4OverAFII_electron
 
std::unique_ptr< TH1 > m_G4OverAFII_converted
 
std::unique_ptr< TH1 > m_G4OverAFII_unconverted
 
std::unique_ptr< TH2 > m_G4OverAFII_electron_2D
 
std::unique_ptr< TH2 > m_G4OverAFII_converted_2D
 
std::unique_ptr< TH2 > m_G4OverAFII_unconverted_2D
 
std::unique_ptr< TH1 > m_G4OverFrSh
 
std::unique_ptr< TH2 > m_G4OverAFII_resolution_electron
 
std::unique_ptr< TH2 > m_G4OverAFII_resolution_unconverted
 
std::unique_ptr< TH2 > m_G4OverAFII_resolution_converted
 
egEnergyCorr::ESModel m_esmodel
 
bool m_use_etaCalo_scales
 
bool m_applyPSCorrection
 
bool m_applyS12Correction
 
bool m_initialized
 
bool m_use_new_resolution_model
 
bool m_use_stat_error_scaling
 
bool m_useL2GainCorrection
 
bool m_useL2GainInterpolation
 
bool m_useLeakageCorrection
 
bool m_usepTInterpolationForLeakage
 
bool m_use_temp_correction201215
 
bool m_use_temp_correction201516
 
bool m_use_uA2MeV_2015_first2weeks_correction
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Detailed Description

Definition at line 364 of file egammaEnergyCorrectionTool.h.

Member Typedef Documentation

◆ RandomNumber

typedef unsigned int AtlasRoot::egammaEnergyCorrectionTool::RandomNumber

Definition at line 367 of file egammaEnergyCorrectionTool.h.

Constructor & Destructor Documentation

◆ egammaEnergyCorrectionTool()

AtlasRoot::egammaEnergyCorrectionTool::egammaEnergyCorrectionTool ( )

Definition at line 121 of file egammaEnergyCorrectionTool.cxx.

122  : asg::AsgMessaging("egammaEnergyCorrectionTool"),
123  m_rootFileName(
124  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v33/"
125  "egammaEnergyCorrectionData.root")),
126  m_esmodel(egEnergyCorr::UNDEFINED) {
127 
128  if (m_rootFileName.empty()) {
129  ATH_MSG_FATAL("cannot find configuration file");
130  throw std::runtime_error("cannot find file");
131  }
132 
133  m_begRunNumber = 0;
134  m_endRunNumber = 0;
135 
136  /*
137  * All histogram vectors start empty
138  */
139 
140  m_use_new_resolution_model = false;
141 
142  // tools
143 
144  m_resolution_tool = nullptr;
145  // m_getMaterialDelta = nullptr;
146  m_e1hg_tool = nullptr;
147 
148  // switches
149 
150  m_use_etaCalo_scales = false;
151 
152  m_applyPSCorrection = true;
153  m_applyS12Correction = true;
154 
155  // special for es2015PRE
156  m_use_temp_correction201215 = true;
157  m_use_uA2MeV_2015_first2weeks_correction = false;
158 
159  // special for es2016PRE
160  m_use_temp_correction201516 = true;
161 
162  // espcial for R22 precision
163  m_useL2GainCorrection = false;
164  m_useL2GainInterpolation = false;
165  m_useLeakageCorrection = false;
166  m_usepTInterpolationForLeakage = false;
167 
168  m_use_stat_error_scaling = false;
169  m_initialized = false;
170  m_RunNumber = 0;
171 }

◆ ~egammaEnergyCorrectionTool()

AtlasRoot::egammaEnergyCorrectionTool::~egammaEnergyCorrectionTool ( )
virtual

Definition at line 173 of file egammaEnergyCorrectionTool.cxx.

173  {
174 
175  // Clean up
176 }

Member Function Documentation

◆ applyAFtoG4()

double AtlasRoot::egammaEnergyCorrectionTool::applyAFtoG4 ( double  eta,
double  ptGeV,
PATCore::ParticleType::Type  ptype 
) const
private

MC calibration corrections.

Definition at line 3077 of file egammaEnergyCorrectionTool.cxx.

3078  {
3079  const double aeta = std::abs(eta);
3080  if (aeta > 2.47)
3081  return 1.;
3082 
3083  if (m_esmodel == egEnergyCorr::es2015PRE or
3084  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3085  m_esmodel == egEnergyCorr::es2015cPRE or
3086  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3087  m_esmodel == egEnergyCorr::es2015c_summer or
3088  m_esmodel == egEnergyCorr::es2016PRE or
3089  m_esmodel == egEnergyCorr::es2017 or
3090  m_esmodel == egEnergyCorr::es2017_summer or
3091  m_esmodel == egEnergyCorr::es2017_summer_improved or
3092  m_esmodel == egEnergyCorr::es2017_summer_final or
3093  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3094  m_esmodel == egEnergyCorr::es2017_R21_v0 or
3095  m_esmodel == egEnergyCorr::es2017_R21_v1 or
3096  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
3097  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
3098  m_esmodel == egEnergyCorr::es2018_R21_v0 or
3099  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3100  m_esmodel == egEnergyCorr::es2022_R22_PRE or
3101  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
3102 
3103  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
3104  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
3105  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
3106  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3107  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
3108  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
3109  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
3110  //
3111  // in es02017_R21_v1 : AF2 to FullSim correction is in a 2D eta-Pt
3112  // histogram
3113 
3114  if (ptype == PATCore::ParticleType::Electron) {
3115  return (1. + getValueHistAt(*m_G4OverAFII_electron_2D, aeta, ptGeV,
3116  true, true, true, true));
3117  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3118  return (1. + getValueHistAt(*m_G4OverAFII_converted_2D, aeta, ptGeV,
3119  true, true, true, true));
3120  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3121  return (1. + getValueHistAt(*m_G4OverAFII_unconverted_2D, aeta, ptGeV,
3122  true, true, true, true));
3123  } else {
3124  throw std::runtime_error("particle not valid");
3125  }
3126  } else {
3127  if (ptype == PATCore::ParticleType::Electron) {
3128  return getValueHistoAt(*m_G4OverAFII_electron, aeta);
3129  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3130  return getValueHistoAt(*m_G4OverAFII_converted, aeta);
3131  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3132  return getValueHistoAt(*m_G4OverAFII_unconverted, aeta);
3133  } else {
3134  throw std::runtime_error("particle not valid");
3135  }
3136  }
3137  } else {
3138  // run 1
3139  return m_G4OverAFII_electron->GetBinContent(
3140  std::as_const(*m_G4OverAFII_electron).GetXaxis()->FindBin(eta));
3141  }
3142 }

◆ applyFStoG4()

double AtlasRoot::egammaEnergyCorrectionTool::applyFStoG4 ( double  eta) const
private

Definition at line 3146 of file egammaEnergyCorrectionTool.cxx.

3146  {
3147 
3148  double aeta = std::abs(eta);
3149  if (aeta < 3.3 || aeta > 4.9)
3150  return 1.;
3151 
3152  return m_G4OverFrSh->GetBinContent(
3153  std::as_const(*m_G4OverFrSh).GetXaxis()->FindBin(aeta));
3154 }

◆ applyMCCalibration()

double AtlasRoot::egammaEnergyCorrectionTool::applyMCCalibration ( double  eta,
double  ET,
PATCore::ParticleType::Type  ptype 
) const

Definition at line 3042 of file egammaEnergyCorrectionTool.cxx.

3043  {
3044 
3045  if (ptype != PATCore::ParticleType::Electron ||
3046  m_esmodel != egEnergyCorr::es2011c)
3047  return 1.;
3048 
3049  double aeta = std::abs(eta);
3050 
3051  if (aeta < 1.42 || aeta > 1.55)
3052  return 1.;
3053 
3054  const int nBoundaries = 18;
3055  double ETBoundaries[nBoundaries] = {0., 5.4, 8.5, 12.9, 16., 20.,
3056  25., 30., 35., 40., 45., 50.,
3057  55., 60., 65., 70., 75., 99999.};
3058 
3059  double CalibFactors[nBoundaries - 1] = {
3060  0.884845, 0.898526, 0.902439, 0.91899, 0.925868, 0.929440,
3061  0.948080, 0.943788, 0.96026, 0.955709, 0.964285, 0.95762,
3062  0.970385, 0.963489, 0.968149, 0.970799, 0.961617};
3063 
3064  int i0 = -1;
3065  for (int i = 0; i < nBoundaries - 1; i++)
3066  if (ET / GeV > ETBoundaries[i] && ET / GeV <= ETBoundaries[i + 1])
3067  i0 = i;
3068 
3069  if (i0 >= 0 && i0 < nBoundaries - 1)
3070  return 1. / CalibFactors[i0];
3071 
3072  return 1.;
3073 }

◆ dataConstantTerm()

double AtlasRoot::egammaEnergyCorrectionTool::dataConstantTerm ( double  eta) const
private

Definition at line 2631 of file egammaEnergyCorrectionTool.cxx.

2631  {
2632  return std::max(0., m_resNom->GetBinContent(m_resNom->FindFixBin(eta)));
2633 }

◆ dataConstantTermCorError()

double AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermCorError ( double  cl_eta) const
private

Definition at line 2661 of file egammaEnergyCorrectionTool.cxx.

2662  {
2663 
2664  double mz = 91.2;
2665 
2666  double resData = dataZPeakResolution(cl_eta);
2667  double resMC = mcZPeakResolution(cl_eta);
2668  double cmc = mcConstantTerm(cl_eta);
2669 
2670  double smpup = 1. + mcSamplingTermRelError(cl_eta);
2671  double smpdo = 1. - mcSamplingTermRelError(cl_eta);
2672 
2673  double central =
2674  sqrt(2 * (resData * resData - resMC * resMC) / mz / mz + cmc * cmc);
2675  double vardown =
2676  sqrt(2 * (resData * resData - resMC * resMC * smpup * smpup) / mz / mz +
2677  cmc * cmc);
2678  double varup =
2679  sqrt(2 * (resData * resData - resMC * resMC * smpdo * smpdo) / mz / mz +
2680  cmc * cmc);
2681 
2682  double errdown = std::abs(central - vardown);
2683  double errup = std::abs(central - varup);
2684 
2685  return .5 * (errup + errdown);
2686 }

◆ dataConstantTermError()

double AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermError ( double  eta) const
private

Definition at line 2635 of file egammaEnergyCorrectionTool.cxx.

2635  {
2636  return m_resSyst->GetBinContent(m_resSyst->FindFixBin(eta));
2637 }

◆ dataConstantTermOFCError()

double AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermOFCError ( double  eta) const
private

Definition at line 2639 of file egammaEnergyCorrectionTool.cxx.

2639  {
2640  return m_resSystOFC->GetBinContent(m_resSystOFC->FindFixBin(eta));
2641 }

◆ dataZPeakResolution()

double AtlasRoot::egammaEnergyCorrectionTool::dataZPeakResolution ( double  cl_eta) const
private

Definition at line 2645 of file egammaEnergyCorrectionTool.cxx.

2645  {
2646 
2647  return m_peakResData->GetBinContent(
2648  std::as_const(*m_peakResData).GetXaxis()->FindBin(cl_eta));
2649 }

◆ fcn_sigma()

double AtlasRoot::egammaEnergyCorrectionTool::fcn_sigma ( double  energy,
double  Cdata,
double  Cdata_er,
double  S,
double  S_er 
)
staticprivate

Definition at line 2955 of file egammaEnergyCorrectionTool.cxx.

2957  {
2958 
2959  double sigma2 = std::pow((Cdata + Cdata_er) * energy, 2) +
2960  std::pow(S * (1 + S_er) * std::sqrt(energy), 2);
2961 
2962  double sigma = 0;
2963  if (sigma2 > 0)
2964  sigma = sqrt(sigma2);
2965 
2966  return sigma / energy;
2967 }

◆ get_OFCSyst()

double AtlasRoot::egammaEnergyCorrectionTool::get_OFCSyst ( double  eta) const
private

Definition at line 5239 of file egammaEnergyCorrectionTool.cxx.

5239  {
5240  const auto ieta = std::as_const(*m_zeeSystOFC).GetXaxis()->FindFixBin(eta);
5241  auto value_histo = m_zeeSystOFC->GetBinContent(ieta);
5242 
5243  return value_histo;
5244 }

◆ get_ZeeStat_eta_axis()

const TAxis & AtlasRoot::egammaEnergyCorrectionTool::get_ZeeStat_eta_axis ( ) const

Definition at line 5246 of file egammaEnergyCorrectionTool.cxx.

5246  {
5247  return *std::as_const(*m_zeeNom).GetXaxis();
5248 }

◆ get_ZeeSyst()

double AtlasRoot::egammaEnergyCorrectionTool::get_ZeeSyst ( double  eta) const
private

Definition at line 5232 of file egammaEnergyCorrectionTool.cxx.

5232  {
5233  const auto ieta = std::as_const(*m_zeeSyst).GetXaxis()->FindFixBin(eta);
5234  auto value_histo = m_zeeSyst->GetBinContent(ieta);
5235 
5236  return value_histo;
5237 }

◆ getAlphaConvSyst()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaConvSyst ( double  cl_eta,
double  energy,
PATCore::ParticleType::Type  ptype,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 4432 of file egammaEnergyCorrectionTool.cxx.

4434  {
4435 
4436  double alpha = 0.;
4437  double aeta = std::abs(cl_eta);
4438  if (aeta > 2.37)
4439  aeta = 2.36;
4440  double ET = energy / std::cosh(cl_eta);
4441 
4442  if (var == egEnergyCorr::Scale::Nominal ||
4443  ptype == PATCore::ParticleType::Electron)
4444  return alpha;
4445 
4446  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4447 
4448  if (var == egEnergyCorr::Scale::ConvEfficiencyUp &&
4449  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4450  alpha = m_convRecoEfficiency->GetBinContent(
4451  m_convRecoEfficiency->FindFixBin(aeta));
4452  else if (var == egEnergyCorr::Scale::ConvEfficiencyDown &&
4453  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4454  alpha = -m_convRecoEfficiency->GetBinContent(
4455  m_convRecoEfficiency->FindFixBin(aeta));
4456  else if (var == egEnergyCorr::Scale::ConvRecoUp &&
4457  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4458  alpha = getInterpolateConvSyst2D(*m_convRecoEfficiency_2D, aeta, ET);
4459  else if (var == egEnergyCorr::Scale::ConvRecoDown &&
4460  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4461  alpha =
4462  -1. * getInterpolateConvSyst2D(*m_convRecoEfficiency_2D, aeta, ET);
4463 
4464  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4465 
4466  if (var == egEnergyCorr::Scale::ConvFakeRateUp &&
4467  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4468  alpha = m_convFakeRate->GetBinContent(m_convFakeRate->FindFixBin(aeta));
4469  else if (var == egEnergyCorr::Scale::ConvFakeRateDown &&
4470  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4471  alpha = -m_convFakeRate->GetBinContent(m_convFakeRate->FindFixBin(aeta));
4472  else if (var == egEnergyCorr::Scale::ConvRecoUp &&
4473  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4474  alpha = getInterpolateConvSyst2D(*m_convFakeRate_2D, aeta, ET);
4475  else if (var == egEnergyCorr::Scale::ConvRecoDown &&
4476  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4477  alpha = -1. * getInterpolateConvSyst2D(*m_convFakeRate_2D, aeta, ET);
4478  else if (var == egEnergyCorr::Scale::ConvRadiusUp)
4479  alpha =
4480  m_convRadius->GetBinContent(m_convRadius->FindFixBin(aeta, ET / GeV));
4481  else if (var == egEnergyCorr::Scale::ConvRadiusDown)
4482  alpha = -m_convRadius->GetBinContent(
4483  m_convRadius->FindFixBin(aeta, ET / GeV));
4484  }
4485 
4486  return alpha * varSF;
4487 }

◆ getAlphaLeakage()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaLeakage ( double  cl_eta,
PATCore::ParticleType::Type  ptype,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 4279 of file egammaEnergyCorrectionTool.cxx.

4281  {
4282 
4283  double alpha = 0.;
4284  double aeta = std::abs(cl_eta);
4285 
4286  if (var == egEnergyCorr::Scale::Nominal ||
4287  ptype == PATCore::ParticleType::Electron)
4288  return alpha;
4289 
4290  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4291 
4292  if (var == egEnergyCorr::Scale::LeakageUnconvUp) {
4293  alpha = m_leakageUnconverted->GetBinContent(
4294  m_leakageUnconverted->FindFixBin(aeta));
4295  } else if (var == egEnergyCorr::Scale::LeakageUnconvDown) {
4296  alpha = -m_leakageUnconverted->GetBinContent(
4297  m_leakageUnconverted->FindFixBin(aeta));
4298  }
4299 
4300  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4301 
4302  if (var == egEnergyCorr::Scale::LeakageConvUp) {
4303  alpha = m_leakageConverted->GetBinContent(
4304  m_leakageConverted->FindFixBin(aeta));
4305  } else if (var == egEnergyCorr::Scale::LeakageConvDown) {
4306  alpha = -m_leakageConverted->GetBinContent(
4307  m_leakageConverted->FindFixBin(aeta));
4308  }
4309  }
4310 
4311  return alpha * varSF;
4312 }

◆ getAlphaLeakage2D()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaLeakage2D ( double  cl_eta,
double  et,
PATCore::ParticleType::Type  ptype,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 4314 of file egammaEnergyCorrectionTool.cxx.

4316  {
4317 
4318  // To be on the safe side
4319  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
4320  return getAlphaLeakage(cl_eta, ptype, var, varSF);
4321  }
4322 
4323  // No correction for electron
4324  if (ptype == PATCore::ParticleType::Electron &&
4325  var != egEnergyCorr::Scale::LeakageElecDown &&
4326  var != egEnergyCorr::Scale::LeakageElecUp)
4327  return 0.;
4328 
4329  // Outside acceptance. Should never happen
4330  double aeta = std::abs(cl_eta);
4331  if (aeta > 2.47) {
4332  ATH_MSG_WARNING("Very high |eta| object, eta = " << cl_eta);
4333  return 0.;
4334  }
4335 
4336  // If no correction applied, can only be the egEnergyCorr::Scale::LeakageXXX
4337  // syst
4338  if (!m_useLeakageCorrection && var != egEnergyCorr::Scale::LeakageConvDown &&
4339  var != egEnergyCorr::Scale::LeakageConvUp &&
4340  var != egEnergyCorr::Scale::LeakageUnconvDown &&
4341  var != egEnergyCorr::Scale::LeakageUnconvUp &&
4342  var != egEnergyCorr::Scale::LeakageElecDown &&
4343  var != egEnergyCorr::Scale::LeakageElecUp)
4344  return 0.;
4345 
4346  double etGeV = et / GeV;
4347  double alpha = 0, dalpha = 0;
4348  if (var == egEnergyCorr::Scale::LeakageElecDown ||
4349  var == egEnergyCorr::Scale::LeakageElecUp) {
4350  dalpha = getAlphaUncAlpha(*m_leakageElectron, aeta, etGeV,
4351  m_usepTInterpolationForLeakage)
4352  .first;
4353  if (var == egEnergyCorr::Scale::LeakageElecDown)
4354  dalpha *= -1;
4355  if (ptype == PATCore::ParticleType::Electron)
4356  return dalpha;
4357  }
4358 
4359  bool isConv = ptype == PATCore::ParticleType::ConvertedPhoton;
4360  TH1* hh = isConv ? m_leakageConverted.get() : m_leakageUnconverted.get();
4361  std::pair<double, double> p =
4362  getAlphaUncAlpha(*hh, aeta, etGeV, m_usepTInterpolationForLeakage);
4363 
4364  if (m_useLeakageCorrection) {
4365  alpha = p.first;
4366  }
4367  if ((isConv && (var == egEnergyCorr::Scale::LeakageConvDown ||
4368  var == egEnergyCorr::Scale::LeakageConvUp)) ||
4369  (!isConv && (var == egEnergyCorr::Scale::LeakageUnconvDown ||
4370  var == egEnergyCorr::Scale::LeakageUnconvUp))) {
4371  // If we correct, use uncertainty. Else use full size of the effect
4372  // for es2023_R22_Run2_v0, use full size of correction as uncertainty
4373  if (m_useLeakageCorrection && m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4374  dalpha = p.second;
4375  else
4376  dalpha = alpha;
4377 
4378  if (var == egEnergyCorr::Scale::LeakageConvDown ||
4379  var == egEnergyCorr::Scale::LeakageUnconvDown)
4380  dalpha *= -1;
4381  }
4382  alpha += dalpha;
4383 
4384  ATH_MSG_VERBOSE(
4385  "In leakage2D alpha = " << alpha << " from var = " << variationName(var));
4386 
4387  return alpha * varSF;
4388 }

◆ getAlphaMaterial()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaMaterial ( double  cl_eta,
egEnergyCorr::MaterialCategory  imat,
PATCore::ParticleType::Type  ptype,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 3953 of file egammaEnergyCorrectionTool.cxx.

3956  {
3957 
3958  double value = 0.;
3959  if (ptype == PATCore::ParticleType::Electron)
3960  return value;
3961  if (var == egEnergyCorr::Scale::Nominal)
3962  return value;
3963 
3964  egEnergyCorr::Geometry geoID, geoCryo, geoCalo, geoGp;
3965  geoID = egEnergyCorr::ConfigA;
3966  if (std::abs(cl_eta) < 2.)
3967  geoCryo = egEnergyCorr::ConfigEL;
3968  else
3969  geoCryo = egEnergyCorr::ConfigFMX;
3970  geoCalo = egEnergyCorr::ConfigFMX;
3971  geoGp = egEnergyCorr::ConfigGp;
3972 
3973  // look up material bias
3974 
3975  double DeltaX = getDeltaX(cl_eta, imat, var) -
3976  getDeltaX(cl_eta, imat, egEnergyCorr::Scale::Nominal);
3977 
3978  // calculate scale change per unit added material
3979 
3980  double DAlphaDXID, DAlphaDXCryo, DAlphaDXCalo, DAlphaDXGp;
3981  DAlphaDXID = DAlphaDXCryo = DAlphaDXCalo = DAlphaDXGp = 0;
3982  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3983  DAlphaDXGp = m_matUnconvertedScale[geoGp]->GetBinContent(
3984  m_matUnconvertedScale[geoGp]->FindBin(cl_eta));
3985  DAlphaDXID = m_matUnconvertedScale[geoID]->GetBinContent(
3986  m_matUnconvertedScale[geoID]->FindBin(cl_eta));
3987  DAlphaDXCryo = m_matUnconvertedScale[geoCryo]->GetBinContent(
3988  m_matUnconvertedScale[geoCryo]->FindBin(cl_eta));
3989  DAlphaDXCalo = m_matUnconvertedScale[geoCalo]->GetBinContent(
3990  m_matUnconvertedScale[geoCalo]->FindBin(cl_eta));
3991  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3992  DAlphaDXGp = m_matConvertedScale[geoGp]->GetBinContent(
3993  m_matConvertedScale[geoGp]->FindBin(cl_eta));
3994  DAlphaDXID = m_matConvertedScale[geoID]->GetBinContent(
3995  m_matConvertedScale[geoID]->FindBin(cl_eta));
3996  DAlphaDXCryo = m_matConvertedScale[geoCryo]->GetBinContent(
3997  m_matConvertedScale[geoCryo]->FindBin(cl_eta));
3998  DAlphaDXCalo = m_matConvertedScale[geoCalo]->GetBinContent(
3999  m_matConvertedScale[geoCalo]->FindBin(cl_eta));
4000  }
4001 
4002  // when in crack, use G', exit
4003 
4004  if (isInCrack(cl_eta)) {
4005  if (imat == egEnergyCorr::MatID && var == egEnergyCorr::Scale::MatIDUp)
4006  value = DAlphaDXGp;
4007  else if (imat == egEnergyCorr::MatID &&
4008  var == egEnergyCorr::Scale::MatIDDown)
4009  value = -DAlphaDXGp;
4010  return value;
4011  }
4012 
4013  // normal case
4014 
4015  int idx = m_matX0Additions[geoID]->FindBin(std::abs(cl_eta));
4016  if (idx < 1 || idx > m_matX0Additions[geoID]->GetNbinsX())
4017  DAlphaDXID = 0;
4018  else
4019  DAlphaDXID /= m_matX0Additions[geoID]->GetBinContent(idx);
4020 
4021  idx = m_matX0Additions[geoCryo]->FindBin(std::abs(cl_eta));
4022  if (idx < 1 || idx > m_matX0Additions[geoCryo]->GetNbinsX())
4023  DAlphaDXCryo = 0;
4024  else
4025  DAlphaDXCryo /= m_matX0Additions[geoCryo]->GetBinContent(idx);
4026 
4027  idx = m_matX0Additions[geoCalo]->FindBin(std::abs(cl_eta));
4028  if (idx < 1 || idx > m_matX0Additions[geoCalo]->GetNbinsX())
4029  DAlphaDXCalo = 0;
4030  else
4031  DAlphaDXCalo /= m_matX0Additions[geoCalo]->GetBinContent(idx);
4032 
4033  // final value
4034 
4035  if (imat == egEnergyCorr::MatID)
4036  value = DeltaX * (DAlphaDXID - DAlphaDXCryo);
4037  else if (imat == egEnergyCorr::MatCryo)
4038  value = DeltaX * DAlphaDXCryo;
4039  else if (imat == egEnergyCorr::MatCalo)
4040  value = DeltaX * DAlphaDXCalo;
4041 
4042  return value * varSF;
4043 }

◆ getAlphaPedestal()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaPedestal ( double  cl_eta,
double  energy,
double  eraw,
PATCore::ParticleType::Type  ptype,
bool  isRef,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 4529 of file egammaEnergyCorrectionTool.cxx.

4532  {
4533  double alpha = 0.;
4534  if (var == egEnergyCorr::Scale::PedestalUp ||
4535  var == egEnergyCorr::Scale::PedestalDown) {
4536  if (m_esmodel == egEnergyCorr::es2017) {
4537  const double delta =
4538  getValueHistoAt(*m_pedestals_es2017, std::abs(cl_eta));
4539  alpha = delta / (energy / cosh(cl_eta));
4540  if (var == egEnergyCorr::Scale::PedestalDown)
4541  alpha *= -1;
4542  } else if (m_esmodel == egEnergyCorr::es2017_summer or
4543  m_esmodel == egEnergyCorr::es2017_summer_improved or
4544  m_esmodel == egEnergyCorr::es2017_summer_final or
4545  m_esmodel == egEnergyCorr::es2017_R21_PRE or
4546  m_esmodel == egEnergyCorr::es2015_5TeV or
4547  m_esmodel == egEnergyCorr::es2017_R21_v0 or
4548  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4549  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4550  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
4551  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4552  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4553  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4554  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4555  // Et uncertainty band: 10 MeV for the corrected cluster
4556  alpha = 10. / (energy / cosh(cl_eta));
4557  if (var == egEnergyCorr::Scale::PedestalDown)
4558  alpha *= -1;
4559  } else {
4560  // observed pedestal corrected as a systematic on MC for now.
4561  // TODO : correct for it in the data
4562 
4563  double pedestal = getLayerPedestal(cl_eta, ptype, 0, var, varSF) +
4564  getLayerPedestal(cl_eta, ptype, 1, var, varSF) +
4565  getLayerPedestal(cl_eta, ptype, 2, var, varSF) +
4566  getLayerPedestal(cl_eta, ptype, 3, var, varSF);
4567 
4568  if (isRef)
4569  alpha = pedestal / energy *
4570  1.06; // approximate average ratio between calibrated and raw
4571  else
4572  alpha = pedestal / eraw;
4573  }
4574  }
4575 
4576  return alpha * varSF;
4577 }

◆ getAlphaUncAlpha()

std::pair< double, double > AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncAlpha ( const TH1 &  hh,
double  cl_eta,
double  et,
bool  useInterp 
) const
private

Definition at line 4390 of file egammaEnergyCorrectionTool.cxx.

4391  {
4392 
4393  // stay within the histogram limits in pT
4394  // no warning to say the pT is not in the "validity" range...
4395  int ibeta = hh.GetXaxis()->FindBin(aeta);
4396  int nbpT = hh.GetYaxis()->GetNbins();
4397  int ibpT = hh.GetYaxis()->FindBin(et);
4398  bool isOUFlow = false;
4399  if (ibpT > nbpT) {
4400  ibpT = nbpT;
4401  isOUFlow = true;
4402  } else if (ibpT == 0) {
4403  ibpT = 1;
4404  isOUFlow = true;
4405  }
4406  double alpha = 0.;
4407  double pTp = hh.GetYaxis()->GetBinCenter(ibpT), pTn = pTp;
4408  if (!useInterp || isOUFlow || (ibpT == nbpT && et > pTp) ||
4409  (ibpT == 1 && et < pTp))
4410  alpha = hh.GetBinContent(ibeta, ibpT);
4411  else {
4412  int jp = ibpT, jn = ibpT - 1;
4413  if (et > pTp) {
4414  jp = ibpT + 1;
4415  jn = ibpT;
4416  pTn = pTp;
4417  pTp = hh.GetYaxis()->GetBinCenter(jp);
4418  } else {
4419  pTn = hh.GetYaxis()->GetBinCenter(jn);
4420  }
4421  double aPos = hh.GetBinContent(ibeta, jp);
4422  double aNeg = hh.GetBinContent(ibeta, jn);
4423  alpha = (aPos * (et - pTn) + aNeg * (pTp - et)) / (pTp - pTn);
4424  ATH_MSG_VERBOSE("interp et = " << et << " alpha+ = " << aPos << " alpha- = "
4425  << aNeg << " alpha = " << alpha);
4426  }
4427  double dalpha = hh.GetBinError(ibeta, ibpT);
4428 
4429  return std::make_pair(alpha, dalpha);
4430 }

◆ getAlphaUncertainty()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncertainty ( long int  runnumber,
double  cl_eta,
double  cl_etaS2,
double  cl_etaCalo,
double  energy,
double  energyS2,
double  eraw,
PATCore::ParticleType::Type  ptype = PATCore::ParticleType::Electron,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 2455 of file egammaEnergyCorrectionTool.cxx.

2458  {
2459 
2460  double alphaNom =
2461  getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy, energyS2, eraw,
2462  ptype, egEnergyCorr::Scale::Nominal);
2463  double alphaVar = 0.;
2464 
2465  if (var != egEnergyCorr::Scale::AllUp &&
2466  var != egEnergyCorr::Scale::AllDown and
2467  var != egEnergyCorr::Scale::AllCorrelatedUp and
2468  var != egEnergyCorr::Scale::AllCorrelatedDown) {
2469  // not an ALLUP
2470  alphaVar = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy, energyS2,
2471  eraw, ptype, var, varSF) -
2472  alphaNom;
2473  } else if (var == egEnergyCorr::Scale::AllUp) {
2474  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatUp;
2475  ivar < egEnergyCorr::Scale::AllUp;
2476  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2477  if (ivar == egEnergyCorr::Scale::ZeeAllUp)
2478  continue;
2479  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2480  energyS2, eraw, ptype, ivar, varSF) -
2481  alphaNom;
2482  ATH_MSG_DEBUG("computing ALLUP, adding " << variationName(ivar) << ": "
2483  << v);
2484  alphaVar += pow(v, 2);
2485  }
2486  alphaVar = sqrt(alphaVar);
2487  } else if (var == egEnergyCorr::Scale::AllDown) {
2488  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatDown;
2489  ivar < egEnergyCorr::Scale::AllDown;
2490  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2491  if (ivar == egEnergyCorr::Scale::ZeeAllDown)
2492  continue;
2493  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2494  energyS2, eraw, ptype, ivar, varSF) -
2495  alphaNom;
2496  ATH_MSG_DEBUG("computing ALLDOWN, adding " << variationName(ivar) << ": "
2497  << v);
2498  alphaVar += pow(v, 2);
2499  }
2500  alphaVar = -sqrt(alphaVar);
2501  } else if (var == egEnergyCorr::Scale::AllCorrelatedUp) {
2502  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatUp;
2503  ivar < egEnergyCorr::Scale::AllUp;
2504  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2505  if (ivar == egEnergyCorr::Scale::ZeeAllUp or
2506  ivar == egEnergyCorr::Scale::LArCalibExtra2015PreUp or
2507  ivar == egEnergyCorr::Scale::LArTemperature2015PreUp or
2508  ivar == egEnergyCorr::Scale::LArTemperature2016PreUp or
2509  ivar == egEnergyCorr::Scale::E4ScintillatorUp)
2510  continue;
2511  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2512  energyS2, eraw, ptype, ivar, varSF) -
2513  alphaNom;
2514  alphaVar += pow(v, 2);
2515  }
2516  alphaVar = sqrt(alphaVar);
2517  } else if (var == egEnergyCorr::Scale::AllCorrelatedDown) {
2518  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatDown;
2519  ivar < egEnergyCorr::Scale::AllDown;
2520  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2521  if (ivar == egEnergyCorr::Scale::ZeeAllDown or
2522  ivar == egEnergyCorr::Scale::LArCalibExtra2015PreDown or
2523  ivar == egEnergyCorr::Scale::LArTemperature2015PreDown or
2524  ivar == egEnergyCorr::Scale::LArTemperature2016PreDown or
2525  ivar == egEnergyCorr::Scale::E4ScintillatorDown)
2526  continue;
2527  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2528  energyS2, eraw, ptype, ivar, varSF) -
2529  alphaNom;
2530  alphaVar += pow(v, 2);
2531  }
2532  alphaVar = -sqrt(alphaVar);
2533  }
2534 
2535  return alphaVar;
2536 }

◆ getAlphaValue()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaValue ( long int  runnumber,
double  cl_eta,
double  cl_etaS2,
double  cl_etaCalo,
double  energy,
double  energyS2,
double  eraw,
PATCore::ParticleType::Type  ptype = PATCore::ParticleType::Electron,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 2022 of file egammaEnergyCorrectionTool.cxx.

2027  {
2028 
2029  double meanET = getZeeMeanET(m_use_etaCalo_scales ? cl_etaCalo : cl_eta);
2030  ATH_MSG_DEBUG("getZeeMeanET() output " << meanET);
2031  ATH_MSG_DEBUG("getZeeMeanET() eta: "
2032  << double(m_use_etaCalo_scales ? cl_etaCalo : cl_eta));
2033  double meanE = meanET * std::cosh(cl_eta);
2034  double Et = energy / std::cosh(cl_eta);
2035 
2036  // Main Scale factor
2037 
2038  double alphaZee = getAlphaZee(
2039  runnumber, m_use_etaCalo_scales ? cl_etaCalo : cl_eta, var, varSF);
2040 
2041  // Sampling recalibration
2042 
2043  double daPS, daS12, linPS, linS12, linEacc, linPS_40_elec, linEacc_40_elec,
2044  linS12_40_elec;
2045  daPS = daS12 = linPS = linS12 = linEacc = linPS_40_elec = linEacc_40_elec =
2046  linS12_40_elec = 0.;
2047 
2048  double daE4 = 0., linE4 = 0.;
2049  // E4 contribution
2050  if ((m_esmodel == egEnergyCorr::es2015c_summer or
2051  m_esmodel == egEnergyCorr::es2016PRE or
2052  m_esmodel == egEnergyCorr::es2017 or
2053  m_esmodel == egEnergyCorr::es2017_summer or
2054  m_esmodel == egEnergyCorr::es2017_summer_improved or
2055  m_esmodel == egEnergyCorr::es2017_summer_final or
2056  m_esmodel == egEnergyCorr::es2017_R21_PRE or
2057  m_esmodel == egEnergyCorr::es2015_5TeV or
2058  m_esmodel == egEnergyCorr::es2017_R21_v0 or
2059  m_esmodel == egEnergyCorr::es2017_R21_v1 or
2060  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
2061  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
2062  m_esmodel == egEnergyCorr::es2018_R21_v0 or
2063  m_esmodel == egEnergyCorr::es2018_R21_v1 or
2064  m_esmodel == egEnergyCorr::es2022_R22_PRE or
2065  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) and
2066  (var == egEnergyCorr::Scale::E4ScintillatorUp or
2067  var == egEnergyCorr::Scale::E4ScintillatorDown)) {
2068  daE4 = getE4Uncertainty(cl_eta);
2069  if (var == egEnergyCorr::Scale::E4ScintillatorDown)
2070  daE4 *= -1;
2071  linE4 = getE4NonLinearity(cl_eta, energy, ptype) -
2072  getE4NonLinearity(cl_eta, meanE, PATCore::ParticleType::Electron);
2073  }
2074 
2075  // wtots1 contribution
2076  double daWtots1 = 0.;
2077  if ((m_esmodel == egEnergyCorr::es2017 or
2078  m_esmodel == egEnergyCorr::es2017_summer or
2079  m_esmodel == egEnergyCorr::es2017_summer_improved or
2080  m_esmodel == egEnergyCorr::es2017_summer_final or
2081  m_esmodel == egEnergyCorr::es2017_R21_PRE or
2082  m_esmodel == egEnergyCorr::es2015_5TeV or
2083  m_esmodel == egEnergyCorr::es2017_R21_v0 or
2084  m_esmodel == egEnergyCorr::es2017_R21_v1 or
2085  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
2086  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
2087  m_esmodel == egEnergyCorr::es2018_R21_v0 or
2088  m_esmodel == egEnergyCorr::es2018_R21_v1 or
2089  m_esmodel == egEnergyCorr::es2022_R22_PRE or
2090  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) and
2091  (var == egEnergyCorr::Scale::Wtots1Up or
2092  var == egEnergyCorr::Scale::Wtots1Down)) {
2093  daWtots1 = getWtots1Uncertainty(cl_eta, energy, ptype);
2094  if (var == egEnergyCorr::Scale::Wtots1Down)
2095  daWtots1 = -daWtots1;
2096  }
2097 
2098  // ... Presampler contribution
2099 
2100  if (var == egEnergyCorr::Scale::PSUp || var == egEnergyCorr::Scale::PSDown ||
2101  var == egEnergyCorr::Scale::PSb12Up ||
2102  var == egEnergyCorr::Scale::PSb12Down ||
2103  var == egEnergyCorr::Scale::LArElecUnconvUp ||
2104  var == egEnergyCorr::Scale::LArElecUnconvDown) {
2105 
2106  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
2107  daPS = getLayerUncertainty(0, cl_eta, var, varSF);
2108  linPS = getLayerNonLinearity(0, cl_eta, energy, ptype) -
2109  getLayerNonLinearity(0, cl_eta, meanE,
2110  PATCore::ParticleType::Electron);
2111  } else {
2112  daPS = getLayerUncertainty(0, cl_eta, var, varSF);
2113  linPS = getLayerNonLinearity(0, cl_eta, energy, ptype);
2114  linEacc = getLayerNonLinearity(
2115  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta, energy, ptype);
2116  linPS_40_elec = getLayerNonLinearity(0, cl_eta, meanE,
2117  PATCore::ParticleType::Electron);
2118  linEacc_40_elec = getLayerNonLinearity(
2119  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta,
2120  meanET * std::cosh(m_use_etaCalo_scales ? cl_etaCalo : cl_eta),
2121  PATCore::ParticleType::Electron);
2122  ATH_MSG_DEBUG(
2123  "es2023_R22_Run2_v0 PS non-linearity before Acc correction: "
2124  << linPS);
2125  linPS = linPS - linEacc * linPS_40_elec / linEacc_40_elec;
2126  ATH_MSG_DEBUG("es2023_R22_Run2_v0 PS non-linearity after Acc correction: "
2127  << linPS);
2128  }
2129  }
2130 
2131  // ... S1 / S2 contribution
2132 
2133  if (var == egEnergyCorr::Scale::S12Up or
2134  var == egEnergyCorr::Scale::S12Down or
2135  var == egEnergyCorr::Scale::LArCalibUp or
2136  var == egEnergyCorr::Scale::LArCalibDown or
2137  var == egEnergyCorr::Scale::LArCalibExtra2015PreUp or
2138  var == egEnergyCorr::Scale::LArCalibExtra2015PreDown or
2139  var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up or
2140  var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down) {
2141  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
2142  daS12 = getLayerUncertainty(1, cl_eta, var, varSF);
2143  linS12 = getLayerNonLinearity(1, cl_eta, energy, ptype) -
2144  getLayerNonLinearity(1, cl_eta, meanE,
2145  PATCore::ParticleType::Electron);
2146  } else {
2147  daS12 = getLayerUncertainty(1, cl_eta, var, varSF) *
2148  -1.; // uncertainty applied to E2 is equal to -delta E1/E2 scale
2149  linS12 = getLayerNonLinearity(1, cl_eta, energy, ptype);
2150  linEacc = getLayerNonLinearity(
2151  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta, energy, ptype);
2152  linS12_40_elec = getLayerNonLinearity(1, cl_eta, meanE,
2153  PATCore::ParticleType::Electron);
2154  linEacc_40_elec = getLayerNonLinearity(
2155  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta,
2156  meanET * std::cosh(m_use_etaCalo_scales ? cl_etaCalo : cl_eta),
2157  PATCore::ParticleType::Electron);
2158  ATH_MSG_DEBUG(
2159  "es2023_R22_Run2_v0 S12 non-linearity before Acc correction: "
2160  << linS12);
2161  linS12 = linS12 - linEacc * linS12_40_elec / linEacc_40_elec;
2162  ATH_MSG_DEBUG(
2163  "es2023_R22_Run2_v0 S12 non-linearity after Acc correction: "
2164  << linS12);
2165  }
2166  }
2167 
2168  // Material contribution
2169 
2170  double daMatID, daMatCryo, daMatCalo;
2171  daMatID = daMatCryo = daMatCalo = 0;
2172 
2173  // for release 21 sensitivity use the same getMaterialNonLinearity for all
2174  // particles while in sensitivities derived from run 1 this is only used for
2175  // electrons
2176 
2177  if (ptype != PATCore::ParticleType::Electron &&
2178  (m_esmodel != egEnergyCorr::es2017_R21_v1 &&
2179  m_esmodel != egEnergyCorr::es2017_R21_ofc0_v1 &&
2180  m_esmodel != egEnergyCorr::es2024_Run3_ofc0_v0 &&
2181  m_esmodel != egEnergyCorr::es2018_R21_v0 &&
2182  m_esmodel != egEnergyCorr::es2018_R21_v1 &&
2183  m_esmodel != egEnergyCorr::es2022_R22_PRE &&
2184  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)) {
2185 
2186  daMatID = getAlphaMaterial(cl_eta, egEnergyCorr::MatID, ptype, var, varSF);
2187  daMatCryo =
2188  getAlphaMaterial(cl_eta, egEnergyCorr::MatCryo, ptype, var, varSF);
2189  daMatCalo =
2190  getAlphaMaterial(cl_eta, egEnergyCorr::MatCalo, ptype, var, varSF);
2191 
2192  } else {
2193 
2194  daMatID =
2195  getMaterialNonLinearity(cl_eta, energy, egEnergyCorr::MatID, ptype, var,
2196  varSF) -
2197  getMaterialNonLinearity(cl_eta, meanE, egEnergyCorr::MatID,
2198  PATCore::ParticleType::Electron, var, varSF);
2199  daMatCryo =
2200  getMaterialNonLinearity(cl_eta, energy, egEnergyCorr::MatCryo, ptype,
2201  var, varSF) -
2202  getMaterialNonLinearity(cl_eta, meanE, egEnergyCorr::MatCryo,
2203  PATCore::ParticleType::Electron, var, varSF);
2204  daMatCalo =
2205  getMaterialNonLinearity(cl_eta, energy, egEnergyCorr::MatCalo, ptype,
2206  var, varSF) -
2207  getMaterialNonLinearity(cl_eta, meanE, egEnergyCorr::MatCalo,
2208  PATCore::ParticleType::Electron, var, varSF);
2209  }
2210 
2211  // Pedestal subtraction
2212 
2213  double daPedestal =
2214  getAlphaPedestal(cl_eta, energy, eraw, ptype, false, var, varSF) -
2215  getAlphaPedestal(cl_eta, meanE, eraw, PATCore::ParticleType::Electron,
2216  true, var, varSF);
2217 
2218  // double pedestal systematics for 2016, Guillaume 12/05/16
2219  if (m_esmodel == egEnergyCorr::es2016PRE) {
2220  daPedestal *= 2;
2221  }
2222 
2223  // Leakage contribution (electron-photon difference)
2224  double daLeakage = getAlphaLeakage2D(cl_etaS2, Et, ptype, var, varSF);
2225 
2226  // L1 Gain switch contribution
2227 
2228  double daL1GainSwitch = 0.;
2229 
2230  if (var == egEnergyCorr::Scale::L1GainUp ||
2231  var == egEnergyCorr::Scale::L1GainDown) {
2232 
2233  int eg_e1hg_ptype;
2234  if (ptype == PATCore::ParticleType::Electron)
2235  eg_e1hg_ptype = 0;
2236  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2237  eg_e1hg_ptype = 1;
2238  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2239  eg_e1hg_ptype = 2;
2240  else
2241  return -1;
2242 
2243  daL1GainSwitch = m_e1hg_tool->getAlpha(eg_e1hg_ptype, energy, cl_eta, true);
2244  if (var == egEnergyCorr::Scale::L1GainDown)
2245  daL1GainSwitch = -daL1GainSwitch;
2246  }
2247 
2248  // L2 Gain switch contribution
2249 
2250  double daL2GainSwitch = 0.;
2251  double daL2MediumGainSwitch = 0.;
2252  double daL2LowGainSwitch = 0.;
2253 
2254  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0 &&
2255  (var == egEnergyCorr::Scale::L2GainUp ||
2256  var == egEnergyCorr::Scale::L2GainDown)) {
2257  if (m_gain_tool) { // recipe for run1
2258  if (!(std::abs(cl_eta) < 1.52 && std::abs(cl_eta) > 1.37) &&
2259  std::abs(cl_eta) < 2.4) {
2260  double evar = m_gain_tool->CorrectionGainTool(cl_eta, energy / GeV,
2261  energyS2 / GeV, ptype);
2262  double meanES2 = m_zeeES2Profile->GetBinContent(
2263  m_zeeES2Profile->FindFixBin(cl_eta)); // in GeV already
2264  double eref = m_gain_tool->CorrectionGainTool(
2265  cl_eta, meanE / GeV, meanES2, PATCore::ParticleType::Electron);
2266  daL2GainSwitch = evar / energy - eref / meanE;
2267  if (var == egEnergyCorr::Scale::L2GainDown)
2268  daL2GainSwitch = -daL2GainSwitch;
2269  }
2270  } else if (m_gain_tool_run2) { // recipe for run 2, see ATLASEG-44
2271  daL2GainSwitch = m_gain_tool_run2->getUncertainty(cl_etaCalo, Et, ptype,
2272  m_useL2GainCorrection);
2273  if (var == egEnergyCorr::Scale::L2GainDown)
2274  daL2GainSwitch *= -1;
2275  ATH_MSG_DEBUG("L2 gain uncertainty: " << daL2GainSwitch);
2276  } else {
2277  ATH_MSG_ERROR(
2278  "trying to compute gain systematic, but no tool for doing it has "
2279  "been instantiated, setting sys to 0");
2280  daL2GainSwitch = 0.;
2281  }
2282  }
2283 
2284  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0 &&
2285  (var == egEnergyCorr::Scale::L2MediumGainUp ||
2286  var == egEnergyCorr::Scale::L2MediumGainDown)) {
2287  if (m_gain_tool_run2) { // recipe for run 2, see ATLASEG-44
2288  daL2MediumGainSwitch = m_gain_tool_run2->getUncertainty(
2289  cl_etaCalo, Et, ptype, m_useL2GainCorrection,
2290  egGain::GainUncertainty::GainType::MEDIUM);
2291  if (var == egEnergyCorr::Scale::L2MediumGainDown)
2292  daL2MediumGainSwitch *= -1;
2293  ATH_MSG_DEBUG("L2 gain Medium uncertainty: " << daL2MediumGainSwitch);
2294  } else {
2295  ATH_MSG_ERROR(
2296  "trying to compute gain systematic, but no tool for doing it has "
2297  "been instantiated, setting sys to 0");
2298  daL2MediumGainSwitch = 0.;
2299  }
2300  }
2301 
2302  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0 &&
2303  (var == egEnergyCorr::Scale::L2LowGainUp ||
2304  var == egEnergyCorr::Scale::L2LowGainDown)) {
2305  if (m_gain_tool_run2) { // recipe for run 2, see ATLASEG-44
2306  daL2LowGainSwitch = m_gain_tool_run2->getUncertainty(
2307  cl_etaCalo, Et, ptype, m_useL2GainCorrection,
2308  egGain::GainUncertainty::GainType::LOW);
2309  if (var == egEnergyCorr::Scale::L2LowGainDown)
2310  daL2LowGainSwitch *= -1;
2311  ATH_MSG_DEBUG("L2 gain Low uncertainty: " << daL2LowGainSwitch);
2312  } else {
2313  ATH_MSG_ERROR(
2314  "trying to compute Low gain systematic, but no tool for doing it has "
2315  "been instantiated, setting sys to 0");
2316  daL2LowGainSwitch = 0.;
2317  }
2318  }
2319 
2320  // pp0 (and IBL)
2321  double dapp0 = 0.;
2322  // values from the histogram already are 0 for the Z->ee electrons
2323  if (var == egEnergyCorr::Scale::MatPP0Up or
2324  var == egEnergyCorr::Scale::MatPP0Down) {
2325 
2326  // new parameterization for release 21 reconstruction with mc16 geometries +
2327  // distortions
2328  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
2329  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2330  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
2331  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
2332  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
2333  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
2334  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2335 
2336  if (std::abs(cl_eta) < 1.5)
2337  dapp0 = getMaterialEffect(egEnergyCorr::ConfigIBL, ptype, cl_eta,
2338  energy / GeV / cosh(cl_eta)) -
2339  getMaterialEffect(egEnergyCorr::ConfigIBL,
2340  PATCore::ParticleType::Electron, cl_eta,
2341  getZeeMeanET(cl_eta) / GeV);
2342  else
2343  dapp0 = getMaterialEffect(egEnergyCorr::ConfigPP0, ptype, cl_eta,
2344  energy / GeV / cosh(cl_eta)) -
2345  getMaterialEffect(egEnergyCorr::ConfigPP0,
2346  PATCore::ParticleType::Electron, cl_eta,
2347  getZeeMeanET(cl_eta) / GeV);
2348 
2349  if (var == egEnergyCorr::Scale::MatPP0Down) {
2350  dapp0 = -dapp0;
2351  }
2352  }
2353 
2354  // release 20 run 2 systematics for mc15 like geometries
2355  else {
2356  // Just pick the owned one from a unique_ptr per case
2357  const TH2* histo = nullptr;
2358  if (ptype == PATCore::ParticleType::Electron && m_pp0_elec)
2359  histo = m_pp0_elec.get();
2360  else if (ptype == PATCore::ParticleType::ConvertedPhoton && m_pp0_conv)
2361  histo = m_pp0_conv.get();
2362  else if (ptype == PATCore::ParticleType::UnconvertedPhoton &&
2363  m_pp0_unconv)
2364  histo = m_pp0_unconv.get();
2365 
2366  if (histo) {
2367  const double aeta = std::abs(cl_eta);
2368  dapp0 = getValueHistAt(*histo, aeta, energy / GeV / cosh(cl_eta), false,
2369  true, false, true);
2370  if (var == egEnergyCorr::Scale::MatPP0Down) {
2371  dapp0 = -dapp0;
2372  }
2373 
2374  // normalize to pp0 systematics
2375  if (aeta > 1.5 and aeta < 2.0) {
2376  dapp0 *= 2.6;
2377  } else if (aeta >= 2.0 and aeta <= 2.5) {
2378  dapp0 *= 2.3;
2379  }
2380  }
2381  }
2382  }
2383 
2384  // Conversion systematics
2385 
2386  double daConvSyst = getAlphaConvSyst(cl_eta, energy, ptype, var, varSF);
2387 
2388  // topo cluster threshold systematics for release 21
2389  double daTopoCluster = 0;
2390  if ((var == egEnergyCorr::Scale::topoClusterThresUp ||
2391  var == egEnergyCorr::Scale::topoClusterThresDown) &&
2392  (m_esmodel == egEnergyCorr::es2017_R21_v0 ||
2393  m_esmodel == egEnergyCorr::es2017_R21_v1 ||
2394  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2395  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
2396  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
2397  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
2398  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
2399  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
2400  double Et = energy / cosh(cl_eta);
2401  double Et0 = 10000.;
2402  // Effect taken as 10**-3/(Et/10GeV) - order of magniture from
2403  // https://indico.cern.ch/event/669895/contributions/2745266/attachments/1535612/2405452/slides.pdf
2404  if (var == egEnergyCorr::Scale::topoClusterThresUp)
2405  daTopoCluster = 1e-3 * (1. / (Et / Et0) - 1. / (meanET / Et0));
2406  if (var == egEnergyCorr::Scale::topoClusterThresDown)
2407  daTopoCluster = -1e-3 * (1. / (Et / Et0) - 1. / (meanET / Et0));
2408  }
2409 
2410  // ADC non linearity correction. 30% of the effect from
2411  // https://indico.cern.ch/event/1001455/contributions/4205636/attachments/2179584/3681315/ADC-linearity-28jan2021.pdf
2412  // ?
2413  double daADCLin = 0;
2414  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0 &&
2415  (var == egEnergyCorr::Scale::ADCLinUp ||
2416  var == egEnergyCorr::Scale::ADCLinDown)) {
2417  if (m_ADCLinearity_tool) {
2418  double corr = m_ADCLinearity_tool->getCorr(cl_etaCalo, Et, ptype) - 1.;
2419  daADCLin = 0.3 * corr;
2420  } else {
2421  ATH_MSG_WARNING(
2422  "trying to compute ADC correction systematic, but no tool for doing "
2423  "it has been instantiated, setting sys to 0");
2424  daADCLin = 0.;
2425  }
2426  if (var == egEnergyCorr::Scale::ADCLinDown)
2427  daADCLin *= -1;
2428  }
2429 
2430  // Total
2431  double alphaTot = alphaZee;
2432  alphaTot += daE4 * linE4;
2433  alphaTot += daPS * linPS;
2434  alphaTot += daS12 * linS12;
2435  alphaTot += daMatID + daMatCryo + daMatCalo;
2436  alphaTot += daLeakage;
2437  alphaTot += daL1GainSwitch;
2438  alphaTot += daL2GainSwitch;
2439  alphaTot += daL2MediumGainSwitch;
2440  alphaTot += daL2LowGainSwitch;
2441  alphaTot += daConvSyst;
2442  alphaTot += daPedestal;
2443  alphaTot += daWtots1;
2444  alphaTot += dapp0;
2445  alphaTot += daTopoCluster;
2446  alphaTot += daADCLin;
2447 
2448  ATH_MSG_DEBUG("alpha value for " << variationName(var) << " = " << alphaTot);
2449 
2450  return alphaTot;
2451 }

◆ getAlphaZee()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaZee ( long int  runnumber,
double  eta,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 3158 of file egammaEnergyCorrectionTool.cxx.

3160  {
3161 
3162  if (!m_zeeNom) {
3163  ATH_MSG_FATAL("no data for Zee");
3164  return -999.0;
3165  }
3166 
3167  double value = 0.;
3168  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
3169  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3170  value = m_zeeNom->GetBinContent(ieta);
3171  } else {
3172  if (runnumber > 341649 && runnumber <= 364292) {
3173  // 2018 runnumber range
3174  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3175  value = m_zeeNom->GetBinContent(ieta);
3176  } else if (runnumber > 364292) {
3177  ATH_MSG_WARNING(
3178  "es2023_R22_Run2_v0 is only valid for Run-2 data! using 2018 scales");
3179  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3180  value = m_zeeNom->GetBinContent(ieta);
3181  }
3182  }
3183 
3184  if ((m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3185  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
3186  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3187  runnumber <= 341649 && runnumber >= 324320) {
3188  int ieta = std::as_const(*m_zeeNom_data2017).GetXaxis()->FindBin(eta);
3189  value = m_zeeNom_data2017->GetBinContent(ieta);
3190  }
3191 
3192  // for es2017_R21_v0 different set of scales for 2017, 2016 and 2015 data
3193  if (m_esmodel == egEnergyCorr::es2017_R21_v0 && runnumber < 322817 &&
3194  runnumber >= 297000) {
3195  int ieta = std::as_const(*m_zeeNom_data2016).GetXaxis()->FindBin(eta);
3196  value = m_zeeNom_data2016->GetBinContent(ieta);
3197  }
3198 
3199  if ((m_esmodel == egEnergyCorr::es2017_R21_v1 ||
3200  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3201  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
3202  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3203  runnumber < 322817 && runnumber >= 297000) {
3204  int ieta = std::as_const(*m_zeeNom_data2016).GetXaxis()->FindBin(eta);
3205  value = m_zeeNom_data2016->GetBinContent(ieta);
3206  }
3207 
3208  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber < 322817 &&
3209  runnumber >= 297000) {
3210  int ieta = std::as_const(*m_zeeNom_data2016).GetXaxis()->FindBin(eta);
3211  value = m_zeeNom_data2016->GetBinContent(ieta);
3212  }
3213 
3214  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber < 297000) {
3215  int ieta = std::as_const(*m_zeeNom_data2015).GetXaxis()->FindBin(eta);
3216  value = m_zeeNom_data2015->GetBinContent(ieta);
3217  }
3218 
3219  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber > 347847) {
3220  int ieta = std::as_const(*m_zeeNom_data2018).GetXaxis()->FindBin(eta);
3221  value = m_zeeNom_data2018->GetBinContent(ieta);
3222  }
3223 
3224  if (m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0) {
3225  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3226  value = m_zeeNom->GetBinContent(ieta);
3227  }
3228 
3229  if ((m_esmodel == egEnergyCorr::es2017 or
3230  m_esmodel == egEnergyCorr::es2017_summer or
3231  m_esmodel == egEnergyCorr::es2017_summer_improved or
3232  m_esmodel == egEnergyCorr::es2017_summer_final or
3233  m_esmodel == egEnergyCorr::es2015_5TeV or
3234  m_esmodel == egEnergyCorr::es2017_R21_v0 or
3235  m_esmodel == egEnergyCorr::es2017_R21_v1 or
3236  m_esmodel == egEnergyCorr::es2018_R21_v0 or
3237  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3238  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3239  runnumber < 297000) {
3240  // 2 sets of scales for this configuration
3241  // change histogram if 2015 data
3242  int ieta = std::as_const(*m_zeeNom_data2015).GetXaxis()->FindBin(eta);
3243  value = m_zeeNom_data2015->GetBinContent(ieta);
3244  }
3245 
3246  if (m_esmodel == egEnergyCorr::es2015PRE or
3247  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3248  m_esmodel == egEnergyCorr::es2015cPRE or
3249  m_esmodel == egEnergyCorr::es2015cPRE_res_improved) {
3250  // special case for es2015PRE
3251  // additional correction due to LAr temperature effect
3252  // for extrapolation 2012 -> 2015 temperature change
3253  // numbers from Guillaume 20150506
3254  /*
3255  2012 (K) 22/04/2015 DeltaResponse 2015/2012 (-2%/K) deltaAlpha
3256  EndCap C 88.41 88.63 -0.45% -0.45%
3257  Barrel C 88.47 88.70 -0.46% -0.46%
3258  Barrel A 88.50 88.71 -0.42% -0.42%
3259  EndCap A 88.70 88.70 +0.00% +0.00%
3260  */
3261  if (eta >= 0) { // side A
3262  if (eta < 1.45)
3263  value += -0.42E-2;
3264  else if (eta < 3.2)
3265  value += 0.;
3266  } else { // side C
3267  if (eta > -1.45)
3268  value += -0.46E-2;
3269  else if (eta > -3.2)
3270  value += -0.45E-2;
3271  }
3272 
3273  // special case for es2015PRE
3274  // additional correction for uA->MeV first 2 weeks 2015 data
3275  if (runnumber >= 266904 and runnumber <= 267639 and
3276  m_use_uA2MeV_2015_first2weeks_correction) {
3277  const double uA2MeV_correction =
3278  m_uA2MeV_2015_first2weeks_correction->GetBinContent(
3279  m_uA2MeV_2015_first2weeks_correction->FindFixBin(std::abs(eta)));
3280  // this takes into account also O((uA2MeV_correction - 1) * alpha) terms
3281  // a simpler formula would be: value + uA2MeV_correction - 1
3282  value = uA2MeV_correction * (1 + value) - 1;
3283  }
3284  } // end special case for es2015PRE*
3285 
3286  if ((m_esmodel == egEnergyCorr::es2015c_summer or
3287  m_esmodel == egEnergyCorr::es2016PRE) and
3288  m_use_temp_correction201215) {
3289  // keep the correction 2012->2015 for |eta| > 2.5
3290  // if (eta > 2.5 and eta < 3.2) value += 0.;
3291  if (eta < -2.5 and eta > -3.2)
3292  value += -0.45E-2;
3293  }
3294 
3295  if (m_esmodel == egEnergyCorr::es2015c_summer or
3296  m_esmodel ==
3297  egEnergyCorr::es2016PRE) { // correction for the extrapolation from
3298  // es2015_summer
3299  if (runnumber >= 297000) { // only for 2016 data
3300  if (eta >= 0) { // side A
3301  if (eta < 1.45)
3302  value *= 1.00028;
3303  else if (eta < 3.2)
3304  value *= 1.00018;
3305  } else { // side C
3306  if (eta > -1.45)
3307  value *= 1.00028;
3308  else if (eta > -3.2)
3309  value *= 0.99986;
3310  }
3311  }
3312  }
3313 
3314  ATH_MSG_DEBUG("getAlphaZee, def alpha " << value << " at eta = " << eta);
3315 
3316  if (var == egEnergyCorr::Scale::ZeeStatUp or
3317  var == egEnergyCorr::Scale::ZeeStatDown) {
3318  const double sign = (var == egEnergyCorr::Scale::ZeeStatUp) ? 1 : -1;
3319 
3320  TH1* h = ((TH1*)m_zeeNom.get());
3321 
3322  if ((m_esmodel == egEnergyCorr::es2017 or
3323  m_esmodel == egEnergyCorr::es2017_summer or
3324  m_esmodel == egEnergyCorr::es2017_summer_improved or
3325  m_esmodel == egEnergyCorr::es2017_summer_final or
3326  m_esmodel == egEnergyCorr::es2015_5TeV or
3327  m_esmodel == egEnergyCorr::es2017_R21_v0 or
3328  m_esmodel == egEnergyCorr::es2017_R21_v1 or
3329  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
3330  m_esmodel == egEnergyCorr::es2018_R21_v0 or
3331  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3332  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3333  runnumber < 297000) {
3334  h = ((TH1*)m_zeeNom_data2015.get()); // special for 2015 with es2017
3335  }
3336  if ((m_esmodel == egEnergyCorr::es2017_R21_v0 ||
3337  m_esmodel == egEnergyCorr::es2017_R21_v1 ||
3338  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
3339  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3340  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3341  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3342  runnumber >= 297000 && runnumber < 322817) {
3343  h = m_zeeNom_data2016.get(); // 2016 data
3344  }
3345  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber > 347847) {
3346  h = m_zeeNom_data2018.get();
3347  }
3348  //egEnergyCorr::es2024_Run3_ofc0_v0 noting to do (have only m_zeeNom)
3349 
3350  if ((m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3351  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3352  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3353  runnumber >= 324320 && runnumber <= 341649) {
3354  h = ((TH1*)m_zeeNom_data2017.get()); // 2017 data
3355  }
3356  double stat_error = h->GetBinError(h->FindFixBin(eta));
3357  if (m_use_stat_error_scaling) {
3358  stat_error = stat_error / sqrt(h->GetNbinsX());
3359  }
3360  value += sign * stat_error * varSF;
3361  } else if (var == egEnergyCorr::Scale::ZeeSystUp && m_zeeSyst) {
3362  value += get_ZeeSyst(eta) * varSF;
3363 
3364  } else if (var == egEnergyCorr::Scale::ZeeSystDown && m_zeeSyst) {
3365  value -= get_ZeeSyst(eta) * varSF;
3366  } else if (var == egEnergyCorr::Scale::OFCUp && m_zeeSystOFC) {
3367  value += get_OFCSyst(eta) * varSF;
3368  } else if (var == egEnergyCorr::Scale::EXTRARUN3PREUp &&
3369  m_esmodel ==
3370  egEnergyCorr::es2022_R22_PRE) // as this is a flat 0.4% syst
3371  // hardcoded, need to switch on
3372  // only for es2022_R22_PRE. OFC
3373  // should be OK, as the OFC file
3374  // is only defined for this
3375  // pre-recommendation.
3376  {
3377  value +=
3378  0.4E-2 *
3379  varSF; // flat 0.4% syst (details:
3380  // https://indico.cern.ch/event/1250560/contributions/5253619/attachments/2586538/4462853/mc21-change.pdf)
3381  } else if (var == egEnergyCorr::Scale::EXTRARUN3PREDown &&
3382  m_esmodel == egEnergyCorr::es2022_R22_PRE) {
3383  value -= 0.4E-2 * varSF;
3384  } else if (var == egEnergyCorr::Scale::OFCDown && m_zeeSystOFC) {
3385  value -= get_OFCSyst(eta) * varSF;
3386  } else if (var == egEnergyCorr::Scale::ZeePhysUp && m_zeePhys) {
3387 
3388  int ieta = std::as_const(*m_zeePhys).GetXaxis()->FindBin(eta);
3389  value += m_zeePhys->GetBinContent(ieta) * varSF;
3390 
3391  } else if (var == egEnergyCorr::Scale::ZeePhysDown && m_zeePhys) {
3392 
3393  int ieta = std::as_const(*m_zeePhys).GetXaxis()->FindBin(eta);
3394  value -= m_zeePhys->GetBinContent(ieta) * varSF;
3395 
3396  } else if ((var == egEnergyCorr::Scale::LArTemperature2015PreUp or
3397  var == egEnergyCorr::Scale::LArTemperature2015PreDown) and
3398  (m_esmodel == egEnergyCorr::es2015PRE or
3399  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3400  m_esmodel == egEnergyCorr::es2015cPRE or
3401  m_esmodel == egEnergyCorr::es2015cPRE_res_improved) and
3402  m_use_temp_correction201215) {
3403  // special case only for es2015PRE
3404  // add LAr temperature effect for extrapolation 2012 -> 2015 temperature
3405  // change numbers from Guillaume 20150506
3406 
3407  const double aeta = std::abs(eta);
3408  const double sign =
3409  (var == egEnergyCorr::Scale::LArTemperature2015PreUp) ? 1 : -1;
3410  if (aeta < 1.45) {
3411  value += 0.15E-2 * sign;
3412  } else if (aeta > 1.45 and aeta < 3.2) {
3413  value += 0.25E-2 * sign;
3414  }
3415  }
3416 
3417  else if ((var == egEnergyCorr::Scale::LArTemperature2015PreUp or
3418  var == egEnergyCorr::Scale::LArTemperature2015PreDown) and
3419  (m_esmodel == egEnergyCorr::es2015c_summer or
3420  m_esmodel == egEnergyCorr::es2016PRE) and
3421  m_use_temp_correction201215) {
3422  // keep 2012->2015 extrapolation correction for eta > 2.5
3423  const double aeta = std::abs(eta);
3424  const double sign =
3425  (var == egEnergyCorr::Scale::LArTemperature2015PreUp) ? 1 : -1;
3426  if (aeta > 2.5 and aeta < 3.2) {
3427  value += 0.25E-2 * sign;
3428  }
3429  }
3430 
3431  else if ((var == egEnergyCorr::Scale::LArTemperature2016PreUp or
3432  var == egEnergyCorr::Scale::LArTemperature2016PreDown) and
3433  (m_esmodel == egEnergyCorr::es2016PRE) and
3434  m_use_temp_correction201516) {
3435  // special case for es2016PRE (extrapolation from 2015)
3436  const double sign =
3437  (var == egEnergyCorr::Scale::LArTemperature2016PreUp) ? 1 : -1;
3438  // temp + pileup
3439  value += qsum(0.05E-2, 0.02E-2) *
3440  sign; // Guillaume email 23/05/2016 + 26/5/2016
3441  }
3442 
3443  else if (var == egEnergyCorr::Scale::ZeeAllDown ||
3444  var == egEnergyCorr::Scale::ZeeAllUp) {
3445 
3446  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3447  double diff = pow(m_zeeNom->GetBinError(ieta) * varSF, 2);
3448 
3449  if (m_zeeSyst) {
3450  diff += pow(get_ZeeSyst(eta) * varSF, 2);
3451  }
3452 
3453  if (m_zeePhys) {
3454  ieta = std::as_const(*m_zeePhys).GetXaxis()->FindBin(eta);
3455  diff += pow(m_zeePhys->GetBinContent(ieta) * varSF, 2);
3456  }
3457 
3458  if (var == egEnergyCorr::Scale::ZeeAllUp)
3459  value += sqrt(diff);
3460  else if (var == egEnergyCorr::Scale::ZeeAllDown)
3461  value -= sqrt(diff);
3462  }
3463 
3464  return value;
3465 }

◆ getCorrectedEnergy()

double AtlasRoot::egammaEnergyCorrectionTool::getCorrectedEnergy ( unsigned int  runnumber,
PATCore::ParticleDataType::DataType  dataType,
PATCore::ParticleType::Type  ptype,
double  cl_eta,
double  cl_etaS2,
double  cl_etaCalo,
double  energy,
double  energyS2,
double  eraw,
RandomNumber  seed,
egEnergyCorr::Scale::Variation  scaleVar = egEnergyCorr::Scale::None,
egEnergyCorr::Resolution::Variation  resVar = egEnergyCorr::Resolution::None,
egEnergyCorr::Resolution::resolutionType  resType = egEnergyCorr::Resolution::SigmaEff90,
double  varSF = 1.0 
) const

Definition at line 1900 of file egammaEnergyCorrectionTool.cxx.

1906  {
1907  double fullyCorrectedEnergy = energy;
1908 
1909  // Correct fast sim flavours
1910 
1911  if (dataType == PATCore::ParticleDataType::FastShower) // Frozen shower sim
1912  fullyCorrectedEnergy = energy * this->applyFStoG4(cl_eta);
1913  else if (dataType == PATCore::ParticleDataType::Fast) // AtlFast2 sim
1914  {
1915  fullyCorrectedEnergy =
1916  energy *
1917  this->applyAFtoG4(cl_eta, 0.001 * energy / cosh(cl_eta), ptype);
1918  }
1919 
1920  // If nothing is to be done
1921 
1922  if (scaleVar == egEnergyCorr::Scale::None &&
1923  resVar == egEnergyCorr::Resolution::None)
1924  return fullyCorrectedEnergy;
1925 
1926  ATH_MSG_DEBUG(std::format("after sim fl = {:.2f}", fullyCorrectedEnergy));
1927 
1928  // main E-scale corrections
1929 
1930  if (dataType == PATCore::ParticleDataType::Data) { // ... Data
1931 
1932  if (scaleVar == egEnergyCorr::Scale::Nominal) {
1933  double alpha =
1934  getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, fullyCorrectedEnergy,
1935  energyS2, eraw, ptype, scaleVar, varSF);
1936  fullyCorrectedEnergy /= (1 + alpha);
1937  // apply additional k.E+b corrections if histograms exist (like in
1938  // es2017_R21_v1)
1939  if (m_zeeFwdk && m_zeeFwdb && std::abs(cl_eta) > 2.5) { // calo eta?
1940  int ieta_k = m_zeeFwdk->GetXaxis()->FindFixBin(cl_eta);
1941  double value_k = m_zeeFwdk->GetBinContent(ieta_k);
1942  int ieta_b = m_zeeFwdb->GetXaxis()->FindFixBin(cl_eta);
1943  double value_b = m_zeeFwdb->GetBinContent(ieta_b);
1944  fullyCorrectedEnergy =
1945  value_k * fullyCorrectedEnergy +
1946  value_b * GeV; // value is stored in GeV in the histogram file
1947  }
1948  ATH_MSG_DEBUG(std::format("after alpha = {:.2f}", fullyCorrectedEnergy));
1949  }
1950 
1951  } else { // ... MC
1952 
1953  // Do the energy scale correction (for systematic variations)
1954 
1955  if (scaleVar != egEnergyCorr::Scale::None &&
1956  scaleVar != egEnergyCorr::Scale::Nominal) {
1957  double deltaAlpha = getAlphaUncertainty(runnumber, cl_eta, cl_etaS2, cl_etaCalo,
1958  fullyCorrectedEnergy, energyS2,
1959  eraw, ptype, scaleVar, varSF);
1960  ATH_MSG_DEBUG("alpha sys " << variationName(scaleVar) << " = "
1961  << deltaAlpha);
1962  fullyCorrectedEnergy *= (1 + deltaAlpha);
1963  ATH_MSG_DEBUG(std::format("after mc alpha = {:.2f}", fullyCorrectedEnergy));
1964  }
1965 
1966  // AF2 systematics (this will not be in the sum of all other NP in the 1 NP
1967  // model)
1968  if (dataType == PATCore::ParticleDataType::Fast &&
1969  (m_esmodel == egEnergyCorr::es2017_R21_v0 ||
1970  m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1971  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1972  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
1973  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1974  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1975  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1976  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
1977  if (scaleVar == egEnergyCorr::Scale::af2Up or
1978  scaleVar == egEnergyCorr::Scale::af2Down) {
1979  double daAF2 = 0.;
1980  if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1981  if (scaleVar == egEnergyCorr::Scale::af2Up)
1982  daAF2 = 0.005;
1983  if (scaleVar == egEnergyCorr::Scale::af2Down)
1984  daAF2 = -0.005;
1985  }
1986  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1987  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1988  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
1989  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1990  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1991  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1992  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1993  if (scaleVar == egEnergyCorr::Scale::af2Up)
1994  daAF2 = 0.001;
1995  if (scaleVar == egEnergyCorr::Scale::af2Down)
1996  daAF2 = -0.001;
1997  }
1998  fullyCorrectedEnergy *= (1 + daAF2);
1999  }
2000  }
2001 
2002  // Do the resolution correction
2003  if (resVar != egEnergyCorr::Resolution::None)
2004  fullyCorrectedEnergy *=
2005  getSmearingCorrection(cl_eta, cl_etaCalo, fullyCorrectedEnergy,
2006  random_seed, ptype, dataType, resVar, resType);
2007 
2008  ATH_MSG_DEBUG(std::format("after resolution correction = {:.2f}", fullyCorrectedEnergy));
2009  }
2010 
2011  return fullyCorrectedEnergy;
2012 }

◆ getCorrectedMomentum()

double AtlasRoot::egammaEnergyCorrectionTool::getCorrectedMomentum ( PATCore::ParticleDataType::DataType  dataType,
PATCore::ParticleType::Type  ptype,
double  momentum,
double  trk_eta,
egEnergyCorr::Scale::Variation  scaleVar = egEnergyCorr::Scale::None,
double  varSF = 1.0 
) const

take eta and uncorrected energy of electron, return corrected energy, apply given variation, for given particle type Note : energies in MeV This is the main method for users.

It internally calls all other needed methods automatically

Definition at line 1875 of file egammaEnergyCorrectionTool.cxx.

1878  {
1879 
1880  double correctedMomentum = momentum;
1881  double aeta = std::abs(trk_eta);
1882 
1883  if (ptype == PATCore::ParticleType::Electron &&
1884  dataType != PATCore::ParticleDataType::Data) {
1885 
1886  double corr = 0;
1887  if (scaleVar == egEnergyCorr::Scale::MomentumUp)
1888  corr = m_trkSyst->GetBinContent(m_trkSyst->FindFixBin(aeta));
1889  else if (scaleVar == egEnergyCorr::Scale::MomentumDown)
1890  corr = -m_trkSyst->GetBinContent(m_trkSyst->FindFixBin(aeta));
1891 
1892  correctedMomentum *= 1. + corr * varSF;
1893  }
1894 
1895  return correctedMomentum;
1896 }

◆ getDeltaX()

double AtlasRoot::egammaEnergyCorrectionTool::getDeltaX ( double  cl_eta,
egEnergyCorr::MaterialCategory  imat,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal 
) const
private

Definition at line 3848 of file egammaEnergyCorrectionTool.cxx.

3850  {
3851 
3852  double value = 0.;
3853  double aeta = std::abs(cl_eta);
3854 
3855  // "ID" : inner detector material; bottom-up (from construction/simulation
3856  // accuracy : ConfigA)
3857 
3858  if (imat == egEnergyCorr::MatID && m_dX_ID_Nom) {
3859 
3860  // ... NOTE : watch out here : this histo does not follow the usual
3861  // value/error look-up convention
3862 
3863  if (var == egEnergyCorr::Scale::MatIDUp)
3864  value += m_dX_ID_Nom->GetBinContent(m_dX_ID_Nom->FindFixBin(aeta));
3865  else if (var == egEnergyCorr::Scale::MatIDDown)
3866  value -= m_dX_ID_Nom->GetBinContent(m_dX_ID_Nom->FindFixBin(aeta));
3867 
3868  // "Cryo" : integral from IP to PS or Acc, depending on eta
3869 
3870  } else if (imat == egEnergyCorr::MatCryo && aeta < 1.82 &&
3871  m_dX_IPPS_Nom) { // Integral between IP and PS
3872 
3873  value = m_dX_IPPS_Nom->GetBinContent(m_dX_IPPS_Nom->FindFixBin(aeta));
3874 
3875  if (var == egEnergyCorr::Scale::MatCryoUp)
3876  value += m_dX_IPPS_Nom->GetBinError(m_dX_IPPS_Nom->FindFixBin(aeta));
3877  else if (var == egEnergyCorr::Scale::MatCryoDown)
3878  value -= m_dX_IPPS_Nom->GetBinError(m_dX_IPPS_Nom->FindFixBin(aeta));
3879 
3880  // ... careful : sign below should be opposite to the effect of this source
3881  // on the PS scale!
3882  if (var == egEnergyCorr::Scale::LArElecUnconvUp && m_dX_IPPS_LAr)
3883  value -= m_dX_IPPS_LAr->GetBinContent(m_dX_IPPS_LAr->FindFixBin(aeta));
3884  else if (var == egEnergyCorr::Scale::LArElecUnconvDown && m_dX_IPPS_LAr)
3885  value += m_dX_IPPS_LAr->GetBinContent(m_dX_IPPS_LAr->FindFixBin(aeta));
3886 
3887  } else if (imat == egEnergyCorr::MatCryo && aeta > 1.82 &&
3888  m_dX_IPAcc_Nom) { // Integral between IP and Accordion
3889 
3890  value = m_dX_IPAcc_Nom->GetBinContent(m_dX_IPAcc_Nom->FindFixBin(aeta));
3891 
3892  if (var == egEnergyCorr::Scale::MatCryoUp)
3893  value += m_dX_IPAcc_Nom->GetBinError(m_dX_IPAcc_Nom->FindFixBin(aeta));
3894  else if (var == egEnergyCorr::Scale::MatCryoDown)
3895  value -= m_dX_IPAcc_Nom->GetBinError(m_dX_IPAcc_Nom->FindFixBin(aeta));
3896 
3897  if (var == egEnergyCorr::Scale::LArElecCalibUp && m_dX_IPAcc_LAr)
3898  value += m_dX_IPAcc_LAr->GetBinContent(m_dX_IPAcc_LAr->FindFixBin(aeta));
3899  else if (var == egEnergyCorr::Scale::LArElecCalibDown && m_dX_IPAcc_LAr)
3900  value -= m_dX_IPAcc_LAr->GetBinContent(m_dX_IPAcc_LAr->FindFixBin(aeta));
3901 
3902  if (var == egEnergyCorr::Scale::G4Up && m_dX_IPAcc_G4)
3903  value += m_dX_IPAcc_G4->GetBinContent(m_dX_IPAcc_G4->FindFixBin(aeta));
3904  else if (var == egEnergyCorr::Scale::G4Down && m_dX_IPAcc_G4)
3905  value -= m_dX_IPAcc_G4->GetBinContent(m_dX_IPAcc_G4->FindFixBin(aeta));
3906 
3907  if (var == egEnergyCorr::Scale::L1GainUp && m_dX_IPAcc_GL1)
3908  value += m_dX_IPAcc_GL1->GetBinContent(m_dX_IPAcc_GL1->FindFixBin(aeta));
3909  else if (var == egEnergyCorr::Scale::L1GainDown && m_dX_IPAcc_GL1)
3910  value -= m_dX_IPAcc_GL1->GetBinContent(m_dX_IPAcc_GL1->FindFixBin(aeta));
3911 
3912  // "Calo" : between PS and Strips
3913 
3914  } else if (imat == egEnergyCorr::MatCalo && aeta < 1.82 && m_dX_PSAcc_Nom) {
3915 
3916  value = m_dX_PSAcc_Nom->GetBinContent(m_dX_PSAcc_Nom->FindFixBin(aeta));
3917 
3918  if (var == egEnergyCorr::Scale::MatCaloUp)
3919  value += m_dX_PSAcc_Nom->GetBinError(m_dX_PSAcc_Nom->FindFixBin(aeta));
3920  else if (var == egEnergyCorr::Scale::MatCaloDown)
3921  value -= m_dX_PSAcc_Nom->GetBinError(m_dX_PSAcc_Nom->FindFixBin(aeta));
3922 
3923  if (var == egEnergyCorr::Scale::LArUnconvCalibUp && m_dX_PSAcc_LAr)
3924  value += m_dX_PSAcc_LAr->GetBinContent(m_dX_PSAcc_LAr->FindFixBin(aeta));
3925  else if (var == egEnergyCorr::Scale::LArUnconvCalibDown && m_dX_PSAcc_LAr)
3926  value -= m_dX_PSAcc_LAr->GetBinContent(m_dX_PSAcc_LAr->FindFixBin(aeta));
3927 
3928  if (var == egEnergyCorr::Scale::G4Up && m_dX_PSAcc_G4)
3929  value += m_dX_PSAcc_G4->GetBinContent(m_dX_PSAcc_G4->FindFixBin(aeta));
3930  else if (var == egEnergyCorr::Scale::G4Down && m_dX_PSAcc_G4)
3931  value -= m_dX_PSAcc_G4->GetBinContent(m_dX_PSAcc_G4->FindFixBin(aeta));
3932  }
3933 
3934  return value;
3935 }

◆ getE4NonLinearity()

double AtlasRoot::egammaEnergyCorrectionTool::getE4NonLinearity ( double  cl_eta,
double  meanE,
PATCore::ParticleType::Type  ptype 
) const
private

Definition at line 3705 of file egammaEnergyCorrectionTool.cxx.

3706  {
3707  double value = 0;
3708  const double aeta = std::abs(cl_eta);
3709  const double ETGeV = energy / cosh(cl_eta) / 1E3;
3710 
3711  // This will point to the return of get() of a unique_ptr
3712  const TAxis* axis;
3713  const TList* graphs;
3714 
3715  if (ptype == PATCore::ParticleType::Electron) {
3716  axis = m_E4ElectronEtaBins.get();
3717  graphs = m_E4ElectronGraphs.get();
3718  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3719  axis = m_E4UnconvertedEtaBins.get();
3720  graphs = m_E4UnconvertedGraphs.get();
3721  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3722  axis = m_E4ConvertedEtaBins.get();
3723  graphs = m_E4ConvertedGraphs.get();
3724  } else {
3725  ATH_MSG_FATAL("invalid particle type");
3726  return -1;
3727  }
3728 
3729  const int ieta = axis->FindFixBin(aeta) - 1;
3730  if (ieta >= 0 and ieta < graphs->GetSize()) {
3731  value = static_cast<TGraph*>(graphs->At(ieta))->Eval(ETGeV);
3732  }
3733 
3734  return value;
3735 }

◆ getE4Uncertainty()

double AtlasRoot::egammaEnergyCorrectionTool::getE4Uncertainty ( double  eta)
staticprivate

Definition at line 3467 of file egammaEnergyCorrectionTool.cxx.

3467  {
3468  const double aeta = std::abs(eta);
3469  if ((aeta > 1.6) or (aeta < 1.4)) {
3470  return 0.;
3471  }
3472 
3473  // numbers from Archil 20/5/2016
3474 
3475  double data_mc_difference = 0.;
3476  if (aeta < 1.46) {
3477  data_mc_difference = 1E-2;
3478  } // 1.4 - 1.46
3479  else if (aeta < 1.52) {
3480  data_mc_difference = 3E-2;
3481  } // 1.46 - 1.52
3482  else {
3483  data_mc_difference = 4.3E-2;
3484  } // 1.52 - 1.6
3485 
3486  const double em_scale = 2.4E-2;
3487  const double mbias = 1E-2; // Archil presentation 26/5/2016
3488  const double laser = 4E-2;
3489 
3490  return std::sqrt(data_mc_difference * data_mc_difference +
3491  em_scale * em_scale + mbias * mbias + laser * laser);
3492 }

◆ getInterpolateConvSyst2D()

double AtlasRoot::egammaEnergyCorrectionTool::getInterpolateConvSyst2D ( const TH2 &  conv_hist,
double  aeta,
double  ET 
) const
private

Definition at line 4489 of file egammaEnergyCorrectionTool.cxx.

4490  {
4491 
4492  // use one bin in eta and linear interpolation in Et between 2 bins
4493  int ieta = conv_hist.GetXaxis()->FindBin(aeta);
4494 
4495  int ipt = conv_hist.GetYaxis()->FindBin(ET);
4496  double ptBin = conv_hist.GetYaxis()->GetBinCenter(ipt);
4497 
4498  int i1, i2;
4499  double pt1, pt2;
4500  if (ET > ptBin) {
4501  i1 = ipt;
4502  i2 = ipt + 1;
4503  pt1 = ptBin;
4504  pt2 = conv_hist.GetYaxis()->GetBinCenter(i2);
4505  } else {
4506  i1 = ipt - 1;
4507  i2 = ipt;
4508  pt1 = conv_hist.GetYaxis()->GetBinCenter(i1);
4509  pt2 = ptBin;
4510  }
4511 
4512  int nbins = conv_hist.GetYaxis()->GetNbins();
4513  double value = 0;
4514  if (i1 >= 1 && i1 < nbins) {
4515  double v1 = conv_hist.GetBinContent(ieta, i1);
4516  double v2 = conv_hist.GetBinContent(ieta, i2);
4517  value = (v1 * (pt2 - ET) + v2 * (ET - pt1)) / (pt2 - pt1);
4518  } else {
4519  if (ipt < 1)
4520  ipt = 1;
4521  if (ipt > nbins)
4522  ipt = nbins;
4523  value = conv_hist.GetBinContent(ieta, ipt);
4524  }
4525 
4526  return value;
4527 }

◆ getLayerNonLinearity()

double AtlasRoot::egammaEnergyCorrectionTool::getLayerNonLinearity ( int  iLayer,
double  cl_eta,
double  energy,
PATCore::ParticleType::Type  ptype 
) const
private

Definition at line 3737 of file egammaEnergyCorrectionTool.cxx.

3739  {
3740 
3741  double value = 0;
3742  // Accordion histogram specicif condition
3743  if (iLayer == 6 && std::abs(cl_eta) >= 2.47)
3744  cl_eta = 2.46;
3745  double aeta = std::abs(cl_eta);
3746  double ET = energy / cosh(cl_eta);
3747 
3748  // move out of crack
3749  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
3750  aeta = nearestEtaBEC(aeta);
3751 
3752  // argument ET is transverse energy in MeV
3753 
3754  if (iLayer == 0 && aeta >= 1.82)
3755  return value;
3756 
3757  if (ptype == PATCore::ParticleType::Electron) {
3758 
3759  if (iLayer == 0) {
3760 
3761  const int ieta = m_psElectronEtaBins->FindFixBin(aeta) - 1;
3762  if (ieta >= 0 and ieta < m_psElectronGraphs->GetSize()) {
3763  value = ((TF1*)m_psElectronGraphs->At(ieta))->Eval(ET);
3764  }
3765  } else if (iLayer == 1) {
3766 
3767  const int ieta = m_s12ElectronEtaBins->FindFixBin(aeta) - 1;
3768  if (ieta >= 0 and ieta < m_s12ElectronGraphs->GetSize()) {
3769  value = ((TF1*)m_s12ElectronGraphs->At(ieta))->Eval(ET);
3770  }
3771  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3772 
3773  const int ieta = m_EaccElectronEtaBins->FindFixBin(aeta) - 1;
3774  if (ieta >= 0 && ieta < m_EaccElectronGraphs->GetSize()) {
3775  value = ((TF1*)m_EaccElectronGraphs->At(ieta))->Eval(ET);
3776  }
3777  }
3778 
3779  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3780 
3781  if (iLayer == 0) {
3782 
3783  const int ieta = m_psUnconvertedEtaBins->FindFixBin(aeta) - 1;
3784  if (ieta >= 0 and ieta < m_psUnconvertedGraphs->GetSize()) {
3785  value = ((TF1*)m_psUnconvertedGraphs->At(ieta))->Eval(ET);
3786  }
3787 
3788  } else if (iLayer == 1) {
3789 
3790  const int ieta = m_s12UnconvertedEtaBins->FindFixBin(aeta) - 1;
3791  if (ieta >= 0 and ieta < m_s12UnconvertedGraphs->GetSize()) {
3792  value = ((TF1*)m_s12UnconvertedGraphs->At(ieta))->Eval(ET);
3793  }
3794  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3795 
3796  const int ieta = m_EaccUnconvertedEtaBins->FindFixBin(aeta) - 1;
3797  if (ieta >= 0 && ieta < m_EaccUnconvertedGraphs->GetSize()) {
3798  value = ((TF1*)m_EaccUnconvertedGraphs->At(ieta))->Eval(ET);
3799  }
3800  }
3801 
3802  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3803 
3804  if (iLayer == 0) {
3805 
3806  const int ieta = m_psConvertedEtaBins->FindFixBin(aeta) - 1;
3807  if (ieta >= 0 and ieta < m_psConvertedGraphs->GetSize()) {
3808  value = ((TF1*)m_psConvertedGraphs->At(ieta))->Eval(ET);
3809  }
3810 
3811  } else if (iLayer == 1) {
3812 
3813  const int ieta = m_s12ConvertedEtaBins->FindFixBin(aeta) - 1;
3814  if (ieta >= 0 and ieta < m_s12ConvertedGraphs->GetSize()) {
3815  value = ((TF1*)m_s12ConvertedGraphs->At(ieta))->Eval(ET);
3816  }
3817  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3818 
3819  const int ieta = m_EaccConvertedEtaBins->FindFixBin(aeta) - 1;
3820  if (ieta >= 0 && ieta < m_EaccConvertedGraphs->GetSize()) {
3821  if (ET < 10000. && (aeta < 1.2 || (aeta >= 1.59 && aeta < 1.73))) {
3822  // harcoded condition to correct bad beahviour of function at low ET
3823  // <10GeV
3824  value = ((TF1*)m_EaccConvertedGraphs->At(ieta))->Eval(10000.);
3825  } else {
3826  value = ((TF1*)m_EaccConvertedGraphs->At(ieta))->Eval(ET);
3827  }
3828  }
3829  }
3830  }
3831 
3832  ATH_MSG_DEBUG("Layer non-linearity: " << iLayer << " value: " << value);
3833 
3834  if (value < 0) {
3835  ATH_MSG_DEBUG("Value is negative -> set to 0");
3836  value = 0;
3837  }
3838 
3839  return value;
3840 }

◆ getLayerPedestal()

double AtlasRoot::egammaEnergyCorrectionTool::getLayerPedestal ( double  cl_eta,
PATCore::ParticleType::Type  ptype,
int  iLayer,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 4579 of file egammaEnergyCorrectionTool.cxx.

4581  {
4582 
4583  double pedestal = 0.;
4584  double aeta = std::abs(cl_eta);
4585 
4586  if (var == egEnergyCorr::Scale::PedestalUp ||
4587  var == egEnergyCorr::Scale::PedestalDown) {
4588 
4589  if (iLayer == 0)
4590  pedestal = m_pedestalL0->GetBinContent(m_pedestalL0->FindFixBin(aeta));
4591  else if (iLayer == 1)
4592  pedestal = m_pedestalL1->GetBinContent(m_pedestalL1->FindFixBin(aeta));
4593  else if (iLayer == 2)
4594  pedestal = m_pedestalL2->GetBinContent(m_pedestalL2->FindFixBin(aeta));
4595  else if (iLayer == 3)
4596  pedestal = m_pedestalL3->GetBinContent(m_pedestalL3->FindFixBin(aeta));
4597 
4598  if (ptype == PATCore::ParticleType::UnconvertedPhoton && aeta < 1.4) {
4599  if (iLayer <= 1)
4600  pedestal /= 1.5;
4601  else if (iLayer == 2)
4602  pedestal *= 15. / 21.;
4603  }
4604 
4605  if (var == egEnergyCorr::Scale::PedestalDown)
4606  pedestal *= -1.;
4607  }
4608 
4609  return pedestal * varSF;
4610 }

◆ getLayerUncertainty()

double AtlasRoot::egammaEnergyCorrectionTool::getLayerUncertainty ( int  iLayer,
double  cl_eta,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 3572 of file egammaEnergyCorrectionTool.cxx.

3574  {
3575 
3576  double value = 0.;
3577 
3578  if (var == egEnergyCorr::Scale::Nominal)
3579  return value;
3580 
3581  // nearest eta outside of crack (for PS scale values and uncertainties)
3582  double nearestEta = cl_eta;
3583  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
3584  nearestEta = nearestEtaBEC(cl_eta);
3585 
3586  if (iLayer == 0) { // use nearestEta
3587 
3588  if (var == egEnergyCorr::Scale::PSUp && m_aPSNom)
3589  value = m_aPSNom->GetBinError(m_aPSNom->FindFixBin(nearestEta));
3590 
3591  else if (var == egEnergyCorr::Scale::PSDown && m_aPSNom)
3592  value = -m_aPSNom->GetBinError(m_aPSNom->FindFixBin(nearestEta));
3593 
3594  else if (var == egEnergyCorr::Scale::PSb12Up && m_daPSb12)
3595  value = m_daPSb12->GetBinContent(m_daPSb12->FindFixBin(nearestEta));
3596 
3597  else if (var == egEnergyCorr::Scale::PSb12Down && m_daPSb12)
3598  value = -m_daPSb12->GetBinContent(m_daPSb12->FindFixBin(nearestEta));
3599 
3600  else if (var == egEnergyCorr::Scale::LArElecUnconvUp && m_daPSCor)
3601  value = m_daPSCor->GetBinContent(m_daPSCor->FindFixBin(nearestEta));
3602 
3603  else if (var == egEnergyCorr::Scale::LArElecUnconvDown && m_daPSCor)
3604  value = -m_daPSCor->GetBinContent(m_daPSCor->FindFixBin(nearestEta));
3605 
3606  }
3607 
3608  else if (iLayer == 1) { // use cl_eta
3609 
3610  if (var == egEnergyCorr::Scale::S12Up && m_aS12Nom) {
3611  value = m_aS12Nom->GetBinError(m_aS12Nom->FindFixBin(cl_eta));
3612  } else if (var == egEnergyCorr::Scale::S12Down && m_aS12Nom) {
3613  value = -m_aS12Nom->GetBinError(m_aS12Nom->FindFixBin(cl_eta));
3614  } else if (var == egEnergyCorr::Scale::LArCalibUp && m_daS12Cor) {
3615  value = m_daS12Cor->GetBinContent(m_daS12Cor->FindFixBin(cl_eta));
3616  } else if (var == egEnergyCorr::Scale::LArCalibDown && m_daS12Cor) {
3617  value = -m_daS12Cor->GetBinContent(m_daS12Cor->FindFixBin(cl_eta));
3618  } else if (var == egEnergyCorr::Scale::LArCalibExtra2015PreUp and
3619  (m_esmodel == egEnergyCorr::es2015PRE or
3620  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3621  m_esmodel == egEnergyCorr::es2015cPRE or
3622  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3623  m_esmodel == egEnergyCorr::es2015c_summer or
3624  m_esmodel == egEnergyCorr::es2016PRE or
3625  m_esmodel == egEnergyCorr::es2017 or
3626  m_esmodel == egEnergyCorr::es2017_summer or
3627  m_esmodel == egEnergyCorr::es2017_summer_improved or
3628  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3629  m_esmodel == egEnergyCorr::es2015_5TeV)) {
3630  // special case for es2015PRE and also for es2015c_summer and also for
3631  // es2017 numbers from Lydia and Christophe,
3632  // https://indico.cern.ch/event/395345/contribution/2/material/slides/0.pdf
3633  // assuming constant uncertainty
3634  // es2017_summer: increased to 5% in the endcap
3635  const double aeta = std::abs(cl_eta);
3636  // endcap
3637  if (aeta >= 1.37 and aeta < 2.5) {
3638  if (m_esmodel == egEnergyCorr::es2017_summer or
3639  m_esmodel == egEnergyCorr::es2017_summer_improved or
3640  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3641  m_esmodel == egEnergyCorr::es2015_5TeV)
3642  value = 5.0E-2;
3643  else
3644  value = 1.5E-2;
3645  } else { // barrel
3646  if (m_esmodel == egEnergyCorr::es2017_summer_improved)
3647  value = 2.5E-2;
3648  else
3649  value = 1.5E-2;
3650  }
3651  } else if (var == egEnergyCorr::Scale::LArCalibExtra2015PreDown and
3652  (m_esmodel == egEnergyCorr::es2015PRE or
3653  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3654  m_esmodel == egEnergyCorr::es2015cPRE or
3655  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3656  m_esmodel == egEnergyCorr::es2015c_summer or
3657  m_esmodel == egEnergyCorr::es2016PRE or
3658  m_esmodel == egEnergyCorr::es2017 or
3659  m_esmodel == egEnergyCorr::es2017_summer or
3660  m_esmodel == egEnergyCorr::es2017_summer_improved or
3661  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3662  m_esmodel == egEnergyCorr::es2015_5TeV)) {
3663  const double aeta = std::abs(cl_eta);
3664  // endcap
3665  if (aeta >= 1.37 and aeta < 2.5) {
3666  if (m_esmodel == egEnergyCorr::es2017_summer or
3667  m_esmodel == egEnergyCorr::es2017_summer_improved or
3668  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3669  m_esmodel == egEnergyCorr::es2015_5TeV)
3670  value = -5.0E-2;
3671  else
3672  value = -1.5E-2;
3673  } else { // barrel
3674  if (m_esmodel == egEnergyCorr::es2017_summer_improved or
3675  m_esmodel == egEnergyCorr::es2015_5TeV)
3676  value = -2.5E-2;
3677  else
3678  value = -1.5E-2;
3679  }
3680  }
3681 
3682  else if (var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up or
3683  var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down) {
3684  // special large sys for run2 in the last eta-bin in es2017, see
3685  // ATLASEG-42
3686  if (m_esmodel == egEnergyCorr::es2017 or
3687  m_esmodel == egEnergyCorr::es2017_summer or
3688  m_esmodel == egEnergyCorr::es2017_summer_improved or
3689  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3690  m_esmodel == egEnergyCorr::es2015_5TeV) {
3691  const double aeta = std::abs(cl_eta);
3692  if (aeta >= 2.4 and aeta < 2.5) {
3693  if (var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up)
3694  value = 25E-2;
3695  else
3696  value = -25E-2;
3697  }
3698  }
3699  }
3700  }
3701 
3702  return value * varSF;
3703 }

◆ getMaterialEffect()

double AtlasRoot::egammaEnergyCorrectionTool::getMaterialEffect ( egEnergyCorr::Geometry  geo,
PATCore::ParticleType::Type  ptype,
double  cl_eta,
double  ET 
) const
private

Definition at line 4045 of file egammaEnergyCorrectionTool.cxx.

4047  {
4048 
4049  // Again this does no need to be ptr just get the one owned
4050  TH2D* hmat;
4051 
4052  if (ptype == PATCore::ParticleType::Electron) {
4053  if (geo == egEnergyCorr::ConfigA)
4054  hmat = ((TH2D*)m_electronBias_ConfigA.get());
4055  else if (geo == egEnergyCorr::ConfigEL)
4056  hmat = ((TH2D*)m_electronBias_ConfigEpLp.get());
4057  else if (geo == egEnergyCorr::ConfigFMX)
4058  hmat = ((TH2D*)m_electronBias_ConfigFpMX.get());
4059  else if (geo == egEnergyCorr::ConfigN)
4060  hmat = ((TH2D*)m_electronBias_ConfigN.get());
4061  else if (geo == egEnergyCorr::ConfigIBL)
4062  hmat = ((TH2D*)m_electronBias_ConfigIBL.get());
4063  else if (geo == egEnergyCorr::ConfigPP0)
4064  hmat = ((TH2D*)m_electronBias_ConfigPP0.get());
4065  else
4066  return 0;
4067  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4068  if (geo == egEnergyCorr::ConfigA)
4069  hmat = ((TH2D*)m_unconvertedBias_ConfigA.get());
4070  else if (geo == egEnergyCorr::ConfigEL)
4071  hmat = ((TH2D*)m_unconvertedBias_ConfigEpLp.get());
4072  else if (geo == egEnergyCorr::ConfigFMX)
4073  hmat = ((TH2D*)m_unconvertedBias_ConfigFpMX.get());
4074  else if (geo == egEnergyCorr::ConfigN)
4075  hmat = ((TH2D*)m_unconvertedBias_ConfigN.get());
4076  else if (geo == egEnergyCorr::ConfigIBL)
4077  hmat = ((TH2D*)m_unconvertedBias_ConfigIBL.get());
4078  else if (geo == egEnergyCorr::ConfigPP0)
4079  hmat = ((TH2D*)m_unconvertedBias_ConfigIBL.get());
4080  else
4081  return 0;
4082  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4083  if (geo == egEnergyCorr::ConfigA)
4084  hmat = ((TH2D*)m_convertedBias_ConfigA.get());
4085  else if (geo == egEnergyCorr::ConfigEL)
4086  hmat = ((TH2D*)m_convertedBias_ConfigEpLp.get());
4087  else if (geo == egEnergyCorr::ConfigFMX)
4088  hmat = ((TH2D*)m_convertedBias_ConfigFpMX.get());
4089  else if (geo == egEnergyCorr::ConfigN)
4090  hmat = ((TH2D*)m_convertedBias_ConfigN.get());
4091  else if (geo == egEnergyCorr::ConfigIBL)
4092  hmat = ((TH2D*)m_convertedBias_ConfigIBL.get());
4093  else if (geo == egEnergyCorr::ConfigPP0)
4094  hmat = ((TH2D*)m_convertedBias_ConfigPP0.get());
4095  else
4096  return 0;
4097  } else
4098  return 0;
4099 
4100  // use one bin in eta and linear interpolation in Et between 2 bins
4101 
4102  double aeta = std::abs(cl_eta);
4103  int ieta = hmat->GetXaxis()->FindBin(aeta);
4104 
4105  int ipt = hmat->GetYaxis()->FindBin(ET);
4106  double ptBin = hmat->GetYaxis()->GetBinCenter(ipt);
4107 
4108  int i1, i2;
4109  double pt1, pt2;
4110  if (ET > ptBin) {
4111  i1 = ipt;
4112  i2 = ipt + 1;
4113  pt1 = ptBin;
4114  pt2 = hmat->GetYaxis()->GetBinCenter(i2);
4115  } else {
4116  i1 = ipt - 1;
4117  i2 = ipt;
4118  pt1 = hmat->GetYaxis()->GetBinCenter(i1);
4119  pt2 = ptBin;
4120  }
4121 
4122  int nbins = hmat->GetYaxis()->GetNbins();
4123  double value = 0;
4124  if (i1 >= 1 && i1 < nbins) {
4125  double v1 = hmat->GetBinContent(ieta, i1);
4126  double v2 = hmat->GetBinContent(ieta, i2);
4127  value = (v1 * (pt2 - ET) + v2 * (ET - pt1)) / (pt2 - pt1);
4128  } else {
4129  if (ipt < 1)
4130  ipt = 1;
4131  if (ipt > nbins)
4132  ipt = nbins;
4133  value = hmat->GetBinContent(ieta, ipt);
4134  }
4135  return value;
4136 }

◆ getMaterialNonLinearity()

double AtlasRoot::egammaEnergyCorrectionTool::getMaterialNonLinearity ( double  cl_eta,
double  energy,
egEnergyCorr::MaterialCategory  imat,
PATCore::ParticleType::Type  ptype,
egEnergyCorr::Scale::Variation  var = egEnergyCorr::Scale::Nominal,
double  varSF = 1. 
) const
private

Definition at line 4140 of file egammaEnergyCorrectionTool.cxx.

4143  {
4144 
4145  double value = 0;
4146  double ET = energy / cosh(cl_eta) / GeV;
4147 
4148  if ((ptype != PATCore::ParticleType::Electron &&
4149  (m_esmodel != egEnergyCorr::es2017_R21_v1 &&
4150  m_esmodel != egEnergyCorr::es2017_R21_ofc0_v1 &&
4151  m_esmodel != egEnergyCorr::es2024_Run3_ofc0_v0 &&
4152  m_esmodel != egEnergyCorr::es2018_R21_v0 &&
4153  m_esmodel != egEnergyCorr::es2018_R21_v1 &&
4154  m_esmodel != egEnergyCorr::es2022_R22_PRE &&
4155  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)) ||
4156  var == egEnergyCorr::Scale::Nominal)
4157  return value;
4158 
4159  egEnergyCorr::Geometry geoID, geoCryo, geoCalo, geoGp;
4160  geoID = egEnergyCorr::ConfigA;
4161  if (std::abs(cl_eta) < 2.)
4162  geoCryo = egEnergyCorr::ConfigEL;
4163  else
4164  geoCryo = egEnergyCorr::ConfigFMX;
4165 
4166  // G.Unal 21.08.2018
4167  // for Calo material use correctly ConfigN material for endcap (PS to Calo) in
4168  // release 21 (not done for run 1, which used FMX in this case)
4169  if (std::abs(cl_eta) > 1.52 &&
4170  (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4171  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4172  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
4173  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4174  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4175  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4176  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0))
4177  geoCalo = egEnergyCorr::ConfigN;
4178  else
4179  geoCalo = egEnergyCorr::ConfigFMX;
4180  geoGp = egEnergyCorr::ConfigGp;
4181 
4182  // look up material bias
4183 
4184  double DeltaX = getDeltaX(cl_eta, imat, var) -
4185  getDeltaX(cl_eta, imat, egEnergyCorr::Scale::Nominal);
4186 
4187  // calculate scale change per unit added material
4188 
4189  // G.Unal 21.08.2019 new code called for release 21 sensivitities
4190 
4191  double DAlphaDXGp, DAlphaDXID, DAlphaDXCryo, DAlphaDXCalo;
4192 
4193  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4194  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4195  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
4196  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4197  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4198  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4199  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4200  DAlphaDXGp =
4201  getMaterialEffect(egEnergyCorr::ConfigFMX, ptype, cl_eta,
4202  ET); // no G' in release 21, use FMX for the crack
4203  DAlphaDXID = getMaterialEffect(geoID, ptype, cl_eta, ET);
4204  DAlphaDXCryo = getMaterialEffect(geoCryo, ptype, cl_eta, ET);
4205  DAlphaDXCalo = getMaterialEffect(geoCalo, ptype, cl_eta, ET);
4206 
4207  } else {
4208  int ialpha = m_matElectronEtaBins->FindFixBin(std::abs(cl_eta)) - 1;
4209  if (ialpha < 0 || ialpha >= m_matElectronGraphs[geoGp]->GetSize())
4210  return 0.;
4211 
4212  DAlphaDXGp = ((TGraphErrors*)m_matElectronGraphs[geoGp]->At(ialpha))
4213  ->GetFunction("fNonLin")
4214  ->Eval(ET);
4215  DAlphaDXID = ((TGraphErrors*)m_matElectronGraphs[geoID]->At(ialpha))
4216  ->GetFunction("fNonLin")
4217  ->Eval(ET);
4218  DAlphaDXCryo = ((TGraphErrors*)m_matElectronGraphs[geoCryo]->At(ialpha))
4219  ->GetFunction("fNonLin")
4220  ->Eval(ET);
4221  DAlphaDXCalo = ((TGraphErrors*)m_matElectronGraphs[geoCalo]->At(ialpha))
4222  ->GetFunction("fNonLin")
4223  ->Eval(ET);
4224  }
4225 
4226  // when in crack, use G', exit
4227 
4228  if (isInCrack(cl_eta)) {
4229  if (imat == egEnergyCorr::MatID && var == egEnergyCorr::Scale::MatIDUp)
4230  value = DAlphaDXGp;
4231  else if (imat == egEnergyCorr::MatID &&
4232  var == egEnergyCorr::Scale::MatIDDown)
4233  value = -DAlphaDXGp;
4234  return value;
4235  }
4236 
4237  int idx = m_matX0Additions[geoID]->FindBin(std::abs(cl_eta));
4238  if (idx < 1 || idx > m_matX0Additions[geoID]->GetNbinsX())
4239  DAlphaDXID = 0;
4240  else {
4241  if (m_matX0Additions[geoID]->GetBinContent(idx) > 0.)
4242  DAlphaDXID /= m_matX0Additions[geoID]->GetBinContent(idx);
4243  else
4244  DAlphaDXID = 0.;
4245  }
4246 
4247  idx = m_matX0Additions[geoCryo]->FindBin(std::abs(cl_eta));
4248  if (idx < 1 || idx > m_matX0Additions[geoCryo]->GetNbinsX())
4249  DAlphaDXCryo = 0;
4250  else {
4251  if (m_matX0Additions[geoCryo]->GetBinContent(idx) > 0.)
4252  DAlphaDXCryo /= m_matX0Additions[geoCryo]->GetBinContent(idx);
4253  else
4254  DAlphaDXCryo = 0.;
4255  }
4256 
4257  idx = m_matX0Additions[geoCalo]->FindBin(std::abs(cl_eta));
4258  if (idx < 1 || idx > m_matX0Additions[geoCalo]->GetNbinsX())
4259  DAlphaDXCalo = 0;
4260  else {
4261  if (m_matX0Additions[geoCalo]->GetBinContent(idx) > 0.)
4262  DAlphaDXCalo /= m_matX0Additions[geoCalo]->GetBinContent(idx);
4263  else
4264  DAlphaDXCalo = 0.;
4265  }
4266 
4267  // final value
4268 
4269  if (imat == egEnergyCorr::MatID)
4270  value = DeltaX * (DAlphaDXID - DAlphaDXCryo);
4271  else if (imat == egEnergyCorr::MatCryo)
4272  value = DeltaX * DAlphaDXCryo;
4273  else if (imat == egEnergyCorr::MatCalo)
4274  value = DeltaX * DAlphaDXCalo;
4275 
4276  return value * varSF;
4277 }

◆ getResolution_systematics()

void AtlasRoot::egammaEnergyCorrectionTool::getResolution_systematics ( int  particle_type,
double  energy,
double  eta,
double  etaCalo,
int  syst_mask,
double &  resolution,
double &  resolution_error,
double &  resolution_error_up,
double &  resolution_error_down,
int  resol_type = 0,
bool  fast = false 
) const
private

get resolution and its uncertainty)

particle type : 0=electron, 1=reco unconverted photon, 2=reco converted photon

energy = Energy in MeV

eta

syst_mask bit mask of systematics to consider (0x1 = smearing uncertainty, 0x2= intrisinc resolution uncertainty, 0x4 = ID material, 0x8 = PS-layer1 material, 0x10 = Material in barrel-endcap gap, 0x20 = Material in "cryo area", 0x40 = Pileup noise uncertainty)

Output : resolution = energy resolution in MeV

Output : resolution_error = uncertainty on energy resolution in MeV from the systematics included according to bit mask

resolution_type 0=gaussian core, 1= sigma eff 80%, 2 = sigma eff 90%

Definition at line 4675 of file egammaEnergyCorrectionTool.cxx.

4678  {
4679 
4680  double pileupNoise = pileUpTerm(energy, eta, particle_type);
4681  double et = energy / cosh(eta);
4682 
4683  resolution =
4684  m_resolution_tool->getResolution(particle_type, energy, eta, resol_type);
4685  // std::cout << " resolution from tool " << resolution << std::endl;
4686  double smearingZ = dataConstantTerm(m_use_etaCalo_scales ? etaCalo : eta);
4687  double esmearingZ =
4688  dataConstantTermError(m_use_etaCalo_scales ? etaCalo : eta);
4689  double esmearingOFC = m_esmodel == egEnergyCorr::es2022_R22_PRE
4690  ? dataConstantTermOFCError(eta)
4691  : 0.;
4692  double resolution2 = resolution * resolution + smearingZ * smearingZ +
4693  (pileupNoise * pileupNoise) / (et * et);
4694  resolution = sqrt(resolution2);
4695 
4696  double_t sum_sigma_resolution2 = 0.;
4697  double sum_deltaDown = 0.;
4698  double sum_deltaUp = 0.;
4699 
4700  for (int isys = 0; isys < 11; isys++) {
4701 
4702  if (syst_mask & (1 << isys)) {
4703 
4704  double sigma2 = 0.;
4705  double sigma2up = 0.;
4706  double sigma2down = 0.;
4707 
4708  // systematics on Z smearing measurement
4709  if (isys == 0) {
4710  double d1 = (smearingZ + esmearingZ) * (smearingZ + esmearingZ) -
4711  smearingZ * smearingZ;
4712  double d2 = smearingZ * smearingZ -
4713  (smearingZ - esmearingZ) * (smearingZ - esmearingZ);
4714  double d = 0.5 * (d1 + d2);
4715  sigma2up = d1;
4716  sigma2down = -d2;
4717  sigma2 = d;
4718  ATH_MSG_DEBUG(
4719  std::format("sys resolution Zsmearing: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4720  }
4721 
4722  // systematics on intrinsic resolution
4723  if (isys == 1) {
4724  double resolutionZ = m_resolution_tool->getResolution(
4725  3, 40000. * cosh(eta), eta, resol_type);
4726  double deltaSigma2 = (1.1 * resolutionZ) * (1.1 * resolutionZ) -
4727  resolutionZ * resolutionZ;
4728  double resolution1 =
4729  m_resolution_tool->getResolution(3, energy, eta, resol_type);
4730  sigma2up = (1.1 * resolution1) * (1.1 * resolution1) -
4731  resolution1 * resolution1 - deltaSigma2;
4732  deltaSigma2 = (0.9 * resolutionZ) * (0.9 * resolutionZ) -
4733  resolutionZ * resolutionZ;
4734  sigma2down = (0.9 * resolution1) * (0.9 * resolution1) -
4735  resolution1 * resolution1 - deltaSigma2;
4736  sigma2 = 0.5 * (sigma2up - sigma2down);
4737  ATH_MSG_DEBUG(
4738  std::format("sys resolution intrinsic: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4739  }
4740 
4741  // systematics from configA ID material
4742  else if (isys == 2) {
4743  double sigmaA =
4744  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 0);
4745  sigma2 = sigmaA * sigmaA;
4746  sigma2up = sigma2;
4747  sigma2down = -1. * sigma2;
4748  ATH_MSG_DEBUG(
4749  std::format("sys resolution configA ID material: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4750  }
4751 
4752  // systematics from material presampler-layer 1 in barrel (based on half
4753  // config M )
4754  else if (isys == 3) {
4755  if (std::abs(eta) < 1.45) {
4756  double sigmaM =
4757  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 3);
4758  sigma2 = 0.5 * sigmaM * sigmaM;
4759  } else
4760  sigma2 = 0.;
4761  sigma2up = sigma2;
4762  sigma2down = -1. * sigma2;
4763  ATH_MSG_DEBUG(
4764  std::format("sys resolution presampler-layer1: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4765  }
4766 
4767  // systematic from material in barrel-endcap gap (using full config X for
4768  // now)
4769  else if (isys == 4) {
4770  if (std::abs(eta) > 1.52 && std::abs(eta) < 1.82) {
4771  double sigmaX =
4772  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 3);
4773  sigma2 = sigmaX * sigmaX;
4774  } else
4775  sigma2 = 0.;
4776  sigma2up = sigma2;
4777  sigma2down = -1. * sigma2;
4778  ATH_MSG_DEBUG(
4779  std::format("sys resolution barrel-endcap gap: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4780  }
4781 
4782  // systematics from material in cryostat area (using half config EL,
4783  // FIXME: could use clever eta dependent scaling)
4784  else if (isys == 5) {
4785  double sigmaEL =
4786  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 2);
4787  sigma2 = 0.5 * sigmaEL * sigmaEL;
4788  sigma2up = sigma2;
4789  sigma2down = -1. * sigma2;
4790  ATH_MSG_DEBUG(
4791  std::format("sys resolution cryostat area: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4792  }
4793 
4794  // systematics from pileup noise on total noise (200 MeV in quadrature,
4795  // somewhat conservative)
4796  else if (isys == 6) {
4797  double et = energy / cosh(eta);
4798  double sigmaPileUp = 0.;
4799  double sigmaZ = 0.;
4800  // release 21 - 10% uncertainty on pileup noise
4801  if (m_esmodel == egEnergyCorr::es2017_R21_v0 or
4802  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4803  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4804  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4805  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4806  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4807  double deltaNoise =
4808  sqrt(1.1 * 1.1 - 1.0) *
4809  pileupNoise; // uncertainty in quadrature 1.1*noise - noise
4810  sigmaPileUp = deltaNoise / et; // sigmaE/E impact
4811  sigmaZ = deltaNoise / 40000.; // sigmaE/E for Z->ee electrons
4812  // (absorbed in smearing correction)
4813  }
4814  // no pileup noise uncertainty for es2017_R21_ofc0_v1 and egEnergyCorr::es2024_Run3_ofc0_v0
4815  else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 || m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0) {
4816  sigmaPileUp = 0.;
4817  sigmaZ = 0.;
4818  } else {
4819  // older models
4820  double deltaPileupNoise = 100.; // MeV
4821  if (std::abs(eta) >= 1.4 && std::abs(eta) < 1.8)
4822  deltaPileupNoise = 200.; // larger systematic in this eta bin
4823  double scaleNcells = 1;
4824  if (particle_type == 1 && std::abs(eta) < 1.4)
4825  scaleNcells = sqrt(3. / 5.); // cluster=3X5 instead of 3x7, rms
4826  // scales with cluster area
4827  sigmaPileUp = deltaPileupNoise * scaleNcells / et;
4828  sigmaZ =
4829  deltaPileupNoise / (40000.); // effect for Z->ee at Et=40 GeV
4830  }
4831  sigma2 = sigmaPileUp * sigmaPileUp - sigmaZ * sigmaZ;
4832  sigma2up = sigma2;
4833  sigma2down = -1. * sigma2;
4834  ATH_MSG_DEBUG(std::format("sys resolution pileup noise: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4835  }
4836 
4837  // systematics from material in IBL+PP0 for barrel
4838  else if (isys == 7 && std::abs(eta) < 1.5 &&
4839  (m_esmodel == egEnergyCorr::es2017 or
4840  m_esmodel == egEnergyCorr::es2017_summer or
4841  m_esmodel == egEnergyCorr::es2017_summer_improved or
4842  m_esmodel == egEnergyCorr::es2017_summer_final or
4843  m_esmodel == egEnergyCorr::es2015_5TeV or
4844  m_esmodel == egEnergyCorr::es2017_R21_v0 or
4845  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4846  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4847  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
4848  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4849  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4850  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4851  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
4852  double sigmaE =
4853  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 5);
4854  sigma2 = sigmaE * sigmaE;
4855  sigma2up = sigma2;
4856  sigma2down = -1. * sigma2;
4857  ATH_MSG_DEBUG(
4858  std::format("sys resolution ibl material: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4859  }
4860 
4861  // systematics from material in IBL+PP0 for end-cap
4862  else if (isys == 8 && std::abs(eta) > 1.5 &&
4863  (m_esmodel == egEnergyCorr::es2017 or
4864  m_esmodel == egEnergyCorr::es2017_summer or
4865  m_esmodel == egEnergyCorr::es2017_summer_improved or
4866  m_esmodel == egEnergyCorr::es2017_summer_final or
4867  m_esmodel == egEnergyCorr::es2015_5TeV or
4868  m_esmodel == egEnergyCorr::es2017_R21_v0 or
4869  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4870  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4871  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
4872  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4873  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4874  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4875  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
4876  double sigmaE =
4877  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 5);
4878  // scale factor 2.3 in X0 => sqrt(2) in resolution or 2 in resolution**2
4879  sigma2 = 2.3 * sigmaE * sigmaE;
4880  sigma2up = sigma2;
4881  sigma2down = -1. * sigma2;
4882  ATH_MSG_DEBUG(
4883  std::format("sys resolution pp0 material: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4884 
4885  }
4886 
4887  // AF2 resolution systematics for es2017_R21_v1 model (neglected before
4888  // that...)
4889  else if (isys == 9 &&
4890  (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4891  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4892  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
4893  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4894  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4895  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4896  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
4897  fast) {
4898  const double ptGeV = et / 1e3;
4899  if (particle_type == 0)
4900  sigma2 = getValueHistAt(*m_G4OverAFII_resolution_electron, eta, ptGeV,
4901  true, true, true, true);
4902  if (particle_type == 1)
4903  sigma2 = getValueHistAt(*m_G4OverAFII_resolution_unconverted, eta,
4904  ptGeV, true, true, true, true);
4905  if (particle_type == 2)
4906  sigma2 = getValueHistAt(*m_G4OverAFII_resolution_converted, eta,
4907  ptGeV, true, true, true, true);
4908  sigma2up = -1. * sigma2; // AF2 resolution worse than full Sim,
4909  // sigma2up gives back AF2 resolution
4910  sigma2down = sigma2;
4911  }
4912 
4913  // OFC resolution systematics for for es2022_RUN3_PRE
4914  else if (isys == 10 && (m_esmodel == egEnergyCorr::es2022_R22_PRE)) {
4915  double d1 = (smearingZ + esmearingOFC) * (smearingZ + esmearingOFC) -
4916  smearingZ * smearingZ;
4917  double d2 = smearingZ * smearingZ -
4918  (smearingZ - esmearingOFC) * (smearingZ - esmearingOFC);
4919  double d = 0.5 * (d1 + d2);
4920  sigma2up = d1;
4921  sigma2down = -d2;
4922  sigma2 = d;
4923  ATH_MSG_DEBUG(std::format("sys resolution OFC unc.: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4924  }
4925 
4926  // old method to use max of up and down for All
4927  /*
4928  double rr1 = sqrt(resolution2+sigma2); // nominal (data) +
4929  average error double rr2=0.; if((resolution2-sigma2) > 0.) rr2 =
4930  sqrt(resolution2-sigma2); // max(0, nominal (data) - average error)
4931  double deltaSigma_sys;
4932  if ((rr1-resolution) > (resolution-rr2) ) deltaSigma_sys =
4933  rr1-resolution; else deltaSigma_sys = resolution-rr2; deltaSigma_sys =
4934  deltaSigma_sys / resolution;
4935  */
4936 
4937  // use average of up and down for symmetric uncertainty for All
4938 
4939  double rr1 = 0.;
4940  if ((resolution2 + sigma2up) > 0.)
4941  rr1 = sqrt(resolution2 + sigma2up); // nominal (data) + up error
4942  double rr2 = 0.;
4943  if ((resolution2 + sigma2down) > 0.)
4944  rr2 = sqrt(resolution2 +
4945  sigma2down); // max(0, nominal (data) + down error
4946  double deltaSigma_sys;
4947  deltaSigma_sys =
4948  0.5 * (rr1 - rr2); // average of up and down uncertainties
4949  deltaSigma_sys =
4950  deltaSigma_sys / resolution; // relative resolution uncertainty
4951 
4952  sum_sigma_resolution2 += deltaSigma_sys * deltaSigma_sys;
4953 
4954  if ((resolution2 + sigma2up) > 0.)
4955  rr1 = sqrt(resolution2 + sigma2up);
4956  else
4957  rr1 = 0.;
4958  double deltaSigmaUp = (rr1 - resolution) / resolution;
4959  ATH_MSG_VERBOSE("relative resolution change Up " << deltaSigmaUp);
4960 
4961  if ((resolution2 + sigma2down) > 0.)
4962  rr2 = sqrt(resolution2 + sigma2down);
4963  else
4964  rr2 = 0.;
4965  double deltaSigmaDown = (rr2 - resolution) / resolution;
4966  ATH_MSG_VERBOSE("relative resolution change Down " << deltaSigmaDown);
4967 
4968  sum_deltaUp += deltaSigmaUp;
4969  sum_deltaDown += deltaSigmaDown;
4970  }
4971  }
4972 
4973  resolution = resolution * energy; // to return final resolution in MeV
4974  resolution_error = sqrt(sum_sigma_resolution2) *
4975  resolution; // to return resolution uncertainty in MeV
4976 
4977  resolution_error_up = sum_deltaUp * resolution;
4978  resolution_error_down = sum_deltaDown * resolution;
4979 
4980  ATH_MSG_VERBOSE("Resolution (MeV): "
4981  << resolution
4982  << " Resolution Error (MeV): " << resolution_error << " down "
4983  << resolution_error_down << " up " << resolution_error_up
4984  << " Z smearing " << smearingZ << " +- " << esmearingZ
4985  << " using mask " << syst_mask);
4986 }

◆ getResolutionError()

double AtlasRoot::egammaEnergyCorrectionTool::getResolutionError ( PATCore::ParticleDataType::DataType  dataType,
double  energy,
double  eta,
double  etaCalo,
PATCore::ParticleType::Type  ptype,
egEnergyCorr::Resolution::Variation  value,
egEnergyCorr::Resolution::resolutionType  resType = egEnergyCorr::Resolution::SigmaEff90 
) const

Definition at line 2690 of file egammaEnergyCorrectionTool.cxx.

2696 {
2697 
2698  int eg_resolution_ptype;
2699  if (ptype == PATCore::ParticleType::Electron)
2700  eg_resolution_ptype = 0;
2701  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2702  eg_resolution_ptype = 1;
2703  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2704  eg_resolution_ptype = 2;
2705  else
2706  return -1;
2707 
2708  int isys = 0;
2709  if (value == egEnergyCorr::Resolution::AllUp ||
2710  value == egEnergyCorr::Resolution::AllDown) {
2711  isys = 0xFFFF;
2712  }
2713  if (value == egEnergyCorr::Resolution::ZSmearingUp ||
2714  value == egEnergyCorr::Resolution::ZSmearingDown) {
2715  isys = 0x1;
2716  }
2717  if (value == egEnergyCorr::Resolution::SamplingTermUp ||
2718  value == egEnergyCorr::Resolution::SamplingTermDown) {
2719  isys = 0x2;
2720  }
2721  if (value == egEnergyCorr::Resolution::MaterialIDUp ||
2722  value == egEnergyCorr::Resolution::MaterialIDDown) {
2723  isys = 0x4;
2724  }
2725  if (value == egEnergyCorr::Resolution::MaterialCaloUp ||
2726  value == egEnergyCorr::Resolution::MaterialCaloDown) {
2727  isys = 0x8;
2728  }
2729  if (value == egEnergyCorr::Resolution::MaterialGapUp ||
2730  value == egEnergyCorr::Resolution::MaterialGapDown) {
2731  isys = 0x10;
2732  }
2733  if (value == egEnergyCorr::Resolution::MaterialCryoUp ||
2734  value == egEnergyCorr::Resolution::MaterialCryoDown) {
2735  isys = 0x20;
2736  }
2737  if (value == egEnergyCorr::Resolution::PileUpUp ||
2738  value == egEnergyCorr::Resolution::PileUpDown) {
2739  isys = 0x40;
2740  }
2741 
2742  if (value == egEnergyCorr::Resolution::MaterialIBLUp ||
2743  value == egEnergyCorr::Resolution::MaterialIBLDown) {
2744  isys = 0x80;
2745  }
2746  if (value == egEnergyCorr::Resolution::MaterialPP0Up ||
2747  value == egEnergyCorr::Resolution::MaterialPP0Down) {
2748  isys = 0x100;
2749  }
2750  if (value == egEnergyCorr::Resolution::af2Up ||
2751  value == egEnergyCorr::Resolution::af2Down) {
2752  isys = 0x200;
2753  }
2754  if (value == egEnergyCorr::Resolution::OFCUp ||
2755  value == egEnergyCorr::Resolution::OFCDown) {
2756  isys = 0x400;
2757  }
2758 
2759  double sign = 1.;
2760  if (value == egEnergyCorr::Resolution::AllDown ||
2761  value == egEnergyCorr::Resolution::ZSmearingDown ||
2762  value == egEnergyCorr::Resolution::SamplingTermDown ||
2763  value == egEnergyCorr::Resolution::MaterialIDDown ||
2764  value == egEnergyCorr::Resolution::MaterialGapDown ||
2765  value == egEnergyCorr::Resolution::MaterialCaloDown ||
2766  value == egEnergyCorr::Resolution::MaterialCryoDown ||
2767  value == egEnergyCorr::Resolution::PileUpDown ||
2768  value == egEnergyCorr::Resolution::MaterialIBLDown ||
2769  value == egEnergyCorr::Resolution::MaterialPP0Down ||
2770  value == egEnergyCorr::Resolution::af2Down ||
2771  value == egEnergyCorr::Resolution::OFCDown)
2772  sign = -1.;
2773 
2774  double resolution;
2775  double resolution_error;
2776  double resolution_error_up;
2777  double resolution_error_down;
2778 
2779  getResolution_systematics(eg_resolution_ptype, energy, eta, etaCalo, isys,
2780  resolution, resolution_error, resolution_error_up,
2781  resolution_error_down, resType,
2782  dataType == PATCore::ParticleDataType::Fast);
2783 
2784  // total resolution uncertainty
2785  if (value == egEnergyCorr::Resolution::AllUp ||
2786  value == egEnergyCorr::Resolution::AllDown) {
2787  resolution_error = resolution_error / resolution * sign;
2788  } else {
2789  if (sign == 1)
2790  resolution_error = resolution_error_up / resolution;
2791  else
2792  resolution_error = resolution_error_down / resolution;
2793  }
2794 
2795  return resolution_error;
2796 }

◆ getSmearingCorrection()

double AtlasRoot::egammaEnergyCorrectionTool::getSmearingCorrection ( double  eta,
double  etaCalo,
double  energy,
RandomNumber  seed,
PATCore::ParticleType::Type  ptype = PATCore::ParticleType::Electron,
PATCore::ParticleDataType::DataType  dataType = PATCore::ParticleDataType::Full,
egEnergyCorr::Resolution::Variation  value = egEnergyCorr::Resolution::Nominal,
egEnergyCorr::Resolution::resolutionType  resType = egEnergyCorr::Resolution::SigmaEff90 
) const
private

smearing corrections

Definition at line 2971 of file egammaEnergyCorrectionTool.cxx.

2976  {
2977 
2978  if (dataType == PATCore::ParticleDataType::Data) {
2979  ATH_MSG_FATAL("Trying to compute smearing correction on data");
2980  }
2981 
2982  if (value == egEnergyCorr::Resolution::None || energy <= 0.)
2983  return 1.0;
2984 
2985  const double energyGeV = energy / GeV;
2986 
2987  // relative resolutions
2988  const double resMC =
2989  resolution(energy, cl_eta, cl_etaCalo, ptype, false, // no additional CT
2990  dataType == PATCore::ParticleDataType::Fast, resType);
2991  double resData =
2992  resolution(energy, cl_eta, cl_etaCalo, ptype, true, // with additional CT
2993  false, resType); // on top of Full simulation
2994 
2995  ATH_MSG_DEBUG("resolution in data: " << resData << " in MC: " << resMC);
2996 
2997  if (m_use_new_resolution_model) {
2998  resData *= 1 + getResolutionError(dataType, energy, cl_eta, cl_etaCalo,
2999  ptype, value, resType);
3000  } else { // OLD model
3001  double errUp, errDown;
3002  resolutionError(energyGeV, cl_eta, errUp, errDown);
3003  if (value == egEnergyCorr::Resolution::AllDown)
3004  resData += errDown;
3005  else if (value == egEnergyCorr::Resolution::AllUp)
3006  resData += errUp;
3007  else if (value != egEnergyCorr::Resolution::Nominal) {
3008  // std::cout << "getSmearingCorrection : wrong value, return 1" <<
3009  // std::endl;
3010  return 1.0;
3011  }
3012  }
3013 
3014  ATH_MSG_DEBUG("resolution in data after systematics: " << resData);
3015 
3016  const double sigma2 =
3017  std::pow(resData * energyGeV, 2) - std::pow(resMC * energyGeV, 2);
3018 
3019  // TODO: for nominal case it can be simplified to:
3020  // const double sigma = dataConstantTerm(m_use_etaCalo_scales ? cl_etaCalo :
3021  // cl_eta) * energyGeV; which is just the additional constant term
3022  if (sigma2 <= 0) {
3023  return 1;
3024  }
3025 
3026  const double sigma = sqrt(sigma2);
3027 
3028  TRandom3 rng(seed);
3029 
3030  const double DeltaE0 = rng.Gaus(0, sigma);
3031  const double cor0 = (energyGeV + DeltaE0) / energyGeV;
3032 
3033  ATH_MSG_DEBUG("sigma|DeltaE0|cor0|seed = " << sigma << "|" << DeltaE0 << "|"
3034  << cor0 << "|" << rng.GetSeed());
3035 
3036  return cor0; // TODO: why not returning DeltaE0 and apply E -> E + DeltaE0 ?
3037 }

◆ getWtots1Uncertainty()

double AtlasRoot::egammaEnergyCorrectionTool::getWtots1Uncertainty ( double  cl_eta,
double  energy,
PATCore::ParticleType::Type  ptype 
) const
private

Definition at line 3494 of file egammaEnergyCorrectionTool.cxx.

3495  {
3496  double value = 0;
3497 
3498  // Get slopes and wstot values
3499  // deltaE/E (Et, particle type ) = 2*A/mZ * ( wstot(Et,particle type)_data -
3500  // <wstot(40 GeV Et electrons)_data)> ) - 2*B/mZ* (wstot(Et,particle type)_MC
3501  // - <w wstot(40 GeV Et electrons)_MC>) factor 2 to go from slopes in dM/M to
3502  // dE/E
3503 
3504  //|eta|>2.4 => use last eta bin
3505  if (cl_eta < -2.4)
3506  cl_eta = -2.35;
3507  if (cl_eta > 2.4)
3508  cl_eta = 2.35;
3509 
3510  int bin = m_wstot_slope_A_data->FindFixBin(cl_eta);
3511  double A = m_wstot_slope_A_data->GetBinContent(bin);
3512  double B = m_wstot_slope_B_MC->GetBinContent(bin);
3513 
3514  // the wstot=f(pT) depends on the particle type
3515  double ETGeV = energy / cosh(cl_eta) / 1E3;
3516  double wstot_pT_data_p0 = 0.;
3517  double wstot_pT_data_p1 = 0.;
3518  double wstot_pT_MC_p0 = 0.;
3519  double wstot_pT_MC_p1 = 0.;
3520 
3521  double wstot_40_data =
3522  m_wstot_pT_data_p0_electrons->GetBinContent(bin) +
3523  (m_wstot_pT_data_p1_electrons->GetBinContent(bin)) / sqrt(40.);
3524  double wstot_40_MC =
3525  m_wstot_pT_MC_p0_electrons->GetBinContent(bin) +
3526  (m_wstot_pT_MC_p1_electrons->GetBinContent(bin)) / sqrt(40.);
3527 
3528  if (ptype == PATCore::ParticleType::Electron) {
3529  wstot_pT_data_p0 = m_wstot_pT_data_p0_electrons->GetBinContent(bin);
3530  wstot_pT_data_p1 = m_wstot_pT_data_p1_electrons->GetBinContent(bin);
3531  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_electrons->GetBinContent(bin);
3532  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_electrons->GetBinContent(bin);
3533  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3534  wstot_pT_data_p0 =
3535  m_wstot_pT_data_p0_unconverted_photons->GetBinContent(bin);
3536  wstot_pT_data_p1 =
3537  m_wstot_pT_data_p1_unconverted_photons->GetBinContent(bin);
3538  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_unconverted_photons->GetBinContent(bin);
3539  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_unconverted_photons->GetBinContent(bin);
3540  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3541  wstot_pT_data_p0 = m_wstot_pT_data_p0_converted_photons->GetBinContent(bin);
3542  wstot_pT_data_p1 = m_wstot_pT_data_p1_converted_photons->GetBinContent(bin);
3543  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_converted_photons->GetBinContent(bin);
3544  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_converted_photons->GetBinContent(bin);
3545  }
3546 
3547  double wstot_pT_data = 0.;
3548  double wstot_pT_MC = 0.;
3549 
3550  // Initial parametrization: [0]+1*pT
3551  // wstot_pT_data = wstot_pT_data_p0+wstot_pT_data_p1*ETGeV;
3552  // prevent wstot_pT_data from being negative
3553  // if(wstot_pT_data<0) wstot_pT_data = 0.;
3554 
3555  // New parametrization: p0+p1/sqrt(pT)
3556  // flat uncertainty below 25 GeV
3557  if (ETGeV < 25.)
3558  ETGeV = 25.;
3559 
3560  wstot_pT_data = wstot_pT_data_p0 + wstot_pT_data_p1 / sqrt(ETGeV);
3561  wstot_pT_MC = wstot_pT_MC_p0 + wstot_pT_MC_p1 / sqrt(ETGeV);
3562 
3563  value = 2 * A / 91.2 * (wstot_pT_data - wstot_40_data) -
3564  2 * B / 91.2 * (wstot_pT_MC - wstot_40_MC);
3565 
3566  return value;
3567 }

◆ getZeeMeanET()

double AtlasRoot::egammaEnergyCorrectionTool::getZeeMeanET ( double  cl_eta) const
private

Definition at line 2539 of file egammaEnergyCorrectionTool.cxx.

2539  {
2540  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
2541  return 40000.;
2542  else {
2543  if (std::abs(cl_eta) >= 2.47)
2544  cl_eta = 2.46;
2545  return m_meanZeeProfile->GetBinContent(
2546  m_meanZeeProfile->FindBin(std::abs(cl_eta))) *
2547  1000;
2548  }
2549 }

◆ initialize()

int AtlasRoot::egammaEnergyCorrectionTool::initialize ( )

Definition at line 178 of file egammaEnergyCorrectionTool.cxx.

178  {
179 
180  ATH_MSG_DEBUG("initialize internal tool");
181 
182  // Load the ROOT filea
183  const std::unique_ptr<char[]> fname(
184  gSystem->ExpandPathName(m_rootFileName.c_str()));
185  std::unique_ptr<TFile> rootFile(TFile::Open(fname.get(), "READ"));
186 
187  if (!rootFile) {
188  ATH_MSG_ERROR("no root file found");
189  return 0;
190  }
191 
192  ATH_MSG_DEBUG("Opening ES model file " << fname.get());
193 
194  // instantiate the resolution parametrization
195  m_getMaterialDelta = std::make_unique<get_MaterialResolutionEffect>();
196 
197  // Energy corrections and systematic uncertainties
199 
200  // Legacy numbers for 2010
201  if (m_esmodel == egEnergyCorr::es2010) {
202  m_use_new_resolution_model = false;
203  m_aPSNom.reset(
204  checked_own_cast<TH1*>(rootFile->Get("Scales/es2010/alphaPS_errTot")));
205  m_aS12Nom.reset(
206  checked_own_cast<TH1*>(rootFile->Get("Scales/es2010/alphaS12_errTot")));
207  m_zeeNom.reset(checked_own_cast<TH1*>(
208  rootFile->Get("Scales/es2010/alphaZee_errStat")));
209  m_zeeSyst.reset(checked_own_cast<TH1*>(
210  rootFile->Get("Scales/es2010/alphaZee_errSyst")));
211  m_resNom.reset(checked_own_cast<TH1*>(
212  rootFile->Get("Resolution/es2010/ctZee_errStat")));
213  m_resSyst.reset(checked_own_cast<TH1*>(
214  rootFile->Get("Resolution/es2010/ctZee_errSyst")));
215  m_peakResData.reset(
216  checked_own_cast<TH1*>(rootFile->Get("Resolution/es2010/resZee_Data")));
217  m_peakResMC.reset(
218  checked_own_cast<TH1*>(rootFile->Get("Resolution/es2010/resZee_MC")));
219  m_begRunNumber = 152166;
220  m_endRunNumber = 170482;
221  // mc11c : faulty electron multiple scattering in G4; old geometry
222  // Precise Z scales, systematics otherwise as in 2010
223 
224  } else if (m_esmodel == egEnergyCorr::es2011c) {
225  m_use_new_resolution_model = false;
226  m_aPSNom.reset(
227  checked_own_cast<TH1*>(rootFile->Get("Scales/es2011c/alphaPS_errTot")));
228  m_aS12Nom.reset(checked_own_cast<TH1*>(
229  rootFile->Get("Scales/es2011c/alphaS12_errTot")));
230  m_zeeNom.reset(checked_own_cast<TH1*>(
231  rootFile->Get("Scales/es2011c/alphaZee_errStat")));
232  m_zeeSyst.reset(checked_own_cast<TH1*>(
233  rootFile->Get("Scales/es2011c/alphaZee_errSyst")));
234  m_resNom.reset(checked_own_cast<TH1*>(
235  rootFile->Get("Resolution/es2011c/ctZee_errStat")));
236  m_resSyst.reset(checked_own_cast<TH1*>(
237  rootFile->Get("Resolution/es2011c/ctZee_errSyst")));
238  m_peakResData.reset(checked_own_cast<TH1*>(
239  rootFile->Get("Resolution/es2011c/resZee_Data")));
240  m_peakResMC.reset(
241  checked_own_cast<TH1*>(rootFile->Get("Resolution/es2011c/resZee_MC")));
242 
243  m_begRunNumber = 177531;
244  m_endRunNumber = 194382;
245 
246  // mc11d : correct MSc in G4; new geometry
247  // Final Run1 calibration scheme
248  } else if (m_esmodel == egEnergyCorr::es2011d ||
249  m_esmodel == egEnergyCorr::es2011dMedium ||
250  m_esmodel == egEnergyCorr::es2011dTight) {
251  m_use_new_resolution_model = true;
252  m_resolution_tool = std::make_unique<eg_resolution>("run1");
253  m_aPSNom.reset(
254  checked_own_cast<TH1*>(rootFile->Get("Scales/es2011d/alphaPS_uncor")));
255  m_daPSCor.reset(
256  checked_own_cast<TH1*>(rootFile->Get("Scales/es2011d/dalphaPS_cor")));
257  m_aS12Nom.reset(
258  checked_own_cast<TH1*>(rootFile->Get("Scales/es2011d/alphaS12_uncor")));
259  m_daS12Cor.reset(
260  checked_own_cast<TH1*>(rootFile->Get("Scales/es2011d/dalphaS12_cor")));
261  m_trkSyst.reset(checked_own_cast<TH1*>(
262  rootFile->Get("Scales/es2011d/momentum_errSyst")));
263 
264  if (m_esmodel == egEnergyCorr::es2011d) {
265 
266  m_zeeNom.reset(checked_own_cast<TH1*>(
267  rootFile->Get("Scales/es2011d/alphaZee_errStat")));
268  m_zeeSyst.reset(checked_own_cast<TH1*>(
269  rootFile->Get("Scales/es2011d/alphaZee_errSyst")));
270  m_resNom.reset(checked_own_cast<TH1*>(
271  rootFile->Get("Resolution/es2011d/ctZee_errStat")));
272  m_resSyst.reset(checked_own_cast<TH1*>(
273  rootFile->Get("Resolution/es2011d/ctZee_errSyst")));
274 
275  } else if (m_esmodel == egEnergyCorr::es2011dMedium) {
276 
277  m_zeeNom.reset(checked_own_cast<TH1*>(
278  rootFile->Get("Scales/es2011dMedium/alphaZee_errStat")));
279  m_zeeSyst.reset(checked_own_cast<TH1*>(
280  rootFile->Get("Scales/es2011dMedium/alphaZee_errSyst")));
281  m_zeePhys.reset(checked_own_cast<TH1*>(
282  rootFile->Get("Scales/es2011dMedium/alphaZee_errPhys")));
283  m_resNom.reset(checked_own_cast<TH1*>(
284  rootFile->Get("Resolution/es2011dMedium/ctZee_errStat")));
285  m_resSyst.reset(checked_own_cast<TH1*>(
286  rootFile->Get("Resolution/es2011dMedium/ctZee_errSyst")));
287 
288  } else if (m_esmodel == egEnergyCorr::es2011dTight) {
289 
290  m_zeeNom.reset(checked_own_cast<TH1*>(
291  rootFile->Get("Scales/es2011dTight/alphaZee_errStat")));
292  m_zeeSyst.reset(checked_own_cast<TH1*>(
293  rootFile->Get("Scales/es2011dTight/alphaZee_errSyst")));
294  m_zeePhys.reset(checked_own_cast<TH1*>(
295  rootFile->Get("Scales/es2011dTight/alphaZee_errPhys")));
296  m_resNom.reset(checked_own_cast<TH1*>(
297  rootFile->Get("Resolution/es2011dTight/ctZee_errStat")));
298  m_resSyst.reset(checked_own_cast<TH1*>(
299  rootFile->Get("Resolution/es2011dTight/ctZee_errSyst")));
300  }
301 
302  m_pedestalL0.reset(checked_own_cast<TH1*>(
303  rootFile->Get("Pedestals/es2011d/pedestals_l0")));
304  m_pedestalL1.reset(checked_own_cast<TH1*>(
305  rootFile->Get("Pedestals/es2011d/pedestals_l1")));
306  m_pedestalL2.reset(checked_own_cast<TH1*>(
307  rootFile->Get("Pedestals/es2011d/pedestals_l2")));
308  m_pedestalL3.reset(checked_own_cast<TH1*>(
309  rootFile->Get("Pedestals/es2011d/pedestals_l3")));
310 
311  m_dX_ID_Nom.reset(
312  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
313 
314  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
315  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
316  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
317  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
318 
319  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
320  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
321  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
322  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
323  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
324  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
325  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
326  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
327 
328  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
329  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
330  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
331  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
332  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
333  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
334 
335  m_convRadius.reset(checked_own_cast<TH1*>(
336  rootFile->Get("Conversions/es2011d/convRadiusMigrations")));
337  m_convFakeRate.reset(checked_own_cast<TH1*>(
338  rootFile->Get("Conversions/es2011d/convFakeRate")));
339  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
340  rootFile->Get("Conversions/es2011d/convRecoEfficiency")));
341 
342  m_begRunNumber = 177531;
343  m_endRunNumber = 194382;
344 
345  const std::string gain_filename1 = PathResolverFindCalibFile(
346  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
347  const std::string gain_filename2 = PathResolverFindCalibFile(
348  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
349  m_gain_tool =
350  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
351 
352  m_e1hg_tool = std::make_unique<e1hg_systematics>(
353  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
354  "e1hg_systematics_histos.root"));
355 
356  // mc12a : crude MSc fix in G4; old geometry
357  // All systematics as in 2010.
358  } else if (m_esmodel == egEnergyCorr::es2012a) {
359  m_use_new_resolution_model = false;
360  m_aPSNom.reset(
361  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012a/alphaPS_errTot")));
362  m_aS12Nom.reset(checked_own_cast<TH1*>(
363  rootFile->Get("Scales/es2012a/alphaS12_errTot")));
364 
365  m_zeeNom.reset(checked_own_cast<TH1*>(
366  rootFile->Get("Scales/es2012a/alphaZee_errStat")));
367  m_zeeSyst.reset(checked_own_cast<TH1*>(
368  rootFile->Get("Scales/es2012a/alphaZee_errSyst")));
369 
370  m_resNom.reset(checked_own_cast<TH1*>(
371  rootFile->Get("Resolution/es2012a/ctZee_errStat")));
372  m_resSyst.reset(checked_own_cast<TH1*>(
373  rootFile->Get("Resolution/es2012a/ctZee_errSyst")));
374  m_peakResData.reset(checked_own_cast<TH1*>(
375  rootFile->Get("Resolution/es2012a/resZee_Data")));
376  m_peakResMC.reset(
377  checked_own_cast<TH1*>(rootFile->Get("Resolution/es2012a/resZee_MC")));
378 
379  m_begRunNumber = 195847;
380  m_endRunNumber = 219365;
381 
382  // mc12c : correct MSc in G4; new geometry
383  // Final Run1 calibration scheme
384  } else if (m_esmodel == egEnergyCorr::es2012c) {
385  m_use_new_resolution_model = true;
386  m_resolution_tool = std::make_unique<eg_resolution>("run1");
387 
388  m_aPSNom.reset(
389  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaPS_uncor")));
390  m_daPSCor.reset(
391  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
392  m_aS12Nom.reset(
393  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaS12_uncor")));
394  m_daS12Cor.reset(
395  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaS12_cor")));
396 
397  m_trkSyst.reset(checked_own_cast<TH1*>(
398  rootFile->Get("Scales/es2012c/momentum_errSyst")));
399 
400  m_zeeNom.reset(checked_own_cast<TH1*>(
401  rootFile->Get("Scales/es2012c/alphaZee_errStat")));
402  m_zeeSyst.reset(checked_own_cast<TH1*>(
403  rootFile->Get("Scales/es2012c/alphaZee_errSyst")));
404 
405  m_resNom.reset(checked_own_cast<TH1*>(
406  rootFile->Get("Resolution/es2012c/ctZee_errStat")));
407  m_resSyst.reset(checked_own_cast<TH1*>(
408  rootFile->Get("Resolution/es2012c/ctZee_errSyst")));
409 
410  m_pedestalL0.reset(checked_own_cast<TH1*>(
411  rootFile->Get("Pedestals/es2012c/pedestals_l0")));
412  m_pedestalL1.reset(checked_own_cast<TH1*>(
413  rootFile->Get("Pedestals/es2012c/pedestals_l1")));
414  m_pedestalL2.reset(checked_own_cast<TH1*>(
415  rootFile->Get("Pedestals/es2012c/pedestals_l2")));
416  m_pedestalL3.reset(checked_own_cast<TH1*>(
417  rootFile->Get("Pedestals/es2012c/pedestals_l3")));
418 
419  m_dX_ID_Nom.reset(
420  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
421 
422  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
423  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
424  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
425  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
426 
427  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
428  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
429  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
430  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
431  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
432  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
433  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
434  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
435 
436  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
437  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
438  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
439  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
440  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
441  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
442 
443  m_convRadius.reset(checked_own_cast<TH1*>(
444  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
445  m_convFakeRate.reset(checked_own_cast<TH1*>(
446  rootFile->Get("Conversions/es2012c/convFakeRate")));
447  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
448  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
449 
450  m_begRunNumber = 195847;
451  m_endRunNumber = 219365;
452 
453  const std::string gain_filename1 = PathResolverFindCalibFile(
454  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
455  const std::string gain_filename2 = PathResolverFindCalibFile(
456  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
457  m_gain_tool =
458  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
459 
460  m_e1hg_tool = std::make_unique<e1hg_systematics>(
461  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
462  "e1hg_systematics_histos.root"));
463  } else if (m_esmodel == egEnergyCorr::es2012XX) {
464  m_use_etaCalo_scales = true;
465  m_use_new_resolution_model = true;
466  m_resolution_tool = std::make_unique<eg_resolution>("run1");
467 
468  m_aPSNom.reset(
469  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaPS_uncor")));
470  m_daPSCor.reset(
471  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
472  m_aS12Nom.reset(
473  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaS12_uncor")));
474  m_daS12Cor.reset(
475  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaS12_cor")));
476 
477  m_trkSyst.reset(checked_own_cast<TH1*>(
478  rootFile->Get("Scales/es2012c/momentum_errSyst")));
479 
480  m_zeeNom.reset(checked_own_cast<TH1*>(
481  rootFile->Get("Scales/es2015PRE/alphaZee_errStat")));
482  m_zeeSyst.reset(checked_own_cast<TH1*>(
483  rootFile->Get("Scales/es2012c/alphaZee_errSyst")));
484 
485  m_resNom.reset(checked_own_cast<TH1*>(
486  rootFile->Get("Resolution/es2015PRE/ctZee_errStat")));
487  m_resSyst.reset(checked_own_cast<TH1*>(
488  rootFile->Get("Resolution/es2012c/ctZee_errSyst")));
489 
490  m_pedestalL0.reset(checked_own_cast<TH1*>(
491  rootFile->Get("Pedestals/es2012c/pedestals_l0")));
492  m_pedestalL1.reset(checked_own_cast<TH1*>(
493  rootFile->Get("Pedestals/es2012c/pedestals_l1")));
494  m_pedestalL2.reset(checked_own_cast<TH1*>(
495  rootFile->Get("Pedestals/es2012c/pedestals_l2")));
496  m_pedestalL3.reset(checked_own_cast<TH1*>(
497  rootFile->Get("Pedestals/es2012c/pedestals_l3")));
498 
499  m_dX_ID_Nom.reset(
500  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
501 
502  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
503  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
504  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
505  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
506 
507  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
508  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
509  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
510  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
511  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
512  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
513  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
514  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
515 
516  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
517  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
518  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
519  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
520  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
521  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
522 
523  m_convRadius.reset(checked_own_cast<TH1*>(
524  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
525  m_convFakeRate.reset(checked_own_cast<TH1*>(
526  rootFile->Get("Conversions/es2012c/convFakeRate")));
527  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
528  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
529 
530  m_begRunNumber = 195847;
531  m_endRunNumber = 219365;
532 
533  const std::string gain_filename1 = PathResolverFindCalibFile(
534  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
535  const std::string gain_filename2 = PathResolverFindCalibFile(
536  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
537  m_gain_tool =
538  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
539 
540  m_e1hg_tool = std::make_unique<e1hg_systematics>(
541  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
542  "e1hg_systematics_histos.root"));
543  } else if (m_esmodel == egEnergyCorr::es2015PRE or
544  m_esmodel == egEnergyCorr::es2015cPRE) {
545  m_use_etaCalo_scales = true;
546  m_use_new_resolution_model = true;
547  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
548 
549  m_aPSNom.reset(
550  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaPS_uncor")));
551  m_daPSCor.reset(
552  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
553  m_aS12Nom.reset(
554  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaS12_uncor")));
555  m_daS12Cor.reset(
556  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaS12_cor")));
557 
558  m_trkSyst.reset(checked_own_cast<TH1*>(
559  rootFile->Get("Scales/es2012c/momentum_errSyst")));
560 
561  m_zeeNom.reset(checked_own_cast<TH1*>(
562  rootFile->Get("Scales/es2015PRE/alphaZee_errStat")));
563  m_zeeSyst.reset(checked_own_cast<TH1*>(
564  rootFile->Get("Scales/es2015PRE/alphaZee_errSyst")));
565  m_uA2MeV_2015_first2weeks_correction.reset(checked_own_cast<TH1*>(
566  rootFile->Get("Scales/es2015PRE/histo_uA2MeV_week12")));
567 
568  m_resNom.reset(checked_own_cast<TH1*>(
569  rootFile->Get("Resolution/es2015PRE/ctZee_errStat")));
570  m_resSyst.reset(checked_own_cast<TH1*>(
571  rootFile->Get("Resolution/es2015PRE/ctZee_errSyst")));
572 
573  m_pedestalL0.reset(checked_own_cast<TH1*>(
574  rootFile->Get("Pedestals/es2012c/pedestals_l0")));
575  m_pedestalL1.reset(checked_own_cast<TH1*>(
576  rootFile->Get("Pedestals/es2012c/pedestals_l1")));
577  m_pedestalL2.reset(checked_own_cast<TH1*>(
578  rootFile->Get("Pedestals/es2012c/pedestals_l2")));
579  m_pedestalL3.reset(checked_own_cast<TH1*>(
580  rootFile->Get("Pedestals/es2012c/pedestals_l3")));
581 
582  m_dX_ID_Nom.reset(
583  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
584 
585  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
586  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
587  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
588  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
589 
590  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
591  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
592  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
593  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
594  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
595  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
596  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
597  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
598 
599  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
600  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
601  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
602  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
603  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
604  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
605 
606  m_convRadius.reset(checked_own_cast<TH1*>(
607  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
608  m_convFakeRate.reset(checked_own_cast<TH1*>(
609  rootFile->Get("Conversions/es2012c/convFakeRate")));
610  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
611  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
612 
613  m_begRunNumber = 195847;
614  m_endRunNumber = 219365;
615 
616  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
617  rootFile->Get("FastSim/es2015/el_full_fast_resolution")));
618  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
619  rootFile->Get("FastSim/es2015/ph_unconv_full_fast_resolution")));
620  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
621  rootFile->Get("FastSim/es2015/ph_conv_full_fast_resolution")));
622 
623  assert(m_G4OverAFII_resolution_electron);
624  assert(m_G4OverAFII_resolution_unconverted);
625  assert(m_G4OverAFII_resolution_converted);
626 
627  const std::string gain_filename1 = PathResolverFindCalibFile(
628  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
629  const std::string gain_filename2 = PathResolverFindCalibFile(
630  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
631  m_gain_tool =
632  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
633 
634  m_e1hg_tool = std::make_unique<e1hg_systematics>(
635  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
636  "e1hg_systematics_histos.root"));
637  } else if (m_esmodel == egEnergyCorr::es2015PRE_res_improved or
638  m_esmodel == egEnergyCorr::es2015cPRE_res_improved) {
639  m_use_etaCalo_scales = true;
640  m_use_new_resolution_model = true;
641  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
642 
643  m_aPSNom.reset(
644  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaPS_uncor")));
645  m_daPSCor.reset(
646  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
647  m_aS12Nom.reset(
648  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaS12_uncor")));
649  m_daS12Cor.reset(
650  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaS12_cor")));
651 
652  m_trkSyst.reset(checked_own_cast<TH1*>(
653  rootFile->Get("Scales/es2012c/momentum_errSyst")));
654 
655  m_zeeNom.reset(checked_own_cast<TH1*>(
656  rootFile->Get("Scales/es2015PRE/alphaZee_errStat")));
657  m_zeeSyst.reset(checked_own_cast<TH1*>(
658  rootFile->Get("Scales/es2015PRE/alphaZee_errSyst")));
659  m_uA2MeV_2015_first2weeks_correction.reset(checked_own_cast<TH1*>(
660  rootFile->Get("Scales/es2015PRE/histo_uA2MeV_week12")));
661 
662  m_resNom.reset(checked_own_cast<TH1*>(
663  rootFile->Get("Resolution/es2015PRE/ctZee_errStat")));
664  m_resSyst.reset(checked_own_cast<TH1*>(
665  rootFile->Get("Resolution/es2015PRE_res_improved/ctZee_errSyst")));
666 
667  m_pedestalL0.reset(checked_own_cast<TH1*>(
668  rootFile->Get("Pedestals/es2012c/pedestals_l0")));
669  m_pedestalL1.reset(checked_own_cast<TH1*>(
670  rootFile->Get("Pedestals/es2012c/pedestals_l1")));
671  m_pedestalL2.reset(checked_own_cast<TH1*>(
672  rootFile->Get("Pedestals/es2012c/pedestals_l2")));
673  m_pedestalL3.reset(checked_own_cast<TH1*>(
674  rootFile->Get("Pedestals/es2012c/pedestals_l3")));
675 
676  m_dX_ID_Nom.reset(
677  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
678 
679  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
680  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
681  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
682  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
683 
684  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
685  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
686  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
687  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
688  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
689  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
690  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
691  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
692 
693  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
694  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
695  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
696  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
697  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
698  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
699 
700  m_convRadius.reset(checked_own_cast<TH1*>(
701  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
702  m_convFakeRate.reset(checked_own_cast<TH1*>(
703  rootFile->Get("Conversions/es2012c/convFakeRate")));
704  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
705  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
706 
707  m_begRunNumber = 195847;
708  m_endRunNumber = 219365;
709 
710  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
711  rootFile->Get("FastSim/es2015/el_full_fast_resolution")));
712  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
713  rootFile->Get("FastSim/es2015/ph_unconv_full_fast_resolution")));
714  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
715  rootFile->Get("FastSim/es2015/ph_conv_full_fast_resolution")));
716 
717  assert(m_G4OverAFII_resolution_electron);
718  assert(m_G4OverAFII_resolution_unconverted);
719  assert(m_G4OverAFII_resolution_converted);
720  const std::string gain_filename1 = PathResolverFindCalibFile(
721  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
722  const std::string gain_filename2 = PathResolverFindCalibFile(
723  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
724  m_gain_tool =
725  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
726 
727  m_e1hg_tool = std::make_unique<e1hg_systematics>(
728  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
729  "e1hg_systematics_histos.root"));
730  } else if (m_esmodel == egEnergyCorr::es2015c_summer) {
731  m_use_etaCalo_scales = true;
732  m_use_new_resolution_model = true;
733  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
734 
735  m_aPSNom.reset(
736  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaPS_uncor")));
737  m_daPSCor.reset(
738  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
739  m_aS12Nom.reset(
740  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaS12_uncor")));
741  m_daS12Cor.reset(
742  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaS12_cor")));
743 
744  m_trkSyst.reset(checked_own_cast<TH1*>(
745  rootFile->Get("Scales/es2012c/momentum_errSyst")));
746 
747  m_zeeNom.reset(checked_own_cast<TH1*>(
748  rootFile->Get("Scales/es2015Summer/alphaZee_errStat")));
749  m_zeeSyst.reset(checked_own_cast<TH1*>(
750  rootFile->Get("Scales/es2015Summer/alphaZee_errSyst")));
751  m_uA2MeV_2015_first2weeks_correction = nullptr;
752 
753  m_resNom.reset(checked_own_cast<TH1*>(
754  rootFile->Get("Resolution/es2015Summer/ctZee_errStat")));
755  m_resSyst.reset(checked_own_cast<TH1*>(
756  rootFile->Get("Resolution/es2015Summer/ctZee_errSyst")));
757 
758  m_pedestalL0.reset(checked_own_cast<TH1*>(
759  rootFile->Get("Pedestals/es2012c/pedestals_l0")));
760  m_pedestalL1.reset(checked_own_cast<TH1*>(
761  rootFile->Get("Pedestals/es2012c/pedestals_l1")));
762  m_pedestalL2.reset(checked_own_cast<TH1*>(
763  rootFile->Get("Pedestals/es2012c/pedestals_l2")));
764  m_pedestalL3.reset(checked_own_cast<TH1*>(
765  rootFile->Get("Pedestals/es2012c/pedestals_l3")));
766 
767  m_dX_ID_Nom.reset(
768  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
769 
770  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
771  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
772  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
773  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
774 
775  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
776  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
777  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
778  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
779  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
780  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
781  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
782  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
783 
784  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
785  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
786  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
787  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
788  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
789  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
790 
791  m_convRadius.reset(checked_own_cast<TH1*>(
792  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
793  m_convFakeRate.reset(checked_own_cast<TH1*>(
794  rootFile->Get("Conversions/es2012c/convFakeRate")));
795  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
796  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
797 
798  m_begRunNumber = 195847;
799  m_endRunNumber = 219365;
800 
801  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
802  rootFile->Get("FastSim/es2015/el_full_fast_resolution")));
803  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
804  rootFile->Get("FastSim/es2015/ph_unconv_full_fast_resolution")));
805  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
806  rootFile->Get("FastSim/es2015/ph_conv_full_fast_resolution")));
807 
808  assert(m_G4OverAFII_resolution_electron);
809  assert(m_G4OverAFII_resolution_unconverted);
810  assert(m_G4OverAFII_resolution_converted);
811 
812  const std::string gain_filename1 = PathResolverFindCalibFile(
813  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
814  const std::string gain_filename2 = PathResolverFindCalibFile(
815  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
816  m_gain_tool =
817  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
818 
819  m_e1hg_tool = std::make_unique<e1hg_systematics>(
820  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
821  "e1hg_systematics_histos.root"));
822  m_use_temp_correction201215 = true; // for eta > 2.5
823  m_use_temp_correction201516 = false;
824  } else if (m_esmodel == egEnergyCorr::es2016PRE) {
825  m_use_etaCalo_scales = true;
826  m_use_new_resolution_model = true;
827  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
828 
829  m_aPSNom.reset(
830  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaPS_uncor")));
831  m_daPSCor.reset(
832  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
833  m_aS12Nom.reset(
834  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/alphaS12_uncor")));
835  m_daS12Cor.reset(
836  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaS12_cor")));
837 
838  m_trkSyst.reset(checked_own_cast<TH1*>(
839  rootFile->Get("Scales/es2012c/momentum_errSyst")));
840 
841  m_zeeNom.reset(checked_own_cast<TH1*>(
842  rootFile->Get("Scales/es2015Summer/alphaZee_errStat")));
843  m_zeeSyst.reset(checked_own_cast<TH1*>(
844  rootFile->Get("Scales/es2015Summer/alphaZee_errSyst")));
845 
846  m_resNom.reset(checked_own_cast<TH1*>(
847  rootFile->Get("Resolution/es2015Summer/ctZee_errStat")));
848  m_resSyst.reset(checked_own_cast<TH1*>(
849  rootFile->Get("Resolution/es2015Summer/ctZee_errSyst")));
850 
851  m_pedestalL0.reset(checked_own_cast<TH1*>(
852  rootFile->Get("Pedestals/es2012c/pedestals_l0")));
853  m_pedestalL1.reset(checked_own_cast<TH1*>(
854  rootFile->Get("Pedestals/es2012c/pedestals_l1")));
855  m_pedestalL2.reset(checked_own_cast<TH1*>(
856  rootFile->Get("Pedestals/es2012c/pedestals_l2")));
857  m_pedestalL3.reset(checked_own_cast<TH1*>(
858  rootFile->Get("Pedestals/es2012c/pedestals_l3")));
859 
860  m_dX_ID_Nom.reset(
861  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
862 
863  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
864  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
865  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
866  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
867 
868  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
869  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
870  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
871  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
872  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
873  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
874  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
875  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
876 
877  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
878  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
879  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
880  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
881  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
882  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
883 
884  m_convRadius.reset(checked_own_cast<TH1*>(
885  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
886  m_convFakeRate.reset(checked_own_cast<TH1*>(
887  rootFile->Get("Conversions/es2012c/convFakeRate")));
888  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
889  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
890 
891  m_begRunNumber = 195847;
892  m_endRunNumber = 219365;
893 
894  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
895  rootFile->Get("FastSim/es2015/el_full_fast_resolution")));
896  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
897  rootFile->Get("FastSim/es2015/ph_unconv_full_fast_resolution")));
898  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
899  rootFile->Get("FastSim/es2015/ph_conv_full_fast_resolution")));
900 
901  assert(m_G4OverAFII_resolution_electron);
902  assert(m_G4OverAFII_resolution_unconverted);
903  assert(m_G4OverAFII_resolution_converted);
904 
905  const std::string gain_filename1 = PathResolverFindCalibFile(
906  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
907  const std::string gain_filename2 = PathResolverFindCalibFile(
908  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
909  m_gain_tool =
910  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
911 
912  m_e1hg_tool = std::make_unique<e1hg_systematics>(
913  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
914  "e1hg_systematics_histos.root"));
915 
916  m_use_temp_correction201215 = true; // for eta > 2.5
917  m_use_temp_correction201516 = true;
918  } else if (m_esmodel == egEnergyCorr::es2017 or
919  m_esmodel == egEnergyCorr::es2017_summer or
920  m_esmodel == egEnergyCorr::es2017_summer_improved or
921  m_esmodel == egEnergyCorr::es2017_summer_final or
922  m_esmodel == egEnergyCorr::es2015_5TeV or
923  m_esmodel == egEnergyCorr::es2017_R21_PRE or
924  m_esmodel == egEnergyCorr::es2017_R21_v0 or
925  m_esmodel == egEnergyCorr::es2017_R21_v1 or
926  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
927  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
928  m_esmodel == egEnergyCorr::es2018_R21_v0 or
929  m_esmodel == egEnergyCorr::es2018_R21_v1 or
930  m_esmodel == egEnergyCorr::es2022_R22_PRE or
931  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) { // add release 21
932  // here for now
933  m_use_etaCalo_scales = true;
934  m_use_new_resolution_model = true;
935  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
936  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
937  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
938  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
939  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
940  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
941  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
942  m_resolution_tool = std::make_unique<eg_resolution>("run2_R21_v1");
943  } else {
944  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
945  }
946 
947  if (m_esmodel == egEnergyCorr::es2017_summer_final or
948  m_esmodel == egEnergyCorr::es2017_R21_v0 or
949  m_esmodel == egEnergyCorr::es2017_R21_v1 or
950  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
951  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
952  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
953  m_esmodel == egEnergyCorr::es2022_R22_PRE) {
954  m_aPSNom.reset(checked_own_cast<TH1*>(
955  rootFile->Get("Scales/es2017_summer_final/alphaPS_uncor")));
956  m_daPSb12.reset(checked_own_cast<TH1*>(
957  rootFile->Get("Scales/es2017_summer_final/dalphaPS_b12")));
958  m_daPSCor.reset(
959  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
960  m_aS12Nom.reset(checked_own_cast<TH1*>(
961  rootFile->Get("Scales/es2017_summer_final/alphaS12_uncor")));
962  m_daS12Cor.reset(checked_own_cast<TH1*>(
963  rootFile->Get("Scales/es2012c/dalphaS12_cor")));
964  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1) {
965  m_aPSNom.reset(checked_own_cast<TH1*>(
966  rootFile->Get("Scales/es2017_summer_final/alphaPS_uncor")));
967  m_daPSb12.reset(checked_own_cast<TH1*>(
968  rootFile->Get("Scales/es2017_summer_final/dalphaPS_b12")));
969  m_daPSCor.reset(
970  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
971  m_aS12Nom.reset(checked_own_cast<TH1*>(
972  rootFile->Get("Scales/es2018_R21_v1/alphaS12_uncor")));
973  m_daS12Cor.reset(checked_own_cast<TH1*>(
974  rootFile->Get("Scales/es2012c/dalphaS12_cor")));
975  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
976  m_aPSNom.reset(checked_own_cast<TH1*>(
977  rootFile->Get("Scales/es2023_R22_Run2_v0/alphaPS_uncor")));
978  m_aS12Nom.reset(checked_own_cast<TH1*>(
979  rootFile->Get("Scales/es2023_R22_Run2_v0/alphaS12_uncor")));
980  } else {
981  m_aPSNom.reset(checked_own_cast<TH1*>(
982  rootFile->Get("Scales/es2012c/alphaPS_uncor")));
983  m_daPSCor.reset(
984  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
985  m_aS12Nom.reset(checked_own_cast<TH1*>(
986  rootFile->Get("Scales/es2012c/alphaS12_uncor")));
987  m_daS12Cor.reset(checked_own_cast<TH1*>(
988  rootFile->Get("Scales/es2012c/dalphaS12_cor")));
989  }
990  m_trkSyst.reset(checked_own_cast<TH1*>(
991  rootFile->Get("Scales/es2012c/momentum_errSyst")));
992 
993  if (m_esmodel == egEnergyCorr::es2017) {
994  m_zeeNom.reset(checked_own_cast<TH1*>(
995  rootFile->Get("Scales/es2017/alphaZee_errStat_period_2016")));
996  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
997  rootFile->Get("Scales/es2017/alphaZee_errStat_period_2015")));
998  } else if (m_esmodel == egEnergyCorr::es2017_summer or
999  m_esmodel == egEnergyCorr::es2017_summer_improved) {
1000  m_zeeNom.reset(checked_own_cast<TH1*>(
1001  rootFile->Get("Scales/es2017_summer/alphaZee_errStat_period_2016")));
1002  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1003  rootFile->Get("Scales/es2017_summer/alphaZee_errStat_period_2015")));
1004  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1005  m_zeeNom.reset(checked_own_cast<TH1*>(rootFile->Get(
1006  "Scales/es2017_summer_final/alphaZee_errStat_period_2016")));
1007  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(rootFile->Get(
1008  "Scales/es2017_summer_final/alphaZee_errStat_period_2015")));
1009  } else if (m_esmodel == egEnergyCorr::es2015_5TeV) {
1010  m_zeeNom.reset(checked_own_cast<TH1*>(
1011  rootFile->Get("Scales/es2015_5TeV/alphaZee_errStat_period_2015")));
1012  // Same histogram added twice for simplicity
1013  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1014  rootFile->Get("Scales/es2015_5TeV/alphaZee_errStat_period_2015")));
1015  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1016  m_zeeNom.reset(checked_own_cast<TH1*>(
1017  rootFile->Get("Scales/es2017_R21_v0/alphaZee_errStat_period_2017")));
1018  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1019  rootFile->Get("Scales/es2017_R21_v0/alphaZee_errStat_period_2016")));
1020  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1021  rootFile->Get("Scales/es2017_R21_v0/alphaZee_errStat_period_2015")));
1022  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1023  m_zeeNom.reset(checked_own_cast<TH1*>(
1024  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errStat_period_2017")));
1025  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1026  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errStat_period_2016")));
1027  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1028  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errStat_period_2015")));
1029  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1030  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalk")));
1031  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1032  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalb")));
1033  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1034  m_zeeNom.reset(checked_own_cast<TH1*>(rootFile->Get(
1035  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2017")));
1036  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(rootFile->Get(
1037  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2016")));
1038  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(rootFile->Get(
1039  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2015")));
1040  m_zeeNom_data2018.reset(checked_own_cast<TH1*>(rootFile->Get(
1041  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2018")));
1042  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1043  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalk")));
1044  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1045  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalb")));
1046  } else if (m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0) {
1047  m_zeeNom.reset(checked_own_cast<TH1*>(rootFile->Get(
1048  "Scales/es2024_Run3_ofc0_v0/alphaZee_errStat")));
1049  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1050  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalk")));
1051  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1052  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalb")));
1053  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1054 
1055  m_zeeNom.reset(checked_own_cast<TH1*>(
1056  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2018")));
1057  m_zeeNom_data2017.reset(checked_own_cast<TH1*>(
1058  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2017")));
1059  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1060  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2016")));
1061  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1062  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2015")));
1063  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1064  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1065  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1066  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1067  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1) {
1068  m_zeeNom.reset(checked_own_cast<TH1*>(
1069  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2018")));
1070  m_zeeNom_data2017.reset(checked_own_cast<TH1*>(
1071  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2017")));
1072  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1073  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2016")));
1074  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1075  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2015")));
1076  // same as in v0 model
1077  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1078  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1079  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1080  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1081  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1082  m_zeeNom.reset(checked_own_cast<TH1*>(
1083  rootFile->Get("Scales/es2022_R22_PRE/alphaZee_errStat_period_2018")));
1084  // same as in v0 model
1085  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1086  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1087  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1088  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1089  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1090  // TODO: update to latest version from Tao
1091  m_zeeNom.reset(checked_own_cast<TH1*>(rootFile->Get(
1092  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2018")));
1093  m_zeeNom_data2017.reset(checked_own_cast<TH1*>(rootFile->Get(
1094  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2017")));
1095  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(rootFile->Get(
1096  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2016")));
1097  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(rootFile->Get(
1098  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2015")));
1099  // same as in v0 model
1100  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1101  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1102  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1103  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1104  } else {
1105  m_zeeNom.reset(checked_own_cast<TH1*>(
1106  rootFile->Get("Scales/es2017_R21_PRE/alphaZee_errStat_period_2016")));
1107  // SAME HISTO FOR 2015 FOR NOW
1108  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1109  rootFile->Get("Scales/es2017_R21_PRE/alphaZee_errStat_period_2016")));
1110  }
1111  if (m_esmodel == egEnergyCorr::es2017) {
1112  m_zeeSyst.reset(checked_own_cast<TH1*>(
1113  rootFile->Get("Scales/es2017/alphaZee_errSyst")));
1114  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1115  m_zeeSyst.reset(checked_own_cast<TH1*>(
1116  rootFile->Get("Scales/es2017_summer_final/alphaZee_errSyst")));
1117  } else if (m_esmodel == egEnergyCorr::es2015_5TeV) {
1118  m_zeeSyst.reset(checked_own_cast<TH1*>(
1119  rootFile->Get("Scales/es2015_5TeV/alphaZee_errSyst")));
1120  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1121  m_zeeSyst.reset(checked_own_cast<TH1*>(
1122  rootFile->Get("Scales/es2017_summer_final/alphaZee_errSyst")));
1123  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1124  m_zeeSyst.reset(checked_own_cast<TH1*>(
1125  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errSyst")));
1126  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1127  m_zeeSyst.reset(checked_own_cast<TH1*>(
1128  rootFile->Get("Scales/es2017_R21_ofc0_v1/alphaZee_errSyst")));
1129  } else if (m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0) {
1130  m_zeeSyst.reset(checked_own_cast<TH1*>(
1131  rootFile->Get("Scales/es2024_Run3_ofc0_v0/alphaZee_errSyst")));
1132  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1133  m_zeeSyst.reset(checked_own_cast<TH1*>(
1134  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errSyst")));
1135  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1136  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1137  m_zeeSyst.reset(checked_own_cast<TH1*>(
1138  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errSyst")));
1139  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1140  m_zeeSyst.reset(checked_own_cast<TH1*>(
1141  rootFile->Get("Scales/es2022_R22_PRE/alphaZee_errSyst")));
1142  m_zeeSystOFC.reset(checked_own_cast<TH1*>(
1143  rootFile->Get("Scales/es2022_R22_PRE/alphaZee_errOFCSyst")));
1144  } else {
1145  m_zeeSyst.reset(checked_own_cast<TH1*>(
1146  rootFile->Get("Scales/es2017_summer/alphaZee_errSyst")));
1147  }
1148 
1149  m_uA2MeV_2015_first2weeks_correction = nullptr;
1150  if (m_esmodel == egEnergyCorr::es2017) {
1151  m_resNom.reset(checked_own_cast<TH1*>(
1152  rootFile->Get("Resolution/es2017/ctZee_errStat")));
1153  } else if (m_esmodel == egEnergyCorr::es2017_summer or
1154  m_esmodel == egEnergyCorr::es2017_summer_improved or
1155  m_esmodel == egEnergyCorr::es2015_5TeV) {
1156  m_resNom.reset(checked_own_cast<TH1*>(
1157  rootFile->Get("Resolution/es2017_summer/ctZee_errStat")));
1158  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1159  m_resNom.reset(checked_own_cast<TH1*>(
1160  rootFile->Get("Resolution/es2017_summer_final/ctZee_errStat")));
1161  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1162  m_resNom.reset(checked_own_cast<TH1*>(
1163  rootFile->Get("Resolution/es2017_R21_v0/ctZee_errStat")));
1164  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1165  m_resNom.reset(checked_own_cast<TH1*>(
1166  rootFile->Get("Resolution/es2017_R21_v1/ctZee_errStat")));
1167  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1168  m_resNom.reset(checked_own_cast<TH1*>(
1169  rootFile->Get("Resolution/es2017_R21_ofc0_v1/ctZee_errStat")));
1170  } else if (m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0) {
1171  // use same resolution smearing as run 2 ofc0 recommendation
1172  m_resNom.reset(checked_own_cast<TH1*>(
1173  rootFile->Get("Resolution/es2017_R21_ofc0_v1/ctZee_errStat")));
1174  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1175  m_resNom.reset(checked_own_cast<TH1*>(
1176  rootFile->Get("Resolution/es2018_R21_v0/ctZee_errStat")));
1177  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1) {
1178  m_resNom.reset(checked_own_cast<TH1*>(
1179  rootFile->Get("Resolution/es2018_R21_v1/ctZee_errStat")));
1180  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1181  m_resNom.reset(checked_own_cast<TH1*>(
1182  rootFile->Get("Resolution/es2022_R22_PRE/ctZee_errStat")));
1183  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1184  m_resNom.reset(checked_own_cast<TH1*>(
1185  rootFile->Get("Resolution/es2023_R22_Run2_v0/ctZee_errStat")));
1186  } else {
1187  m_resNom.reset(checked_own_cast<TH1*>(
1188  rootFile->Get("Resolution/es2017_R21_PRE/ctZee_errStat")));
1189  }
1190 
1191  if (m_esmodel == egEnergyCorr::es2017) {
1192  m_resSyst.reset(checked_own_cast<TH1*>(
1193  rootFile->Get("Resolution/es2017/ctZee_errSyst")));
1194  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1195  m_resSyst.reset(checked_own_cast<TH1*>(
1196  rootFile->Get("Resolution/es2017_summer_final/ctZee_errSyst")));
1197  } else if (m_esmodel == egEnergyCorr::es2015_5TeV) {
1198  m_resSyst.reset(checked_own_cast<TH1*>(
1199  rootFile->Get("Resolution/es2015_5TeV/ctZee_errSyst")));
1200  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1201  m_resSyst.reset(checked_own_cast<TH1*>(
1202  rootFile->Get("Resolution/es2017_summer_final/ctZee_errSyst")));
1203  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1204  m_resSyst.reset(checked_own_cast<TH1*>(
1205  rootFile->Get("Resolution/es2017_R21_v1/ctZee_errSyst")));
1206  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1207  m_resSyst.reset(checked_own_cast<TH1*>(
1208  rootFile->Get("Resolution/es2017_R21_ofc0_v1/ctZee_errSyst")));
1209  } else if (m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0) {
1210  // use same resolution smearing syst as run 2 ofc0 recommendataion
1211  m_resSyst.reset(checked_own_cast<TH1*>(
1212  rootFile->Get("Resolution/es2017_R21_ofc0_v1/ctZee_errSyst")));
1213  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1214  m_resSyst.reset(checked_own_cast<TH1*>(
1215  rootFile->Get("Resolution/es2018_R21_v0/ctZee_errSyst")));
1216  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1217  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1218  m_resSyst.reset(checked_own_cast<TH1*>(
1219  rootFile->Get("Resolution/es2018_R21_v1/ctZee_errSyst")));
1220  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1221  m_resSyst.reset(checked_own_cast<TH1*>(
1222  rootFile->Get("Resolution/es2022_R22_PRE/ctZee_errSyst")));
1223  m_resSystOFC.reset(checked_own_cast<TH1*>(
1224  rootFile->Get("Resolution/es2022_R22_PRE/ctZee_errOFCSyst")));
1225  } else {
1226  m_resSyst.reset(checked_own_cast<TH1*>(
1227  rootFile->Get("Resolution/es2017_summer/ctZee_errSyst")));
1228  }
1229  // else{
1230  // m_resSyst.reset( checked_own_cast< TH1* >(
1231  // rootFile->Get("Resolution/es2017_summer_improved/ctZee_errSyst")));
1232  // }
1233 
1234  m_pedestals_es2017.reset(
1235  checked_own_cast<TH1*>(rootFile->Get("Pedestals/es2017/pedestals")));
1236 
1237  m_dX_ID_Nom.reset(
1238  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
1239 
1240  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
1241  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
1242  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
1243  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
1244 
1245  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
1246  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
1247  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
1248  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
1249  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
1250  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
1251  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
1252  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
1253 
1254  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
1255  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
1256  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
1257  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
1258  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
1259  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
1260 
1261  m_convRadius.reset(checked_own_cast<TH1*>(
1262  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
1263  if (m_esmodel == egEnergyCorr::es2017) {
1264  m_convFakeRate.reset(checked_own_cast<TH1*>(
1265  rootFile->Get("Conversions/es2012c/convFakeRate")));
1266  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
1267  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
1268  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1269  m_convFakeRate_2D.reset(checked_own_cast<TH2*>(
1270  rootFile->Get("Conversions/es2023_R22_Run2_v0/convFakeRate")));
1271  m_convRecoEfficiency_2D.reset(checked_own_cast<TH2*>(
1272  rootFile->Get("Conversions/es2023_R22_Run2_v0/convRecoEfficiency")));
1273  } else {
1274  m_convFakeRate.reset(checked_own_cast<TH1*>(
1275  rootFile->Get("Conversions/es2017_summer/convFakeRate")));
1276  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
1277  rootFile->Get("Conversions/es2017_summer/convRecoEfficiency")));
1278  }
1279 
1280  // TODO: change path when moving to calibarea
1281  // TODO: better package this somewhere
1282 
1283  const std::string filename_pp0 = PathResolverFindCalibFile(
1284  "ElectronPhotonFourMomentumCorrection/v8/PP0sys.root");
1285 
1286  TFile file_pp0(filename_pp0.c_str());
1287  m_pp0_elec.reset(checked_own_cast<TH2*>(file_pp0.Get("elec")));
1288  m_pp0_conv.reset(checked_own_cast<TH2*>(file_pp0.Get("conv")));
1289  m_pp0_unconv.reset(checked_own_cast<TH2*>(file_pp0.Get("unco")));
1290 
1291  // similar case for wtots1
1292  const std::string filename_wstot = PathResolverFindCalibFile(
1293  "ElectronPhotonFourMomentumCorrection/v8/wstot_related_syst.root");
1294 
1295  TFile file_wstot(filename_wstot.c_str());
1296  m_wstot_slope_A_data.reset(
1297  checked_own_cast<TH1*>(file_wstot.Get("A_data")));
1298  m_wstot_slope_B_MC.reset(checked_own_cast<TH1*>(file_wstot.Get("B_mc")));
1299  m_wstot_pT_data_p0_electrons.reset(
1300  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_data_p0")));
1301  m_wstot_pT_data_p1_electrons.reset(
1302  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_data_p1")));
1303  m_wstot_pT_data_p0_unconverted_photons.reset(
1304  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_uc_data_p0")));
1305  m_wstot_pT_data_p1_unconverted_photons.reset(
1306  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_uc_data_p1")));
1307  m_wstot_pT_data_p0_converted_photons.reset(
1308  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_c_data_p0")));
1309  m_wstot_pT_data_p1_converted_photons.reset(
1310  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_c_data_p1")));
1311  m_wstot_pT_MC_p0_electrons.reset(
1312  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_mc_p0")));
1313  m_wstot_pT_MC_p1_electrons.reset(
1314  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_mc_p1")));
1315  m_wstot_pT_MC_p0_unconverted_photons.reset(
1316  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_uc_mc_p0")));
1317  m_wstot_pT_MC_p1_unconverted_photons.reset(
1318  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_uc_mc_p1")));
1319  m_wstot_pT_MC_p0_converted_photons.reset(
1320  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_c_mc_p0")));
1321  m_wstot_pT_MC_p1_converted_photons.reset(
1322  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_c_mc_p1")));
1323 
1324  m_begRunNumber = 252604;
1325  m_endRunNumber = 314199;
1326 
1327  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1328  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1329  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
1330  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1331  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1332  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1333  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1334  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
1335  rootFile->Get("FastSim/es2017_v1/resol_Af2ToG4_elec_rel21")));
1336  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
1337  rootFile->Get("FastSim/es2017_v1/resol_Af2ToG4_unco_rel21")));
1338  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
1339  rootFile->Get("FastSim/es2017_v1/resol_Af2ToG4_conv_rel21")));
1340  } else {
1341  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
1342  rootFile->Get("FastSim/es2017/el_full_fast_resolution")));
1343  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
1344  rootFile->Get("FastSim/es2017/ph_unconv_full_fast_resolution")));
1345  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
1346  rootFile->Get("FastSim/es2017/ph_conv_full_fast_resolution")));
1347  }
1348  assert(m_G4OverAFII_resolution_electron);
1349  assert(m_G4OverAFII_resolution_unconverted);
1350  assert(m_G4OverAFII_resolution_converted);
1351 
1352  const std::string gain_filename1 = PathResolverFindCalibFile(
1353  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
1354  const std::string gain_filename2 = PathResolverFindCalibFile(
1355  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
1356  m_gain_tool = nullptr;
1357 
1358  std::string gain_tool_run_2_filename;
1359  if (m_esmodel == egEnergyCorr::es2017 or
1360  m_esmodel == egEnergyCorr::es2017_summer or
1361  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1362  m_esmodel == egEnergyCorr::es2015_5TeV) {
1363  gain_tool_run_2_filename = PathResolverFindCalibFile(
1364  "ElectronPhotonFourMomentumCorrection/v11/"
1365  "gain_uncertainty_specialRun.root");
1366  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1367  gain_tool_run_2_filename = PathResolverFindCalibFile(
1368  "ElectronPhotonFourMomentumCorrection/v29/"
1369  "gain_uncertainty_specialRun.root");
1370  } else {
1371  gain_tool_run_2_filename = PathResolverFindCalibFile(
1372  "ElectronPhotonFourMomentumCorrection/v14/"
1373  "gain_uncertainty_specialRun.root");
1374  }
1375  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1376  m_gain_tool_run2 = std::make_unique<egGain::GainUncertainty>(
1377  gain_tool_run_2_filename, true, "GainUncertainty",
1378  m_useL2GainInterpolation);
1379  } else {
1380  m_gain_tool_run2 =
1381  std::make_unique<egGain::GainUncertainty>(gain_tool_run_2_filename);
1382  }
1383 
1384  m_gain_tool_run2->msg().setLevel(this->msg().level());
1385 
1386  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1387  m_e1hg_tool = std::make_unique<e1hg_systematics>(
1388  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v29/"
1389  "e1hg_systematics_histos.root"));
1390  } else {
1391  m_e1hg_tool = std::make_unique<e1hg_systematics>(
1392  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
1393  "e1hg_systematics_histos.root"));
1394  }
1395 
1396  m_use_temp_correction201215 = false;
1397  m_use_temp_correction201516 = false;
1398  } else if (m_esmodel == egEnergyCorr::es2015_day0_3percent) {
1399  m_use_new_resolution_model = true;
1400  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
1401 
1402  m_aPSNom.reset(checked_own_cast<TH1*>(
1403  rootFile->Get("Scales/es2015_day0/alphaPS_uncor"))); // old one
1404  m_daPSCor.reset(checked_own_cast<TH1*>(
1405  rootFile->Get("Scales/es2015_day0/dalphaPS_cor"))); // old one
1406  m_aS12Nom.reset(checked_own_cast<TH1*>(
1407  rootFile->Get("Scales/es2015_day0/alphaS12_uncor"))); // old one
1408  m_daS12Cor.reset(checked_own_cast<TH1*>(
1409  rootFile->Get("Scales/es2015_day0/dalphaS12_cor"))); // old one
1410 
1411  m_trkSyst.reset(checked_own_cast<TH1*>(
1412  rootFile->Get("Scales/es2015_day0/momentum_errSyst"))); // old one
1413 
1414  m_zeeNom.reset(checked_own_cast<TH1*>(
1415  rootFile->Get("Scales/es2015_day0/alphaZee_errStat"))); // old one
1416  m_zeeSyst.reset(checked_own_cast<TH1*>(
1417  rootFile->Get("Scales/es2015_day0/alphaZee_errSyst"))); // old one
1418 
1419  m_resNom.reset(checked_own_cast<TH1*>(
1420  rootFile->Get("Resolution/es2012c/ctZee_errStat"))); // old one
1421  m_resSyst.reset(checked_own_cast<TH1*>(
1422  rootFile->Get("Resolution/es2012c/ctZee_errSyst"))); // old one
1423 
1424  m_pedestalL0.reset(checked_own_cast<TH1*>(
1425  rootFile->Get("Pedestals/es2012c/pedestals_l0"))); // old one
1426  m_pedestalL1.reset(checked_own_cast<TH1*>(
1427  rootFile->Get("Pedestals/es2012c/pedestals_l1"))); // old one
1428  m_pedestalL2.reset(checked_own_cast<TH1*>(
1429  rootFile->Get("Pedestals/es2012c/pedestals_l2"))); // old one
1430  m_pedestalL3.reset(checked_own_cast<TH1*>(
1431  rootFile->Get("Pedestals/es2012c/pedestals_l3"))); // old one
1432 
1433  m_dX_ID_Nom.reset(checked_own_cast<TH1*>(
1434  rootFile->Get("Material/DX0_ConfigA"))); // old one
1435 
1436  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(rootFile->Get(
1437  "Material/Measured/DXerr_IPPS_NewG_errUncor"))); // old one
1438  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
1439  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr"))); // old one
1440 
1441  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(rootFile->Get(
1442  "Material/Measured/DXerr_IPAcc_NewG_errUncor"))); // old one
1443  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(rootFile->Get(
1444  "Material/Measured/DXerr_IPAcc_NewG_errLAr"))); // old one
1445  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
1446  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4"))); // old one
1447  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(rootFile->Get(
1448  "Material/Measured/DXerr_IPAcc_NewG_errGL1"))); // old one
1449 
1450  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(rootFile->Get(
1451  "Material/Measured/DXerr_PSAcc_NewG_errUncor"))); // old one
1452  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(rootFile->Get(
1453  "Material/Measured/DXerr_PSAcc_NewG_errLAr"))); // old one
1454  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
1455  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4"))); // old one
1456 
1457  m_convRadius.reset(checked_own_cast<TH1*>(
1458  rootFile->Get("Conversions/es2012c/convRadiusMigrations"))); // old one
1459  m_convFakeRate.reset(checked_own_cast<TH1*>(
1460  rootFile->Get("Conversions/es2012c/convFakeRate"))); // old one
1461  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
1462  rootFile->Get("Conversions/es2012c/convRecoEfficiency"))); // old one
1463 
1464  m_begRunNumber = 195847;
1465  m_endRunNumber = 219365;
1466 
1467  const std::string gain_filename1 = PathResolverFindCalibFile(
1468  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
1469  const std::string gain_filename2 = PathResolverFindCalibFile(
1470  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
1471  m_gain_tool =
1472  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
1473 
1474  m_e1hg_tool = std::make_unique<e1hg_systematics>(
1475  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
1476  "e1hg_systematics_histos.root"));
1477 
1478  // If we are here, fail s :
1479 
1480  } else if (m_esmodel == egEnergyCorr::UNDEFINED) {
1481  ATH_MSG_FATAL("ES model not initialized - Initialization fails");
1482  return 0;
1483  } else {
1484  ATH_MSG_FATAL("ES model not recognized - Initialization fails");
1485  return 0;
1486  }
1487 
1488  if (m_esmodel == egEnergyCorr::es2015cPRE or
1489  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
1490  m_esmodel == egEnergyCorr::es2015c_summer or
1491  m_esmodel == egEnergyCorr::es2016PRE or
1492  m_esmodel == egEnergyCorr::es2017 or
1493  m_esmodel == egEnergyCorr::es2017_summer or
1494  m_esmodel == egEnergyCorr::es2017_summer_improved or
1495  m_esmodel == egEnergyCorr::es2017_summer_final or
1496  m_esmodel == egEnergyCorr::es2017_R21_v0 or
1497  m_esmodel == egEnergyCorr::es2017_R21_v1 or
1498  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
1499  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
1500  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1501  m_esmodel == egEnergyCorr::es2015_5TeV or
1502  m_esmodel == egEnergyCorr::es2018_R21_v0 or
1503  m_esmodel == egEnergyCorr::es2018_R21_v1 or
1504  m_esmodel == egEnergyCorr::es2022_R22_PRE or
1505  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1506  // E4 systematics
1507  m_E4ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1508  rootFile->Get("E4Recalibration/v4/electron_eta_axis")));
1509  m_E4ElectronGraphs.reset(
1510  checked_own_cast<TList*>(rootFile->Get("E4Recalibration/v4/electron")));
1511  // for photons use the same as electrons
1512  m_E4UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1513  rootFile->Get("E4Recalibration/v4/electron_eta_axis")));
1514  m_E4UnconvertedGraphs.reset(
1515  checked_own_cast<TList*>(rootFile->Get("E4Recalibration/v4/electron")));
1516  m_E4ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1517  rootFile->Get("E4Recalibration/v4/electron_eta_axis")));
1518  m_E4ConvertedGraphs.reset(
1519  checked_own_cast<TList*>(rootFile->Get("E4Recalibration/v4/electron")));
1520  }
1521 
1522  // ... PS and S12 recalibration curves
1523  if (m_esmodel == egEnergyCorr::es2015PRE or
1524  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
1525  m_esmodel == egEnergyCorr::es2015cPRE or
1526  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
1527  m_esmodel == egEnergyCorr::es2015c_summer or
1528  m_esmodel == egEnergyCorr::es2016PRE or
1529  m_esmodel == egEnergyCorr::es2017 or
1530  m_esmodel == egEnergyCorr::es2017_summer or
1531  m_esmodel == egEnergyCorr::es2017_summer_improved or
1532  m_esmodel == egEnergyCorr::es2017_summer_final or
1533  m_esmodel == egEnergyCorr::es2017_R21_v0 or
1534  m_esmodel == egEnergyCorr::es2017_R21_v1 or
1535  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
1536  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
1537  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1538  m_esmodel == egEnergyCorr::es2015_5TeV or
1539  m_esmodel == egEnergyCorr::es2018_R21_v0 or
1540  m_esmodel == egEnergyCorr::es2018_R21_v1 or
1541  m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1542 
1543  m_psElectronEtaBins.reset(checked_own_cast<TAxis*>(
1544  rootFile->Get("PSRecalibration/es2015PRE/ElectronAxis")));
1545  m_psElectronGraphs.reset(checked_own_cast<TList*>(
1546  rootFile->Get("PSRecalibration/es2015PRE/ElectronBiasPS")));
1547  m_psUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1548  rootFile->Get("PSRecalibration/es2015PRE/UnconvertedAxis")));
1549  m_psUnconvertedGraphs.reset(checked_own_cast<TList*>(
1550  rootFile->Get("PSRecalibration/es2015PRE/UnconvertedBiasPS")));
1551  m_psConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1552  rootFile->Get("PSRecalibration/es2015PRE/ConvertedAxis")));
1553  m_psConvertedGraphs.reset(checked_own_cast<TList*>(
1554  rootFile->Get("PSRecalibration/es2015PRE/ConvertedBiasPS")));
1555 
1556  m_s12ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1557  rootFile->Get("S1Recalibration/es2015PRE/ElectronAxis")));
1558  m_s12ElectronGraphs.reset(checked_own_cast<TList*>(
1559  rootFile->Get("S1Recalibration/es2015PRE/ElectronBiasS1")));
1560  m_s12UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1561  rootFile->Get("S1Recalibration/es2015PRE/UnconvertedAxis")));
1562  m_s12UnconvertedGraphs.reset(checked_own_cast<TList*>(
1563  rootFile->Get("S1Recalibration/es2015PRE/UnconvertedBiasS1")));
1564  m_s12ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1565  rootFile->Get("S1Recalibration/es2015PRE/ConvertedAxis")));
1566  m_s12ConvertedGraphs.reset(checked_own_cast<TList*>(
1567  rootFile->Get("S1Recalibration/es2015PRE/ConvertedBiasS1")));
1568  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1569  m_psElectronEtaBins.reset(checked_own_cast<TAxis*>(
1570  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ElectronAxis")));
1571  m_psElectronGraphs.reset(checked_own_cast<TList*>(
1572  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ElectronBiasPS")));
1573  m_psUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1574  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/UnconvertedAxis")));
1575  m_psUnconvertedGraphs.reset(checked_own_cast<TList*>(
1576  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/UnconvertedBiasPS")));
1577  m_psConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1578  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ConvertedAxis")));
1579  m_psConvertedGraphs.reset(checked_own_cast<TList*>(
1580  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ConvertedBiasPS")));
1581 
1582  m_s12ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1583  rootFile->Get("S2Recalibration/ElectronAxis")));
1584  m_s12ElectronGraphs.reset(checked_own_cast<TList*>(
1585  rootFile->Get("S2Recalibration/ElectronBiasS2")));
1586  m_s12UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1587  rootFile->Get("S2Recalibration/UnconvertedAxis")));
1588  m_s12UnconvertedGraphs.reset(checked_own_cast<TList*>(
1589  rootFile->Get("S2Recalibration/UnconvertedBiasS2")));
1590  m_s12ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1591  rootFile->Get("S2Recalibration/ConvertedAxis")));
1592  m_s12ConvertedGraphs.reset(checked_own_cast<TList*>(
1593  rootFile->Get("S2Recalibration/ConvertedBiasS2")));
1594 
1595  m_EaccElectronEtaBins.reset(checked_own_cast<TAxis*>(
1596  rootFile->Get("SaccRecalibration/ElectronAxis")));
1597  m_EaccElectronGraphs.reset(checked_own_cast<TList*>(
1598  rootFile->Get("SaccRecalibration/ElectronBiasSacc")));
1599  m_EaccUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1600  rootFile->Get("SaccRecalibration/UnconvertedAxis")));
1601  m_EaccUnconvertedGraphs.reset(checked_own_cast<TList*>(
1602  rootFile->Get("SaccRecalibration/UnconvertedBiasSacc")));
1603  m_EaccConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1604  rootFile->Get("SaccRecalibration/ConvertedAxis")));
1605  m_EaccConvertedGraphs.reset(checked_own_cast<TList*>(
1606  rootFile->Get("SaccRecalibration/ConvertedBiasSacc")));
1607  } else // run1
1608  {
1609  m_psElectronEtaBins.reset(checked_own_cast<TAxis*>(
1610  rootFile->Get("PSRecalibration/ElectronAxis")));
1611  m_psElectronGraphs.reset(checked_own_cast<TList*>(
1612  rootFile->Get("PSRecalibration/ElectronBiasPS")));
1613  m_psUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1614  rootFile->Get("PSRecalibration/UnconvertedAxis")));
1615  m_psUnconvertedGraphs.reset(checked_own_cast<TList*>(
1616  rootFile->Get("PSRecalibration/UnconvertedBiasPS")));
1617  m_psConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1618  rootFile->Get("PSRecalibration/ConvertedAxis")));
1619  m_psConvertedGraphs.reset(checked_own_cast<TList*>(
1620  rootFile->Get("PSRecalibration/ConvertedBiasPS")));
1621 
1622  m_s12ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1623  rootFile->Get("S1Recalibration/ElectronAxis")));
1624  m_s12ElectronGraphs.reset(checked_own_cast<TList*>(
1625  rootFile->Get("S1Recalibration/ElectronBiasS1")));
1626  m_s12UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1627  rootFile->Get("S1Recalibration/UnconvertedAxis")));
1628  m_s12UnconvertedGraphs.reset(checked_own_cast<TList*>(
1629  rootFile->Get("S1Recalibration/UnconvertedBiasS1")));
1630  m_s12ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1631  rootFile->Get("S1Recalibration/ConvertedAxis")));
1632  m_s12ConvertedGraphs.reset(checked_own_cast<TList*>(
1633  rootFile->Get("S1Recalibration/ConvertedBiasS1")));
1634  }
1635 
1636  // further inputs do not depend on year
1637 
1638  // ... material distortions
1639  m_matUnconvertedScale.emplace_back(
1640  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1641  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigA"))));
1642  m_matUnconvertedScale.emplace_back(
1643  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1644  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigCpDp"))));
1645  m_matUnconvertedScale.emplace_back(
1646  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1647  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigEpLp"))));
1648  m_matUnconvertedScale.emplace_back(
1649  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1650  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigFpMX"))));
1651  m_matUnconvertedScale.emplace_back(
1652  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1653  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigGp"))));
1654 
1655  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1656  rootFile->Get("Material/convertedBiasSubtracted_ConfigA"))));
1657  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1658  rootFile->Get("Material/convertedBiasSubtracted_ConfigCpDp"))));
1659  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1660  rootFile->Get("Material/convertedBiasSubtracted_ConfigEpLp"))));
1661  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1662  rootFile->Get("Material/convertedBiasSubtracted_ConfigFpMX"))));
1663  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1664  rootFile->Get("Material/convertedBiasSubtracted_ConfigGp"))));
1665 
1666  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1667  rootFile->Get("Material/electronCstTerm_ConfigA"))));
1668  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1669  rootFile->Get("Material/electronCstTerm_ConfigCpDp"))));
1670  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1671  rootFile->Get("Material/electronCstTerm_ConfigEpLp"))));
1672  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1673  rootFile->Get("Material/electronCstTerm_ConfigFpMX"))));
1674  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1675  rootFile->Get("Material/electronCstTerm_ConfigGp"))));
1676 
1677  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1678  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1679  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
1680  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1681  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1682  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1683  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1684  // update dX0 plots for distorted geometry for case A, EL, FMX and N
1685  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1686  checked_own_cast<TH1*>(rootFile->Get("Material_rel21/DX0_ConfigA"))));
1687  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1688  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigCpDp"))));
1689  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1690  rootFile->Get("Material_rel21/DX0_ConfigEpLp"))));
1691  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1692  rootFile->Get("Material_rel21/DX0_ConfigFpMX"))));
1693  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1694  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigGp"))));
1695  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1696  checked_own_cast<TH1*>(rootFile->Get("Material_rel21/DX0_ConfigN"))));
1697  } else {
1698  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1699  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA"))));
1700  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1701  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigCpDp"))));
1702  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1703  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigEpLp"))));
1704  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1705  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigFpMX"))));
1706  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1707  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigGp"))));
1708  }
1709 
1710  m_matElectronEtaBins.reset(
1711  checked_own_cast<TAxis*>(rootFile->Get("Material/LinearityEtaBins")));
1712  m_matElectronGraphs.emplace_back(
1713  std::unique_ptr<TList>(checked_own_cast<TList*>(
1714  rootFile->Get("Material/Linearity_Cluster_ConfigA"))));
1715  m_matElectronGraphs.emplace_back(
1716  std::unique_ptr<TList>(checked_own_cast<TList*>(
1717  rootFile->Get("Material/Linearity_Cluster_ConfigCpDp"))));
1718  m_matElectronGraphs.emplace_back(
1719  std::unique_ptr<TList>(checked_own_cast<TList*>(
1720  rootFile->Get("Material/Linearity_Cluster_ConfigEpLp"))));
1721  m_matElectronGraphs.emplace_back(
1722  std::unique_ptr<TList>(checked_own_cast<TList*>(
1723  rootFile->Get("Material/Linearity_Cluster_ConfigFpMX"))));
1724  m_matElectronGraphs.emplace_back(
1725  std::unique_ptr<TList>(checked_own_cast<TList*>(
1726  rootFile->Get("Material/Linearity_Cluster_ConfigGp"))));
1727  // ... new material distortions from release 21 parameterizations
1728  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1729  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1730  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
1731  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1732  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1733  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1734  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1735  m_electronBias_ConfigA.reset(checked_own_cast<TH2*>(
1736  rootFile->Get("Material_rel21/electronBias_ConfigA")));
1737  m_electronBias_ConfigEpLp.reset(checked_own_cast<TH2*>(
1738  rootFile->Get("Material_rel21/electronBias_ConfigEpLp")));
1739  m_electronBias_ConfigFpMX.reset(checked_own_cast<TH2*>(
1740  rootFile->Get("Material_rel21/electronBias_ConfigFpMX")));
1741  m_electronBias_ConfigN.reset(checked_own_cast<TH2*>(
1742  rootFile->Get("Material_rel21/electronBias_ConfigN")));
1743  m_electronBias_ConfigIBL.reset(checked_own_cast<TH2*>(
1744  rootFile->Get("Material_rel21/electronBias_ConfigIBL")));
1745  m_electronBias_ConfigPP0.reset(checked_own_cast<TH2*>(
1746  rootFile->Get("Material_rel21/electronBias_ConfigPP0")));
1747  m_unconvertedBias_ConfigA.reset(checked_own_cast<TH2*>(
1748  rootFile->Get("Material_rel21/unconvertedBias_ConfigA")));
1749  m_unconvertedBias_ConfigEpLp.reset(checked_own_cast<TH2*>(
1750  rootFile->Get("Material_rel21/unconvertedBias_ConfigEpLp")));
1751  m_unconvertedBias_ConfigFpMX.reset(checked_own_cast<TH2*>(
1752  rootFile->Get("Material_rel21/unconvertedBias_ConfigFpMX")));
1753  m_unconvertedBias_ConfigN.reset(checked_own_cast<TH2*>(
1754  rootFile->Get("Material_rel21/unconvertedBias_ConfigN")));
1755  m_unconvertedBias_ConfigIBL.reset(checked_own_cast<TH2*>(
1756  rootFile->Get("Material_rel21/unconvertedBias_ConfigIBL")));
1757  m_unconvertedBias_ConfigPP0.reset(checked_own_cast<TH2*>(
1758  rootFile->Get("Material_rel21/unconvertedBias_ConfigPP0")));
1759  m_convertedBias_ConfigA.reset(checked_own_cast<TH2*>(
1760  rootFile->Get("Material_rel21/convertedBias_ConfigA")));
1761  m_convertedBias_ConfigEpLp.reset(checked_own_cast<TH2*>(
1762  rootFile->Get("Material_rel21/convertedBias_ConfigEpLp")));
1763  m_convertedBias_ConfigFpMX.reset(checked_own_cast<TH2*>(
1764  rootFile->Get("Material_rel21/convertedBias_ConfigFpMX")));
1765  m_convertedBias_ConfigN.reset(checked_own_cast<TH2*>(
1766  rootFile->Get("Material_rel21/convertedBias_ConfigN")));
1767  m_convertedBias_ConfigIBL.reset(checked_own_cast<TH2*>(
1768  rootFile->Get("Material_rel21/convertedBias_ConfigIBL")));
1769  m_convertedBias_ConfigPP0.reset(checked_own_cast<TH2*>(
1770  rootFile->Get("Material_rel21/convertedBias_ConfigPP0")));
1771  }
1772 
1773  // ... Fastsim to Fullsim corrections
1774 
1775  if (m_esmodel == egEnergyCorr::es2015PRE or
1776  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
1777  m_esmodel == egEnergyCorr::es2015cPRE or
1778  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
1779  m_esmodel == egEnergyCorr::es2015c_summer or
1780  m_esmodel == egEnergyCorr::es2016PRE) {
1781 
1782  m_G4OverAFII_electron.reset(checked_own_cast<TH1*>(
1783  rootFile->Get("FastSim/es2015/el_scale_full_fast_peak_gaussian")));
1784  m_G4OverAFII_unconverted.reset(checked_own_cast<TH1*>(rootFile->Get(
1785  "FastSim/es2015/ph_unconv_scale_full_fast_peak_gaussian")));
1786  m_G4OverAFII_converted.reset(checked_own_cast<TH1*>(
1787  rootFile->Get("FastSim/es2015/ph_conv_scale_full_fast_peak_gaussian")));
1788  } else if (m_esmodel == egEnergyCorr::es2017 or
1789  m_esmodel == egEnergyCorr::es2017_summer or
1790  m_esmodel == egEnergyCorr::es2017_summer_improved or
1791  m_esmodel == egEnergyCorr::es2017_summer_final or
1792  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1793  m_esmodel == egEnergyCorr::es2015_5TeV or
1794  m_esmodel == egEnergyCorr::es2017_R21_v0) {
1795  m_G4OverAFII_electron.reset(checked_own_cast<TH1*>(
1796  rootFile->Get("FastSim/es2017/el_scale_full_fast_peak_gaussian")));
1797  m_G4OverAFII_unconverted.reset(checked_own_cast<TH1*>(rootFile->Get(
1798  "FastSim/es2017/ph_unconv_scale_full_fast_peak_gaussian")));
1799  m_G4OverAFII_converted.reset(checked_own_cast<TH1*>(
1800  rootFile->Get("FastSim/es2017/ph_conv_scale_full_fast_peak_gaussian")));
1801  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1802  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1803  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
1804  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1805  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1806  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1807  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1808  m_G4OverAFII_electron_2D.reset(checked_own_cast<TH2*>(
1809  rootFile->Get("FastSim/es2017_v1/scale_Af2ToG4_elec_rel21")));
1810  m_G4OverAFII_electron_2D->SetDirectory(nullptr);
1811  m_G4OverAFII_unconverted_2D.reset(checked_own_cast<TH2*>(
1812  rootFile->Get("FastSim/es2017_v1/scale_Af2ToG4_unco_rel21")));
1813  m_G4OverAFII_converted_2D.reset(checked_own_cast<TH2*>(
1814  rootFile->Get("FastSim/es2017_v1/scale_Af2ToG4_conv_rel21")));
1815  } else { // run 1
1816  m_G4OverAFII_electron.reset(
1817  checked_own_cast<TH1*>(rootFile->Get("FastSim/hG4OverAF")));
1818  }
1819  m_G4OverFrSh.reset(
1820  checked_own_cast<TH1*>(rootFile->Get("FastSim/hG4OverFS")));
1821  // ... Leakage systematics
1822 
1823  if (m_esmodel != egEnergyCorr::es2017_summer and
1824  m_esmodel != egEnergyCorr::es2017_summer_improved and
1825  m_esmodel != egEnergyCorr::es2017_summer_final and
1826  m_esmodel != egEnergyCorr::es2017_R21_PRE and
1827  m_esmodel != egEnergyCorr::es2015_5TeV and
1828  m_esmodel != egEnergyCorr::es2017_R21_v0 and
1829  m_esmodel != egEnergyCorr::es2017_R21_v1 and
1830  m_esmodel != egEnergyCorr::es2017_R21_ofc0_v1 and
1831  m_esmodel != egEnergyCorr::es2024_Run3_ofc0_v0 and
1832  m_esmodel != egEnergyCorr::es2018_R21_v0 and
1833  m_esmodel != egEnergyCorr::es2018_R21_v1 and
1834  m_esmodel != egEnergyCorr::es2022_R22_PRE and
1835  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
1836  m_leakageConverted.reset(
1837  checked_own_cast<TH1*>(rootFile->Get("Leakage/LeakageDiffConverted")));
1838  m_leakageUnconverted.reset(checked_own_cast<TH1*>(
1839  rootFile->Get("Leakage/LeakageDiffUnconverted")));
1840  } else if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
1841  m_leakageConverted.reset(checked_own_cast<TH1*>(
1842  rootFile->Get("Leakage/es2017_summer/LeakageDiffConverted")));
1843  m_leakageUnconverted.reset(checked_own_cast<TH1*>(
1844  rootFile->Get("Leakage/es2017_summer/LeakageDiffUnconverted")));
1845  } else {
1846  m_leakageConverted.reset(checked_own_cast<TH1*>(
1847  rootFile->Get("Leakage/es2023_R22_Run2_v0/LeakageDiffConverted")));
1848  m_leakageUnconverted.reset(checked_own_cast<TH1*>(
1849  rootFile->Get("Leakage/es2023_R22_Run2_v0/LeakageDiffUnconverted")));
1850  m_leakageElectron.reset(checked_own_cast<TH1*>(
1851  rootFile->Get("Leakage/es2023_R22_Run2_v0/LeakageDiffElectron")));
1852  m_leakageElectron->SetDirectory(nullptr);
1853  }
1854  if (m_leakageConverted.get() && m_leakageUnconverted.get()) {
1855  m_leakageConverted->SetDirectory(nullptr);
1856  m_leakageUnconverted->SetDirectory(nullptr);
1857  } else {
1858  ATH_MSG_INFO("No leakage systematic uncertainty for ES model "
1859  << m_esmodel);
1860  }
1861 
1862  // ... Zee S2 profile (needed for gain switch syst).
1863  m_zeeES2Profile.reset(
1864  checked_own_cast<TH1*>(rootFile->Get("ZeeEnergyProfiles/p2MC")));
1865  // mean Zee energy as function of eta
1866  m_meanZeeProfile.reset(checked_own_cast<TProfile*>(
1867  rootFile->Get("ZeeMeanET/MC_eta_vs_et_profiled")));
1868  // OK, now we are all initialized and everything went fine
1869  m_initialized = true;
1870  return 1;
1871 }

◆ initMessaging()

void AthMessaging::initMessaging ( ) const
privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

40 {
41  m_imsg = Athena::getMessageSvc();
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ isInCrack()

bool AtlasRoot::egammaEnergyCorrectionTool::isInCrack ( double  cl_eta)
staticprivate

Definition at line 4612 of file egammaEnergyCorrectionTool.cxx.

4612  {
4613 
4614  return std::abs(cl_eta) >= 1.35 && std::abs(cl_eta) <= 1.55;
4615 }

◆ mcConstantTerm()

double AtlasRoot::egammaEnergyCorrectionTool::mcConstantTerm ( double  cl_eta)
staticprivate

Definition at line 2610 of file egammaEnergyCorrectionTool.cxx.

2610  {
2611 
2612  double aeta = std::abs(cl_eta);
2613  double cst = 0.;
2614 
2615  if (aeta < 0.6)
2616  cst = 0.005;
2617 
2618  else if (aeta < 1.75)
2619  cst = 0.003;
2620 
2621  else if (aeta < 2.5)
2622  cst = 0.0055 * (2.69 - aeta);
2623 
2624  // cst = 0.005;
2625 
2626  return cst;
2627 }

◆ mcNoiseTerm()

double AtlasRoot::egammaEnergyCorrectionTool::mcNoiseTerm ( double  cl_eta)
staticprivate

Definition at line 2591 of file egammaEnergyCorrectionTool.cxx.

2591  {
2592 
2593  double aeta = std::abs(cl_eta);
2594  double noise = 0.;
2595 
2596  double noise37[25] = {0.27, 0.27, 0.27, 0.27, 0.27, 0.26, 0.25, 0.23, 0.21,
2597  0.19, 0.17, 0.16, 0.15, 0.14, 0.27, 0.23, 0.17, 0.15,
2598  0.13, 0.10, 0.07, 0.06, 0.05, 0.04, 0.03};
2599 
2600  int ieta = (int)(aeta / 0.1);
2601 
2602  if (ieta >= 0 && ieta < 25)
2603  noise = noise37[ieta] * cosh(cl_eta); // the above parametrization is vs ET
2604 
2605  return noise;
2606 }

◆ mcSamplingTerm()

double AtlasRoot::egammaEnergyCorrectionTool::mcSamplingTerm ( double  cl_eta)
staticprivate

Definition at line 2555 of file egammaEnergyCorrectionTool.cxx.

2555  {
2556 
2557  double aeta = std::abs(cl_eta);
2558  double sampling = 0.;
2559 
2560  if (aeta < 0.8)
2561  sampling = 0.091;
2562 
2563  else if (aeta < 1.37)
2564  sampling = 0.036 + 0.130 * aeta;
2565 
2566  else if (aeta < 1.52)
2567  sampling = 0.27;
2568 
2569  else if (aeta < 2.0)
2570  sampling = 0.85 - 0.36 * aeta;
2571 
2572  else if (aeta < 2.3)
2573  sampling = 0.16;
2574 
2575  else if (aeta < 2.5)
2576  sampling = -1.05 + 0.52 * aeta;
2577 
2578  return sampling;
2579 }

◆ mcSamplingTermRelError()

double AtlasRoot::egammaEnergyCorrectionTool::mcSamplingTermRelError ( double  cl_eta)
staticprivate

Definition at line 2583 of file egammaEnergyCorrectionTool.cxx.

2583  {
2584 
2585  (void)cl_eta; // not used
2586  return 0.1; // when will this be improved?
2587 }

◆ mcZPeakResolution()

double AtlasRoot::egammaEnergyCorrectionTool::mcZPeakResolution ( double  cl_eta) const
private

Definition at line 2653 of file egammaEnergyCorrectionTool.cxx.

2653  {
2654 
2655  return m_peakResMC->GetBinContent(
2656  std::as_const(*m_peakResMC).GetXaxis()->FindBin(cl_eta));
2657 }

◆ msg() [1/2]

MsgStream & asg::AsgMessaging::msg ( ) const
inherited

The standard message stream.

Returns
A reference to the default message stream of this object.

Definition at line 49 of file AsgMessaging.cxx.

49  {
50 #ifndef XAOD_STANDALONE
51  return ::AthMessaging::msg();
52 #else // not XAOD_STANDALONE
53  return m_msg;
54 #endif // not XAOD_STANDALONE
55  }

◆ msg() [2/2]

MsgStream & asg::AsgMessaging::msg ( const MSG::Level  lvl) const
inherited

The standard message stream.

Parameters
lvlThe message level to set the stream to
Returns
A reference to the default message stream, set to level "lvl"

Definition at line 57 of file AsgMessaging.cxx.

57  {
58 #ifndef XAOD_STANDALONE
59  return ::AthMessaging::msg( lvl );
60 #else // not XAOD_STANDALONE
61  m_msg << lvl;
62  return m_msg;
63 #endif // not XAOD_STANDALONE
64  }

◆ msgLvl()

bool asg::AsgMessaging::msgLvl ( const MSG::Level  lvl) const
inherited

Test the output level of the object.

Parameters
lvlThe message level to test against
Returns
boolean Indicting if messages at given level will be printed
true If messages at level "lvl" will be printed

Definition at line 41 of file AsgMessaging.cxx.

41  {
42 #ifndef XAOD_STANDALONE
43  return ::AthMessaging::msgLvl( lvl );
44 #else // not XAOD_STANDALONE
45  return m_msg.msgLevel( lvl );
46 #endif // not XAOD_STANDALONE
47  }

◆ nearestEtaBEC()

double AtlasRoot::egammaEnergyCorrectionTool::nearestEtaBEC ( double  cl_eta)
staticprivate

Definition at line 4617 of file egammaEnergyCorrectionTool.cxx.

4617  {
4618 
4619  double newEta = cl_eta;
4620 
4621  if (!isInCrack(newEta))
4622  return newEta;
4623 
4624  if (newEta >= 1.35 && newEta <= 1.45)
4625  newEta = 1.349;
4626  if (newEta >= 1.45 && newEta <= 1.55)
4627  newEta = 1.551;
4628 
4629  if (newEta >= -1.55 && newEta <= -1.45)
4630  newEta = -1.551;
4631  if (newEta >= -1.45 && newEta <= -1.35)
4632  newEta = -1.349;
4633 
4634  return newEta;
4635 }

◆ pileUpTerm()

double AtlasRoot::egammaEnergyCorrectionTool::pileUpTerm ( double  energy,
double  eta,
int  particle_type 
) const
private

Definition at line 4637 of file egammaEnergyCorrectionTool.cxx.

4638  {
4639 
4640  double pileupNoise;
4641 
4642  // release 21 for <mu> =32 (combined 2015-2016-2017 dataset), pileup noise =
4643  // f(Et) for superclusters
4644  if (m_esmodel == egEnergyCorr::es2017_R21_v0 or
4645  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4646  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4647  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
4648  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4649  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4650  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4651  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4652  double avgmu = 32;
4653  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4654  avgmu = 34.;
4655 
4656  double et = energy / cosh(eta);
4657  if (et < 5000.)
4658  et = 5000.;
4659  if (et > 50000.)
4660  et = 50000.;
4661  pileupNoise = sqrt(avgmu) * (60. + 40. * log(et / 10000.) / log(5.));
4662  } else {
4663  // approximate pileup noise addition to the total noise in MeV for
4664  // <mu_data> (2012) = 20 converted photons and electrons
4665  pileupNoise = 240.;
4666  // unconverted photons, different values in barrel and end-cap
4667  if (particle_type == 1) {
4668  if (std::abs(eta) < 1.4)
4669  pileupNoise = 200.;
4670  }
4671  }
4672  return pileupNoise;
4673 }

◆ resolution()

double AtlasRoot::egammaEnergyCorrectionTool::resolution ( double  energy,
double  cl_eta,
double  cl_etaCalo,
PATCore::ParticleType::Type  ptype,
bool  withCT,
bool  fast,
egEnergyCorr::Resolution::resolutionType  resType = egEnergyCorr::Resolution::SigmaEff90 
) const

Definition at line 2839 of file egammaEnergyCorrectionTool.cxx.

2842  {
2843  int eg_resolution_ptype;
2844  if (ptype == PATCore::ParticleType::Electron)
2845  eg_resolution_ptype = 0;
2846  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2847  eg_resolution_ptype = 1;
2848  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2849  eg_resolution_ptype = 2;
2850  else {
2851  ATH_MSG_FATAL("cannot understand particle type");
2852  return -1;
2853  }
2854 
2855  double sig2 = 0.;
2856 
2857  if (m_use_new_resolution_model) {
2858  sig2 = pow(m_resolution_tool->getResolution(eg_resolution_ptype, energy,
2859  cl_eta, resType),
2860  2);
2861  const double et = energy / cosh(cl_eta);
2862  sig2 += pow(pileUpTerm(energy, cl_eta, eg_resolution_ptype) / et,
2863  2); // TODO: why et and not E?
2864  } else { // OLD model
2865 
2866  double energyGeV = energy / GeV;
2867  double a = mcSamplingTerm(cl_eta);
2868  double b = mcNoiseTerm(cl_eta);
2869  double c = mcConstantTerm(cl_eta);
2870  sig2 = a * a / energyGeV + b * b / energyGeV / energyGeV + c * c;
2871  }
2872 
2873  if (withCT and fast) {
2874  throw std::runtime_error(
2875  "It doesn't make sense to ask resolution fast sim + additional CT."
2876  " The resolution on data is FULL sim resolution + CT");
2877  }
2878 
2879  if (fast and std::abs(cl_eta) < 2.5) {
2880  if (m_esmodel == egEnergyCorr::es2017 or
2881  m_esmodel == egEnergyCorr::es2017_summer or
2882  m_esmodel == egEnergyCorr::es2017_summer_improved or
2883  m_esmodel == egEnergyCorr::es2017_summer_final or
2884  m_esmodel == egEnergyCorr::es2017_R21_PRE or
2885  m_esmodel == egEnergyCorr::es2015_5TeV or
2886  m_esmodel == egEnergyCorr::es2015PRE or
2887  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
2888  m_esmodel == egEnergyCorr::es2015cPRE or
2889  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
2890  m_esmodel == egEnergyCorr::es2015c_summer or
2891  m_esmodel == egEnergyCorr::es2016PRE or
2892  m_esmodel == egEnergyCorr::es2017_R21_v0 or
2893  m_esmodel == egEnergyCorr::es2017_R21_v1 or
2894  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
2895  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 or
2896  m_esmodel == egEnergyCorr::es2018_R21_v0 or
2897  m_esmodel == egEnergyCorr::es2018_R21_v1 or
2898  m_esmodel == egEnergyCorr::es2022_R22_PRE or
2899  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2900 
2901  double ratio_IQR_full_fast = 1.;
2902  const double ptGeV = energy / cosh(cl_eta) / 1E3;
2903 
2904  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
2905  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2906  m_esmodel == egEnergyCorr::es2024_Run3_ofc0_v0 ||
2907  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
2908  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
2909  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
2910  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2911  //
2912  // for es2017_R21_v1, histograms contain directly values of
2913  // deltaSigma**2 of relative energy resolution (FastSIm-FulSim) so need
2914  // to subtract this value to get the sigma**2 of FastSim
2915 
2916  if (ptype == PATCore::ParticleType::Electron)
2917  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_electron, cl_eta,
2918  ptGeV, true, true, true, true);
2919  if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2920  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_unconverted, cl_eta,
2921  ptGeV, true, true, true, true);
2922  if (ptype == PATCore::ParticleType::ConvertedPhoton)
2923  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_converted, cl_eta,
2924  ptGeV, true, true, true, true);
2925  if (sig2 < 0.)
2926  sig2 = 0.;
2927  } else {
2928  if (ptype == PATCore::ParticleType::Electron) {
2929  ratio_IQR_full_fast = getValueHistAt(
2930  *m_G4OverAFII_resolution_electron, ptGeV, cl_eta, true, false);
2931  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
2932  ratio_IQR_full_fast = getValueHistAt(
2933  *m_G4OverAFII_resolution_unconverted, ptGeV, cl_eta, true, false);
2934  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
2935  ratio_IQR_full_fast = getValueHistAt(
2936  *m_G4OverAFII_resolution_converted, ptGeV, cl_eta, true, false);
2937  }
2938 
2939  sig2 /= ratio_IQR_full_fast * ratio_IQR_full_fast;
2940  }
2941  }
2942  }
2943 
2944  // add the additional constant term from the Zee data/MC measurement
2945  if (withCT)
2946  sig2 += pow(
2947  dataConstantTerm(m_use_etaCalo_scales ? cl_etaCalo : cl_eta),
2948  2); // TODO: is it correct? Or should be += -c**2 + (c + deltac) ** 2 ?
2949 
2950  return sqrt(sig2);
2951 }

◆ resolutionError()

void AtlasRoot::egammaEnergyCorrectionTool::resolutionError ( double  energy,
double  cl_eta,
double &  errUp,
double &  errDown 
) const
private

Definition at line 2800 of file egammaEnergyCorrectionTool.cxx.

2802  {
2803 
2804  double Cdata = dataConstantTerm(cl_eta);
2805  double Cdata_cor = dataConstantTermCorError(cl_eta);
2806  double Cdata_err = dataConstantTermError(cl_eta);
2807 
2808  double Cdata_unc = 0.;
2809  if (Cdata_err > Cdata_cor)
2810  Cdata_unc = sqrt(Cdata_err * Cdata_err - Cdata_cor * Cdata_cor);
2811  if (Cdata_unc < 0.001)
2812  Cdata_unc = 0.001; // preserve at least the stat error
2813 
2814  double Smc = mcSamplingTerm(cl_eta);
2815  double Smc_err = mcSamplingTermRelError(cl_eta);
2816 
2817  double central = fcn_sigma(energy, Cdata, 0., Smc, 0.);
2818 
2819  double err1 = fcn_sigma(energy, Cdata, Cdata_unc, Smc, 0.) - central;
2820  double err2 = fcn_sigma(energy, Cdata, -Cdata_unc, Smc, 0.) - central;
2821  double err3 = fcn_sigma(energy, Cdata, -Cdata_cor, Smc, Smc_err) - central;
2822  double err4 = -err3;
2823 
2824  errUp = 0;
2825  if (err1 > 0)
2826  errUp = sqrt(errUp * errUp + err1 * err1);
2827  if (err2 > 0)
2828  errUp = sqrt(errUp * errUp + err2 * err2);
2829  if (err3 > 0)
2830  errUp = sqrt(errUp * errUp + err3 * err3);
2831  if (err4 > 0)
2832  errUp = sqrt(errUp * errUp + err4 * err4);
2833 
2834  errDown = -errUp;
2835 }

◆ setADCTool()

void AtlasRoot::egammaEnergyCorrectionTool::setADCTool ( std::shared_ptr< LinearityADC >  t)
inline

Definition at line 456 of file egammaEnergyCorrectionTool.h.

456 { m_ADCLinearity_tool = t; }

◆ setApplyL2GainCorrection()

void AtlasRoot::egammaEnergyCorrectionTool::setApplyL2GainCorrection ( )
inline

Definition at line 447 of file egammaEnergyCorrectionTool.h.

447 { m_useL2GainCorrection = true; }

◆ setApplyL2GainInterpolation()

void AtlasRoot::egammaEnergyCorrectionTool::setApplyL2GainInterpolation ( )
inline

Definition at line 448 of file egammaEnergyCorrectionTool.h.

448 { m_useL2GainInterpolation = true; }

◆ setApplyLeakageCorrection()

void AtlasRoot::egammaEnergyCorrectionTool::setApplyLeakageCorrection ( bool  interpt = false)
inline

Definition at line 451 of file egammaEnergyCorrectionTool.h.

451  {
452  m_useLeakageCorrection = true;
453  m_usepTInterpolationForLeakage = interpt;
454  }

◆ setESModel()

void AtlasRoot::egammaEnergyCorrectionTool::setESModel ( egEnergyCorr::ESModel  val)
inline

Definition at line 375 of file egammaEnergyCorrectionTool.h.

375 { m_esmodel = val; }

◆ setFileName()

void AtlasRoot::egammaEnergyCorrectionTool::setFileName ( const std::string &  val)
inline

Definition at line 385 of file egammaEnergyCorrectionTool.h.

385 { m_rootFileName = val; }

◆ setLevel()

void AthMessaging::setLevel ( MSG::Level  lvl)
inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

29 {
30  m_lvl = lvl;
31 }

◆ setRunNumber()

void AtlasRoot::egammaEnergyCorrectionTool::setRunNumber ( long int  runn = 0)
inline

Definition at line 388 of file egammaEnergyCorrectionTool.h.

388 { m_RunNumber = runn; }

◆ use_temp_correction201215()

void AtlasRoot::egammaEnergyCorrectionTool::use_temp_correction201215 ( bool  flag)
inline

Definition at line 392 of file egammaEnergyCorrectionTool.h.

392  {
393  m_use_temp_correction201215 = flag;
394  }

◆ use_temp_correction201516()

void AtlasRoot::egammaEnergyCorrectionTool::use_temp_correction201516 ( bool  flag)
inline

Definition at line 395 of file egammaEnergyCorrectionTool.h.

395  {
396  m_use_temp_correction201516 = flag;
397  }

◆ use_uA2MeV_2015_first2weeks_correction()

void AtlasRoot::egammaEnergyCorrectionTool::use_uA2MeV_2015_first2weeks_correction ( bool  flag)
inline

Definition at line 398 of file egammaEnergyCorrectionTool.h.

398  {
399  m_use_uA2MeV_2015_first2weeks_correction = flag;
400  }

◆ useStatErrorScaling()

void AtlasRoot::egammaEnergyCorrectionTool::useStatErrorScaling ( bool  flag)
inline

Definition at line 390 of file egammaEnergyCorrectionTool.h.

390 { m_use_stat_error_scaling = flag; }

◆ variationName() [1/2]

string AtlasRoot::egammaEnergyCorrectionTool::variationName ( egEnergyCorr::Resolution::Variation &  var)
static

Definition at line 5170 of file egammaEnergyCorrectionTool.cxx.

5171  {
5172  switch (var) {
5173  case egEnergyCorr::Resolution::None:
5174  return "Resolution::None";
5175  case egEnergyCorr::Resolution::Nominal:
5176  return "Resolution::Nominal";
5177  case egEnergyCorr::Resolution::AllDown:
5178  return "Resolution::AllDown";
5179  case egEnergyCorr::Resolution::AllUp:
5180  return "Resolution::AllUp";
5181  case egEnergyCorr::Resolution::ZSmearingUp:
5182  return "Resolution::ZSmearingUp";
5183  case egEnergyCorr::Resolution::ZSmearingDown:
5184  return "Resolution::ZSmearingDown";
5185  case egEnergyCorr::Resolution::SamplingTermUp:
5186  return "Resolution::SamplingTermUp";
5187  case egEnergyCorr::Resolution::SamplingTermDown:
5188  return "Resolution::SamplingTermDown";
5189  case egEnergyCorr::Resolution::MaterialIDUp:
5190  return "Resolution::MaterialUp";
5191  case egEnergyCorr::Resolution::MaterialIDDown:
5192  return "Resolution::MaterialDown";
5193  case egEnergyCorr::Resolution::MaterialCaloUp:
5194  return "Resolution::MaterialUp";
5195  case egEnergyCorr::Resolution::MaterialCaloDown:
5196  return "Resolution::MaterialDown";
5197  case egEnergyCorr::Resolution::MaterialCryoUp:
5198  return "Resolution::MaterialUp";
5199  case egEnergyCorr::Resolution::MaterialCryoDown:
5200  return "Resolution::MaterialDown";
5201  case egEnergyCorr::Resolution::MaterialGapUp:
5202  return "Resolution::MaterialUp";
5203  case egEnergyCorr::Resolution::MaterialGapDown:
5204  return "Resolution::MaterialDown";
5205  case egEnergyCorr::Resolution::PileUpUp:
5206  return "Resolution::PileUpUp";
5207  case egEnergyCorr::Resolution::PileUpDown:
5208  return "Resolution::PileUpDown";
5209  case egEnergyCorr::Resolution::MaterialPP0Up:
5210  return "Resolution::MaterialPP0Up";
5211  case egEnergyCorr::Resolution::MaterialPP0Down:
5212  return "Resolution::MaterialPP0Down";
5213  case egEnergyCorr::Resolution::MaterialIBLUp:
5214  return "Resolution::MaterialIBLUp";
5215  case egEnergyCorr::Resolution::MaterialIBLDown:
5216  return "Resolution::MaterialIBLDown";
5217  case egEnergyCorr::Resolution::af2Up:
5218  return "Resolution::af2Up";
5219  case egEnergyCorr::Resolution::af2Down:
5220  return "Resolution::af2Down";
5221  case egEnergyCorr::Resolution::OFCUp:
5222  return "Resolution::OFCUp";
5223  case egEnergyCorr::Resolution::OFCDown:
5224  return "Resolution::OFCDown";
5225  case egEnergyCorr::Resolution::LastResolutionVariation:
5226  return "LastResolutionVariation";
5227  default:
5228  return "Resolution::Unknown";
5229  }
5230 }

◆ variationName() [2/2]

string AtlasRoot::egammaEnergyCorrectionTool::variationName ( egEnergyCorr::Scale::Variation &  var)
static

Definition at line 4988 of file egammaEnergyCorrectionTool.cxx.

4989  {
4990  switch (var) {
4991  case egEnergyCorr::Scale::None:
4992  return "None";
4993  case egEnergyCorr::Scale::Nominal:
4994  return "Nominal";
4995  case egEnergyCorr::Scale::topoClusterThresUp:
4996  return "topoClusterThresUp";
4997  case egEnergyCorr::Scale::topoClusterThresDown:
4998  return "topoClusterThresDown";
4999  case egEnergyCorr::Scale::MomentumUp:
5000  return "MomentumUp";
5001  case egEnergyCorr::Scale::MomentumDown:
5002  return "MomentumDown";
5003  case egEnergyCorr::Scale::ZeeStatUp:
5004  return "ZeeStatUp";
5005  case egEnergyCorr::Scale::ZeeStatDown:
5006  return "ZeeStatDown";
5007  case egEnergyCorr::Scale::ZeeSystUp:
5008  return "ZeeSystUp";
5009  case egEnergyCorr::Scale::ZeeSystDown:
5010  return "ZeeSystDown";
5011  case egEnergyCorr::Scale::ZeePhysUp:
5012  return "ZeePhysUp";
5013  case egEnergyCorr::Scale::ZeePhysDown:
5014  return "ZeePhysDown";
5015  case egEnergyCorr::Scale::ZeeAllUp:
5016  return "ZeeAllUp";
5017  case egEnergyCorr::Scale::ZeeAllDown:
5018  return "ZeeAllDown";
5019  case egEnergyCorr::Scale::LArCalibUp:
5020  return "LArCalibUp";
5021  case egEnergyCorr::Scale::LArCalibDown:
5022  return "LArCalibDown";
5023  case egEnergyCorr::Scale::LArUnconvCalibUp:
5024  return "LArUnconvCalibUp";
5025  case egEnergyCorr::Scale::LArUnconvCalibDown:
5026  return "LArUnconvCalibDown";
5027  case egEnergyCorr::Scale::LArElecCalibUp:
5028  return "LArElecCalibUp";
5029  case egEnergyCorr::Scale::LArElecCalibDown:
5030  return "LArElecCalibDown";
5031  case egEnergyCorr::Scale::LArCalibExtra2015PreUp:
5032  return "LArCalibExtra2015PreUp";
5033  case egEnergyCorr::Scale::LArCalibExtra2015PreDown:
5034  return "LArCalibExtra2015PreDown";
5035  case egEnergyCorr::Scale::LArElecUnconvUp:
5036  return "LArElecUnconvUp";
5037  case egEnergyCorr::Scale::LArElecUnconvDown:
5038  return "LArElecUnconvDown";
5039  case egEnergyCorr::Scale::G4Up:
5040  return "G4Up";
5041  case egEnergyCorr::Scale::G4Down:
5042  return "G4Down";
5043  case egEnergyCorr::Scale::PSUp:
5044  return "PSUp";
5045  case egEnergyCorr::Scale::PSDown:
5046  return "PSDown";
5047  case egEnergyCorr::Scale::PSb12Up:
5048  return "PSb12Up";
5049  case egEnergyCorr::Scale::PSb12Down:
5050  return "PSb12Down";
5051  case egEnergyCorr::Scale::S12Up:
5052  return "S12Up";
5053  case egEnergyCorr::Scale::S12Down:
5054  return "S12Down";
5055  case egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up:
5056  return "S12ExtraLastEtaBinRun2Up";
5057  case egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down:
5058  return "S12ExtraLastEtaBinRun2Down";
5059  case egEnergyCorr::Scale::MatIDUp:
5060  return "MatIDUp";
5061  case egEnergyCorr::Scale::MatIDDown:
5062  return "MatIDDown";
5063  case egEnergyCorr::Scale::MatCryoUp:
5064  return "MatCryoUp";
5065  case egEnergyCorr::Scale::MatCryoDown:
5066  return "MatCryoDown";
5067  case egEnergyCorr::Scale::MatCaloUp:
5068  return "MatCaloUp";
5069  case egEnergyCorr::Scale::MatCaloDown:
5070  return "MatCaloDown";
5071  case egEnergyCorr::Scale::L1GainUp:
5072  return "L1GainUp";
5073  case egEnergyCorr::Scale::L1GainDown:
5074  return "L1GainDown";
5075  case egEnergyCorr::Scale::L2GainUp:
5076  return "L2GainUp";
5077  case egEnergyCorr::Scale::L2GainDown:
5078  return "L2GainDown";
5079  case egEnergyCorr::Scale::L2LowGainDown:
5080  return "L2LowGainDown";
5081  case egEnergyCorr::Scale::L2LowGainUp:
5082  return "L2LowGainUp";
5083  case egEnergyCorr::Scale::L2MediumGainDown:
5084  return "L2MediumGainDown";
5085  case egEnergyCorr::Scale::L2MediumGainUp:
5086  return "L2MediumGainUp";
5087  case egEnergyCorr::Scale::ADCLinUp:
5088  return "ADCLinUp";
5089  case egEnergyCorr::Scale::ADCLinDown:
5090  return "ADCLinDown";
5091  case egEnergyCorr::Scale::LeakageElecUp:
5092  return "LeakageElecUp";
5093  case egEnergyCorr::Scale::LeakageElecDown:
5094  return "LeakageElecDown";
5095  case egEnergyCorr::Scale::ConvRecoUp:
5096  return "ConvRecoUp";
5097  case egEnergyCorr::Scale::ConvRecoDown:
5098  return "ConvRecoDown";
5099  case egEnergyCorr::Scale::af2Up:
5100  return "af2Up";
5101  case egEnergyCorr::Scale::af2Down:
5102  return "af2Down";
5103  case egEnergyCorr::Scale::LeakageUnconvUp:
5104  return "LeakageUnconvUp";
5105  case egEnergyCorr::Scale::LeakageUnconvDown:
5106  return "LeakageUnconvDown";
5107  case egEnergyCorr::Scale::LeakageConvUp:
5108  return "LeakageConvUp";
5109  case egEnergyCorr::Scale::LeakageConvDown:
5110  return "LeakageConvDown";
5111  case egEnergyCorr::Scale::ConvEfficiencyUp:
5112  return "ConvEfficiencyUp";
5113  case egEnergyCorr::Scale::ConvEfficiencyDown:
5114  return "ConvEfficiencyDown";
5115  case egEnergyCorr::Scale::ConvFakeRateUp:
5116  return "ConvFakeRateUp";
5117  case egEnergyCorr::Scale::ConvFakeRateDown:
5118  return "ConvFakeRateDown";
5119  case egEnergyCorr::Scale::ConvRadiusUp:
5120  return "ConvRadiusUp";
5121  case egEnergyCorr::Scale::ConvRadiusDown:
5122  return "ConvRadiusDown";
5123  case egEnergyCorr::Scale::PedestalUp:
5124  return "PedestalUp";
5125  case egEnergyCorr::Scale::PedestalDown:
5126  return "PedestalDown";
5127  case egEnergyCorr::Scale::AllUp:
5128  return "AllUp";
5129  case egEnergyCorr::Scale::AllDown:
5130  return "AllDown";
5131  case egEnergyCorr::Scale::AllCorrelatedUp:
5132  return "AllCorrelatedUp";
5133  case egEnergyCorr::Scale::AllCorrelatedDown:
5134  return "AllCorrelatedDown";
5135  case egEnergyCorr::Scale::LArTemperature2015PreUp:
5136  return "LArTemperature2015PreUp";
5137  case egEnergyCorr::Scale::LArTemperature2015PreDown:
5138  return "LArTemperature2015PreDown";
5139  case egEnergyCorr::Scale::LArTemperature2016PreUp:
5140  return "LArTemperature2016PreUp";
5141  case egEnergyCorr::Scale::LArTemperature2016PreDown:
5142  return "LArTemperature2016PreDown";
5143  case egEnergyCorr::Scale::E4ScintillatorUp:
5144  return "E4ScintillatorUp";
5145  case egEnergyCorr::Scale::E4ScintillatorDown:
5146  return "E4ScintillatorDown";
5147  case egEnergyCorr::Scale::MatPP0Up:
5148  return "MatPP0Up";
5149  case egEnergyCorr::Scale::MatPP0Down:
5150  return "MatPP0Down";
5151  case egEnergyCorr::Scale::Wtots1Up:
5152  return "Wtots1Up";
5153  case egEnergyCorr::Scale::Wtots1Down:
5154  return "Wtots1Down";
5155  case egEnergyCorr::Scale::LastScaleVariation:
5156  return "LastScaleVariation";
5157  case egEnergyCorr::Scale::OFCUp:
5158  return "OFCUp";
5159  case egEnergyCorr::Scale::OFCDown:
5160  return "OFCDown";
5161  case egEnergyCorr::Scale::EXTRARUN3PREUp:
5162  return "EXTRARUN3PREUp";
5163  case egEnergyCorr::Scale::EXTRARUN3PREDown:
5164  return "EXTRARUN3PREDown";
5165  default:
5166  return "Unknown";
5167  }
5168 }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

◆ m_ADCLinearity_tool

std::shared_ptr<LinearityADC> AtlasRoot::egammaEnergyCorrectionTool::m_ADCLinearity_tool
private

Definition at line 465 of file egammaEnergyCorrectionTool.h.

◆ m_applyPSCorrection

bool AtlasRoot::egammaEnergyCorrectionTool::m_applyPSCorrection
private

Definition at line 800 of file egammaEnergyCorrectionTool.h.

◆ m_applyS12Correction

bool AtlasRoot::egammaEnergyCorrectionTool::m_applyS12Correction
private

Definition at line 801 of file egammaEnergyCorrectionTool.h.

◆ m_aPSNom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_aPSNom
private

Definition at line 637 of file egammaEnergyCorrectionTool.h.

◆ m_aS12Nom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_aS12Nom
private

Definition at line 640 of file egammaEnergyCorrectionTool.h.

◆ m_begRunNumber

unsigned int AtlasRoot::egammaEnergyCorrectionTool::m_begRunNumber
private

Definition at line 631 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigA

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigA
private

Definition at line 770 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigEpLp

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigEpLp
private

Definition at line 771 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigFpMX

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigFpMX
private

Definition at line 772 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigIBL

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigIBL
private

Definition at line 774 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigN

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigN
private

Definition at line 773 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigPP0

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigPP0
private

Definition at line 775 of file egammaEnergyCorrectionTool.h.

◆ m_convFakeRate

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_convFakeRate
private

Definition at line 713 of file egammaEnergyCorrectionTool.h.

◆ m_convFakeRate_2D

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convFakeRate_2D
private

Definition at line 715 of file egammaEnergyCorrectionTool.h.

◆ m_convRadius

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_convRadius
private

Definition at line 712 of file egammaEnergyCorrectionTool.h.

◆ m_convRecoEfficiency

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_convRecoEfficiency
private

Definition at line 714 of file egammaEnergyCorrectionTool.h.

◆ m_convRecoEfficiency_2D

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_convRecoEfficiency_2D
private

Definition at line 716 of file egammaEnergyCorrectionTool.h.

◆ m_daPSb12

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_daPSb12
private

Definition at line 639 of file egammaEnergyCorrectionTool.h.

◆ m_daPSCor

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_daPSCor
private

Definition at line 638 of file egammaEnergyCorrectionTool.h.

◆ m_daS12Cor

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_daS12Cor
private

Definition at line 641 of file egammaEnergyCorrectionTool.h.

◆ m_dX_ID_Nom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_ID_Nom
private

Definition at line 663 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_G4

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_G4
private

Definition at line 669 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_GL1

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_GL1
private

Definition at line 671 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_LAr

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_LAr
private

Definition at line 670 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_Nom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_Nom
private

Definition at line 668 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPPS_LAr

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPPS_LAr
private

Definition at line 666 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPPS_Nom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPPS_Nom
private

Definition at line 665 of file egammaEnergyCorrectionTool.h.

◆ m_dX_PSAcc_G4

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_G4
private

Definition at line 674 of file egammaEnergyCorrectionTool.h.

◆ m_dX_PSAcc_LAr

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_LAr
private

Definition at line 675 of file egammaEnergyCorrectionTool.h.

◆ m_dX_PSAcc_Nom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_Nom
private

Definition at line 673 of file egammaEnergyCorrectionTool.h.

◆ m_e1hg_tool

std::unique_ptr<e1hg_systematics> AtlasRoot::egammaEnergyCorrectionTool::m_e1hg_tool
private

Definition at line 468 of file egammaEnergyCorrectionTool.h.

◆ m_E4ConvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_E4ConvertedEtaBins
private

Definition at line 688 of file egammaEnergyCorrectionTool.h.

◆ m_E4ConvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_E4ConvertedGraphs
private

Definition at line 689 of file egammaEnergyCorrectionTool.h.

◆ m_E4ElectronEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_E4ElectronEtaBins
private

Definition at line 684 of file egammaEnergyCorrectionTool.h.

◆ m_E4ElectronGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_E4ElectronGraphs
private

Definition at line 685 of file egammaEnergyCorrectionTool.h.

◆ m_E4UnconvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_E4UnconvertedEtaBins
private

Definition at line 686 of file egammaEnergyCorrectionTool.h.

◆ m_E4UnconvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_E4UnconvertedGraphs
private

Definition at line 687 of file egammaEnergyCorrectionTool.h.

◆ m_EaccConvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_EaccConvertedEtaBins
private

Definition at line 702 of file egammaEnergyCorrectionTool.h.

◆ m_EaccConvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_EaccConvertedGraphs
private

Definition at line 703 of file egammaEnergyCorrectionTool.h.

◆ m_EaccElectronEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronEtaBins
private

Definition at line 698 of file egammaEnergyCorrectionTool.h.

◆ m_EaccElectronGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronGraphs
private

Definition at line 699 of file egammaEnergyCorrectionTool.h.

◆ m_EaccUnconvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_EaccUnconvertedEtaBins
private

Definition at line 700 of file egammaEnergyCorrectionTool.h.

◆ m_EaccUnconvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_EaccUnconvertedGraphs
private

Definition at line 701 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigA

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigA
private

Definition at line 758 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigEpLp

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigEpLp
private

Definition at line 759 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigFpMX

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigFpMX
private

Definition at line 760 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigIBL

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigIBL
private

Definition at line 762 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigN

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigN
private

Definition at line 761 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigPP0

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigPP0
private

Definition at line 763 of file egammaEnergyCorrectionTool.h.

◆ m_endRunNumber

unsigned int AtlasRoot::egammaEnergyCorrectionTool::m_endRunNumber
private

Definition at line 632 of file egammaEnergyCorrectionTool.h.

◆ m_esmodel

egEnergyCorr::ESModel AtlasRoot::egammaEnergyCorrectionTool::m_esmodel
private

Definition at line 793 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_converted

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_converted
private

Definition at line 780 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_converted_2D

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_converted_2D
private

Definition at line 783 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_electron

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_electron
private

Definition at line 779 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_electron_2D

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_electron_2D
private

Definition at line 782 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_resolution_converted

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_converted
private

Definition at line 789 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_resolution_electron

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_electron
private

Definition at line 787 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_resolution_unconverted

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_unconverted
private

Definition at line 788 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_unconverted

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_unconverted
private

Definition at line 781 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_unconverted_2D

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_unconverted_2D
private

Definition at line 784 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverFrSh

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_G4OverFrSh
private

Definition at line 785 of file egammaEnergyCorrectionTool.h.

◆ m_gain_tool

std::unique_ptr<egGain::GainTool> AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool
private

Definition at line 462 of file egammaEnergyCorrectionTool.h.

◆ m_gain_tool_run2

std::unique_ptr<egGain::GainUncertainty> AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool_run2
private

Definition at line 464 of file egammaEnergyCorrectionTool.h.

◆ m_getMaterialDelta

std::unique_ptr<get_MaterialResolutionEffect> AtlasRoot::egammaEnergyCorrectionTool::m_getMaterialDelta
private

Definition at line 467 of file egammaEnergyCorrectionTool.h.

◆ m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }
mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_initialized

bool AtlasRoot::egammaEnergyCorrectionTool::m_initialized
private

Definition at line 803 of file egammaEnergyCorrectionTool.h.

◆ m_leakageConverted

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_leakageConverted
private

Definition at line 718 of file egammaEnergyCorrectionTool.h.

◆ m_leakageElectron

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_leakageElectron
private

Definition at line 720 of file egammaEnergyCorrectionTool.h.

◆ m_leakageUnconverted

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_leakageUnconverted
private

Definition at line 719 of file egammaEnergyCorrectionTool.h.

◆ m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }
mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

◆ m_matConvertedScale

std::vector<std::unique_ptr<TH1> > AtlasRoot::egammaEnergyCorrectionTool::m_matConvertedScale
private

Definition at line 747 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronCstTerm

std::vector<std::unique_ptr<TH1> > AtlasRoot::egammaEnergyCorrectionTool::m_matElectronCstTerm
private

Definition at line 748 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_matElectronEtaBins
private

Definition at line 753 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronGraphs

std::vector<std::unique_ptr<TList> > AtlasRoot::egammaEnergyCorrectionTool::m_matElectronGraphs
private

Definition at line 754 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronScale

std::vector<std::unique_ptr<TH1> > AtlasRoot::egammaEnergyCorrectionTool::m_matElectronScale
private

Definition at line 745 of file egammaEnergyCorrectionTool.h.

◆ m_matUnconvertedScale

std::vector<std::unique_ptr<TH1> > AtlasRoot::egammaEnergyCorrectionTool::m_matUnconvertedScale
private

Definition at line 746 of file egammaEnergyCorrectionTool.h.

◆ m_matX0Additions

std::vector<std::unique_ptr<TH1> > AtlasRoot::egammaEnergyCorrectionTool::m_matX0Additions
private

Definition at line 749 of file egammaEnergyCorrectionTool.h.

◆ m_meanZeeProfile

std::unique_ptr<TProfile> AtlasRoot::egammaEnergyCorrectionTool::m_meanZeeProfile
private

Definition at line 655 of file egammaEnergyCorrectionTool.h.

◆ m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls
mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

◆ m_nm

std::string AthMessaging::m_nm
privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

◆ m_peakResData

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_peakResData
private

Definition at line 660 of file egammaEnergyCorrectionTool.h.

◆ m_peakResMC

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_peakResMC
private

Definition at line 661 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL0

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL0
private

Definition at line 705 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL1

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL1
private

Definition at line 706 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL2

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL2
private

Definition at line 707 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL3

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL3
private

Definition at line 708 of file egammaEnergyCorrectionTool.h.

◆ m_pedestals_es2017

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_pedestals_es2017
private

Definition at line 710 of file egammaEnergyCorrectionTool.h.

◆ m_pp0_conv

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_pp0_conv
private

Definition at line 726 of file egammaEnergyCorrectionTool.h.

◆ m_pp0_elec

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_pp0_elec
private

Definition at line 724 of file egammaEnergyCorrectionTool.h.

◆ m_pp0_unconv

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_pp0_unconv
private

Definition at line 725 of file egammaEnergyCorrectionTool.h.

◆ m_psConvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedEtaBins
private

Definition at line 681 of file egammaEnergyCorrectionTool.h.

◆ m_psConvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedGraphs
private

Definition at line 682 of file egammaEnergyCorrectionTool.h.

◆ m_psElectronEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_psElectronEtaBins
private

Definition at line 677 of file egammaEnergyCorrectionTool.h.

◆ m_psElectronGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_psElectronGraphs
private

Definition at line 678 of file egammaEnergyCorrectionTool.h.

◆ m_psUnconvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_psUnconvertedEtaBins
private

Definition at line 679 of file egammaEnergyCorrectionTool.h.

◆ m_psUnconvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_psUnconvertedGraphs
private

Definition at line 680 of file egammaEnergyCorrectionTool.h.

◆ m_resNom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_resNom
private

Definition at line 657 of file egammaEnergyCorrectionTool.h.

◆ m_resolution_tool

std::unique_ptr<eg_resolution> AtlasRoot::egammaEnergyCorrectionTool::m_resolution_tool
private

Definition at line 466 of file egammaEnergyCorrectionTool.h.

◆ m_resSyst

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_resSyst
private

Definition at line 658 of file egammaEnergyCorrectionTool.h.

◆ m_resSystOFC

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_resSystOFC
private

Definition at line 659 of file egammaEnergyCorrectionTool.h.

◆ m_rootFileName

std::string AtlasRoot::egammaEnergyCorrectionTool::m_rootFileName
private

Definition at line 629 of file egammaEnergyCorrectionTool.h.

◆ m_RunNumber

unsigned int AtlasRoot::egammaEnergyCorrectionTool::m_RunNumber
private

Definition at line 633 of file egammaEnergyCorrectionTool.h.

◆ m_s12ConvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedEtaBins
private

Definition at line 695 of file egammaEnergyCorrectionTool.h.

◆ m_s12ConvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedGraphs
private

Definition at line 696 of file egammaEnergyCorrectionTool.h.

◆ m_s12ElectronEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_s12ElectronEtaBins
private

Definition at line 691 of file egammaEnergyCorrectionTool.h.

◆ m_s12ElectronGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_s12ElectronGraphs
private

Definition at line 692 of file egammaEnergyCorrectionTool.h.

◆ m_s12UnconvertedEtaBins

std::unique_ptr<TAxis> AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedEtaBins
private

Definition at line 693 of file egammaEnergyCorrectionTool.h.

◆ m_s12UnconvertedGraphs

std::unique_ptr<TList> AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedGraphs
private

Definition at line 694 of file egammaEnergyCorrectionTool.h.

◆ m_trkSyst

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_trkSyst
private

Definition at line 635 of file egammaEnergyCorrectionTool.h.

◆ m_uA2MeV_2015_first2weeks_correction

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_uA2MeV_2015_first2weeks_correction
private

Definition at line 654 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigA

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigA
private

Definition at line 764 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigEpLp

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigEpLp
private

Definition at line 765 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigFpMX

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigFpMX
private

Definition at line 766 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigIBL

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigIBL
private

Definition at line 768 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigN

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigN
private

Definition at line 767 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigPP0

std::unique_ptr<TH2> AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigPP0
private

Definition at line 769 of file egammaEnergyCorrectionTool.h.

◆ m_use_etaCalo_scales

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_etaCalo_scales
private

Definition at line 797 of file egammaEnergyCorrectionTool.h.

◆ m_use_new_resolution_model

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_new_resolution_model
private

Definition at line 804 of file egammaEnergyCorrectionTool.h.

◆ m_use_stat_error_scaling

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_stat_error_scaling
private

Definition at line 805 of file egammaEnergyCorrectionTool.h.

◆ m_use_temp_correction201215

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201215
private

Definition at line 812 of file egammaEnergyCorrectionTool.h.

◆ m_use_temp_correction201516

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201516
private

Definition at line 813 of file egammaEnergyCorrectionTool.h.

◆ m_use_uA2MeV_2015_first2weeks_correction

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_uA2MeV_2015_first2weeks_correction
private

Definition at line 814 of file egammaEnergyCorrectionTool.h.

◆ m_useL2GainCorrection

bool AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainCorrection
private

Definition at line 807 of file egammaEnergyCorrectionTool.h.

◆ m_useL2GainInterpolation

bool AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainInterpolation
private

Definition at line 808 of file egammaEnergyCorrectionTool.h.

◆ m_useLeakageCorrection

bool AtlasRoot::egammaEnergyCorrectionTool::m_useLeakageCorrection
private

Definition at line 809 of file egammaEnergyCorrectionTool.h.

◆ m_usepTInterpolationForLeakage

bool AtlasRoot::egammaEnergyCorrectionTool::m_usepTInterpolationForLeakage
private

Definition at line 810 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_data_p0_converted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_converted_photons
private

Definition at line 734 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_data_p0_electrons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_electrons
private

Definition at line 730 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_data_p0_unconverted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_unconverted_photons
private

Definition at line 732 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_data_p1_converted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_converted_photons
private

Definition at line 735 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_data_p1_electrons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_electrons
private

Definition at line 731 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_data_p1_unconverted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_unconverted_photons
private

Definition at line 733 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_MC_p0_converted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_converted_photons
private

Definition at line 740 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_MC_p0_electrons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_electrons
private

Definition at line 736 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_MC_p0_unconverted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_unconverted_photons
private

Definition at line 738 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_MC_p1_converted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_converted_photons
private

Definition at line 741 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_MC_p1_electrons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_electrons
private

Definition at line 737 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_pT_MC_p1_unconverted_photons

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_unconverted_photons
private

Definition at line 739 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_slope_A_data

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_A_data
private

Definition at line 728 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_slope_B_MC

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_B_MC
private

Definition at line 729 of file egammaEnergyCorrectionTool.h.

◆ m_zeeES2Profile

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeES2Profile
private

Definition at line 722 of file egammaEnergyCorrectionTool.h.

◆ m_zeeFwdb

std::unique_ptr<const TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeFwdb
private

Definition at line 649 of file egammaEnergyCorrectionTool.h.

◆ m_zeeFwdk

std::unique_ptr<const TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeFwdk
private

Definition at line 648 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom
private

Definition at line 643 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2015

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2015
private

Definition at line 644 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2016

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2016
private

Definition at line 645 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2017

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2017
private

Definition at line 646 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2018

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2018
private

Definition at line 647 of file egammaEnergyCorrectionTool.h.

◆ m_zeePhys

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeePhys
private

Definition at line 653 of file egammaEnergyCorrectionTool.h.

◆ m_zeeSyst

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeSyst
private

Definition at line 651 of file egammaEnergyCorrectionTool.h.

◆ m_zeeSystOFC

std::unique_ptr<TH1> AtlasRoot::egammaEnergyCorrectionTool::m_zeeSystOFC
private

Definition at line 652 of file egammaEnergyCorrectionTool.h.

The documentation for this class was generated from the following files:
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPPS_LAr
std::unique_ptr< TH1 > m_dX_IPPS_LAr
Definition: egammaEnergyCorrectionTool.h:666
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
egEnergyCorr::Scale::ZeeSystDown
@ ZeeSystDown
Definition: egammaEnergyCorrectionTool.h:147
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
egEnergyCorr::Resolution::MaterialPP0Up
@ MaterialPP0Up
Definition: egammaEnergyCorrectionTool.h:93
AtlasRoot::egammaEnergyCorrectionTool::m_resSyst
std::unique_ptr< TH1 > m_resSyst
Definition: egammaEnergyCorrectionTool.h:658
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
AtlasRoot::egammaEnergyCorrectionTool::m_rootFileName
std::string m_rootFileName
Definition: egammaEnergyCorrectionTool.h:629
egEnergyCorr::Scale::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:266
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2015
std::unique_ptr< TH1 > m_zeeNom_data2015
Definition: egammaEnergyCorrectionTool.h:644
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:738
egEnergyCorr::Scale::PSDown
@ PSDown
Definition: egammaEnergyCorrectionTool.h:184
PATCore::ParticleType::UnconvertedPhoton
@ UnconvertedPhoton
Definition: PATCoreEnums.h:38
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_electrons
std::unique_ptr< TH1 > m_wstot_pT_data_p0_electrons
Definition: egammaEnergyCorrectionTool.h:730
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronCstTerm
std::vector< std::unique_ptr< TH1 > > m_matElectronCstTerm
Definition: egammaEnergyCorrectionTool.h:748
et
Extra patterns decribing particle interation process.
egEnergyCorr::Resolution::SamplingTermUp
@ SamplingTermUp
Definition: egammaEnergyCorrectionTool.h:74
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
egEnergyCorr::es2011c
@ es2011c
Definition: egammaEnergyCorrectionTool.h:289
egEnergyCorr::ConfigIBL
@ ConfigIBL
Definition: egammaEnergyCorrectionTool.h:345
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
egEnergyCorr::Scale::LArCalibExtra2015PreDown
@ LArCalibExtra2015PreDown
Definition: egammaEnergyCorrectionTool.h:166
egEnergyCorr::Scale::LastScaleVariation
@ LastScaleVariation
Definition: egammaEnergyCorrectionTool.h:278
mc.random_seed
random_seed
Definition: mc.PhPy8EG_Hto4l_NNLOPS_nnlo_30_ggH125_ZZ4l.py:43
AtlasRoot::egammaEnergyCorrectionTool::mcSamplingTermRelError
static double mcSamplingTermRelError(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2583
AtlasRoot::egammaEnergyCorrectionTool::m_initialized
bool m_initialized
Definition: egammaEnergyCorrectionTool.h:803
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigN
std::unique_ptr< TH2 > m_unconvertedBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:767
egEnergyCorr::es2011d
@ es2011d
Definition: egammaEnergyCorrectionTool.h:291
egEnergyCorr::Scale::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:265
egEnergyCorr::Scale::MatIDDown
@ MatIDDown
Definition: egammaEnergyCorrectionTool.h:216
beamspotman.sigmaZ
sigmaZ
Definition: beamspotman.py:1625
vtune_athena.format
format
Definition: vtune_athena.py:14
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigA
std::unique_ptr< TH2 > m_convertedBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:770
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigPP0
std::unique_ptr< TH2 > m_unconvertedBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:769
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AtlasRoot::egammaEnergyCorrectionTool::m_resNom
std::unique_ptr< TH1 > m_resNom
Definition: egammaEnergyCorrectionTool.h:657
DiTauMassTools::TauTypes::hh
@ hh
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:53
AtlasRoot::egammaEnergyCorrectionTool::m_EaccUnconvertedGraphs
std::unique_ptr< TList > m_EaccUnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:701
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
AtlasRoot::egammaEnergyCorrectionTool::m_psElectronGraphs
std::unique_ptr< TList > m_psElectronGraphs
Definition: egammaEnergyCorrectionTool.h:678
egEnergyCorr::Scale::LArTemperature2016PreUp
@ LArTemperature2016PreUp
Definition: egammaEnergyCorrectionTool.h:171
egEnergyCorr::Scale::AllCorrelatedDown
@ AllCorrelatedDown
Definition: egammaEnergyCorrectionTool.h:275
AtlasRoot::egammaEnergyCorrectionTool::m_endRunNumber
unsigned int m_endRunNumber
Definition: egammaEnergyCorrectionTool.h:632
AtlasRoot::egammaEnergyCorrectionTool::m_leakageElectron
std::unique_ptr< TH1 > m_leakageElectron
Definition: egammaEnergyCorrectionTool.h:720
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
AtlasRoot::egammaEnergyCorrectionTool::applyAFtoG4
double applyAFtoG4(double eta, double ptGeV, PATCore::ParticleType::Type ptype) const
MC calibration corrections.
Definition: egammaEnergyCorrectionTool.cxx:3077
graphs
Definition: graphs.py:1
egEnergyCorr::Scale::ConvFakeRateDown
@ ConvFakeRateDown
Definition: egammaEnergyCorrectionTool.h:255
egEnergyCorr::Resolution::ZSmearingUp
@ ZSmearingUp
Definition: egammaEnergyCorrectionTool.h:70
egEnergyCorr::Scale::G4Down
@ G4Down
Definition: egammaEnergyCorrectionTool.h:176
egEnergyCorr::Scale::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:273
hist_file_dump.d
d
Definition: hist_file_dump.py:137
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
RootHelpers::FindBin
Int_t FindBin(const TAxis *axis, const double x)
Definition: RootHelpers.cxx:14
AtlasRoot::egammaEnergyCorrectionTool::m_applyS12Correction
bool m_applyS12Correction
Definition: egammaEnergyCorrectionTool.h:801
AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedEtaBins
std::unique_ptr< TAxis > m_s12ConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:695
AtlasRoot::egammaEnergyCorrectionTool::m_zeeES2Profile
std::unique_ptr< TH1 > m_zeeES2Profile
Definition: egammaEnergyCorrectionTool.h:722
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_B_MC
std::unique_ptr< TH1 > m_wstot_slope_B_MC
Definition: egammaEnergyCorrectionTool.h:729
egEnergyCorr::Scale::L2GainDown
@ L2GainDown
Definition: egammaEnergyCorrectionTool.h:226
AtlasRoot::egammaEnergyCorrectionTool::getResolutionError
double getResolutionError(PATCore::ParticleDataType::DataType dataType, double energy, double eta, double etaCalo, PATCore::ParticleType::Type ptype, egEnergyCorr::Resolution::Variation value, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
Definition: egammaEnergyCorrectionTool.cxx:2690
AtlasRoot::egammaEnergyCorrectionTool::getE4NonLinearity
double getE4NonLinearity(double cl_eta, double meanE, PATCore::ParticleType::Type) const
Definition: egammaEnergyCorrectionTool.cxx:3705
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_elec
std::unique_ptr< TH2 > m_pp0_elec
Definition: egammaEnergyCorrectionTool.h:724
AtlasRoot::egammaEnergyCorrectionTool::getAlphaValue
double getAlphaValue(long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:2022
egEnergyCorr::Scale::LArTemperature2015PreDown
@ LArTemperature2015PreDown
Definition: egammaEnergyCorrectionTool.h:168
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigEpLp
std::unique_ptr< TH2 > m_unconvertedBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:765
egEnergyCorr::Scale::LArElecUnconvUp
@ LArElecUnconvUp
Definition: egammaEnergyCorrectionTool.h:161
AtlasRoot::egammaEnergyCorrectionTool::getResolution_systematics
void getResolution_systematics(int particle_type, double energy, double eta, double etaCalo, int syst_mask, double &resolution, double &resolution_error, double &resolution_error_up, double &resolution_error_down, int resol_type=0, bool fast=false) const
get resolution and its uncertainty)
Definition: egammaEnergyCorrectionTool.cxx:4675
AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedGraphs
std::unique_ptr< TList > m_psConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:682
AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedGraphs
std::unique_ptr< TList > m_s12ConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:696
PATCore::ParticleDataType::Fast
@ Fast
Definition: PATCoreEnums.h:22
AtlasRoot::egammaEnergyCorrectionTool::getDeltaX
double getDeltaX(double cl_eta, egEnergyCorr::MaterialCategory imat, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal) const
Definition: egammaEnergyCorrectionTool.cxx:3848
egEnergyCorr::Scale::LArElecCalibUp
@ LArElecCalibUp
Definition: egammaEnergyCorrectionTool.h:159
egEnergyCorr::Scale::MatIDUp
@ MatIDUp
Definition: egammaEnergyCorrectionTool.h:215
egEnergyCorr::es2017_R21_v1
@ es2017_R21_v1
Definition: egammaEnergyCorrectionTool.h:320
egEnergyCorr::Scale::LeakageElecUp
@ LeakageElecUp
Definition: egammaEnergyCorrectionTool.h:197
yodamerge_tmp.axis
list axis
Definition: yodamerge_tmp.py:241
AtlasRoot::egammaEnergyCorrectionTool::m_E4ConvertedEtaBins
std::unique_ptr< TAxis > m_E4ConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:688
AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool
std::unique_ptr< egGain::GainTool > m_gain_tool
Definition: egammaEnergyCorrectionTool.h:462
egEnergyCorr::Scale::LeakageConvDown
@ LeakageConvDown
Definition: egammaEnergyCorrectionTool.h:204
egEnergyCorr::Scale::MatPP0Down
@ MatPP0Down
Definition: egammaEnergyCorrectionTool.h:242
AtlasRoot::egammaEnergyCorrectionTool::m_aS12Nom
std::unique_ptr< TH1 > m_aS12Nom
Definition: egammaEnergyCorrectionTool.h:640
egEnergyCorr::es2015PRE_res_improved
@ es2015PRE_res_improved
Definition: egammaEnergyCorrectionTool.h:304
AtlasRoot::egammaEnergyCorrectionTool::m_dX_ID_Nom
std::unique_ptr< TH1 > m_dX_ID_Nom
Definition: egammaEnergyCorrectionTool.h:663
AtlasRoot::egammaEnergyCorrectionTool::get_ZeeSyst
double get_ZeeSyst(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:5232
egEnergyCorr::Resolution::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:98
bin
Definition: BinsDiffFromStripMedian.h:43
EgammaARTmonitoring_plotsMaker.particle_type
particle_type
Definition: EgammaARTmonitoring_plotsMaker.py:633
AtlasRoot::egammaEnergyCorrectionTool::m_matUnconvertedScale
std::vector< std::unique_ptr< TH1 > > m_matUnconvertedScale
Definition: egammaEnergyCorrectionTool.h:746
egEnergyCorr::Scale::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:132
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
AtlasRoot::egammaEnergyCorrectionTool::mcZPeakResolution
double mcZPeakResolution(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2653
egEnergyCorr::Scale::EXTRARUN3PREDown
@ EXTRARUN3PREDown
Definition: egammaEnergyCorrectionTool.h:270
AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedGraphs
std::unique_ptr< TList > m_s12UnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:694
egEnergyCorr::Scale::S12Up
@ S12Up
Definition: egammaEnergyCorrectionTool.h:185
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
AtlasRoot::egammaEnergyCorrectionTool::m_daS12Cor
std::unique_ptr< TH1 > m_daS12Cor
Definition: egammaEnergyCorrectionTool.h:641
egEnergyCorr::Scale::L2LowGainDown
@ L2LowGainDown
Definition: egammaEnergyCorrectionTool.h:229
AtlasRoot::egammaEnergyCorrectionTool::m_e1hg_tool
std::unique_ptr< e1hg_systematics > m_e1hg_tool
Definition: egammaEnergyCorrectionTool.h:468
athena.value
value
Definition: athena.py:124
egEnergyCorr::Scale::ZeeStatUp
@ ZeeStatUp
Definition: egammaEnergyCorrectionTool.h:144
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTerm
double dataConstantTerm(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2631
egEnergyCorr::es2011dMedium
@ es2011dMedium
Definition: egammaEnergyCorrectionTool.h:292
AtlasRoot::egammaEnergyCorrectionTool::m_meanZeeProfile
std::unique_ptr< TProfile > m_meanZeeProfile
Definition: egammaEnergyCorrectionTool.h:655
AtlasRoot::egammaEnergyCorrectionTool::getAlphaPedestal
double getAlphaPedestal(double cl_eta, double energy, double eraw, PATCore::ParticleType::Type ptype, bool isRef, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4529
AtlasRoot::egammaEnergyCorrectionTool::mcNoiseTerm
static double mcNoiseTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2591
AtlasRoot::egammaEnergyCorrectionTool::m_uA2MeV_2015_first2weeks_correction
std::unique_ptr< TH1 > m_uA2MeV_2015_first2weeks_correction
Definition: egammaEnergyCorrectionTool.h:654
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL1
std::unique_ptr< TH1 > m_pedestalL1
Definition: egammaEnergyCorrectionTool.h:706
AtlasRoot::egammaEnergyCorrectionTool::variationName
static std::string variationName(egEnergyCorr::Scale::Variation &var)
Definition: egammaEnergyCorrectionTool.cxx:4988
egEnergyCorr::Scale::ConvRadiusUp
@ ConvRadiusUp
Definition: egammaEnergyCorrectionTool.h:256
egEnergyCorr::Scale::Wtots1Up
@ Wtots1Up
Definition: egammaEnergyCorrectionTool.h:237
egEnergyCorr::Scale::MatCryoDown
@ MatCryoDown
Definition: egammaEnergyCorrectionTool.h:218
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
AtlasRoot::egammaEnergyCorrectionTool::m_peakResData
std::unique_ptr< TH1 > m_peakResData
Definition: egammaEnergyCorrectionTool.h:660
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigFpMX
std::unique_ptr< TH2 > m_unconvertedBias_ConfigFpMX
Definition: egammaEnergyCorrectionTool.h:766
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
AtlasRoot::egammaEnergyCorrectionTool::m_convFakeRate_2D
std::unique_ptr< TH2 > m_convFakeRate_2D
Definition: egammaEnergyCorrectionTool.h:715
beamspotman.sigmaX
sigmaX
Definition: beamspotman.py:1625
egEnergyCorr::Scale::ConvRecoDown
@ ConvRecoDown
Definition: egammaEnergyCorrectionTool.h:262
egEnergyCorr::Scale::LeakageConvUp
@ LeakageConvUp
Definition: egammaEnergyCorrectionTool.h:203
AtlasRoot::egammaEnergyCorrectionTool::m_s12ElectronGraphs
std::unique_ptr< TList > m_s12ElectronGraphs
Definition: egammaEnergyCorrectionTool.h:692
D3PDTest::rng
uint32_t rng()
Definition: FillerAlg.cxx:40
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
JetTiledMap::S
@ S
Definition: TiledEtaPhiMap.h:44
egEnergyCorr::Scale::ZeeSystUp
@ ZeeSystUp
Definition: egammaEnergyCorrectionTool.h:146
egGain::GainUncertainty::GainType::MEDIUM
@ MEDIUM
egEnergyCorr::Resolution::PileUpUp
@ PileUpUp
Definition: egammaEnergyCorrectionTool.h:88
AtlasRoot::egammaEnergyCorrectionTool::m_begRunNumber
unsigned int m_begRunNumber
Definition: egammaEnergyCorrectionTool.h:631
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_electrons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_electrons
Definition: egammaEnergyCorrectionTool.h:737
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
AtlasRoot::egammaEnergyCorrectionTool::getInterpolateConvSyst2D
double getInterpolateConvSyst2D(const TH2 &conv_hist, double aeta, double ET) const
Definition: egammaEnergyCorrectionTool.cxx:4489
AtlasRoot::egammaEnergyCorrectionTool::m_leakageUnconverted
std::unique_ptr< TH1 > m_leakageUnconverted
Definition: egammaEnergyCorrectionTool.h:719
egEnergyCorr::ConfigN
@ ConfigN
Definition: egammaEnergyCorrectionTool.h:344
egEnergyCorr::Scale::L2GainUp
@ L2GainUp
Definition: egammaEnergyCorrectionTool.h:225
AtlasRoot::egammaEnergyCorrectionTool::m_EaccConvertedEtaBins
std::unique_ptr< TAxis > m_EaccConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:702
egEnergyCorr::Scale::AllCorrelatedUp
@ AllCorrelatedUp
Definition: egammaEnergyCorrectionTool.h:274
egEnergyCorr::Scale::MatCaloDown
@ MatCaloDown
Definition: egammaEnergyCorrectionTool.h:220
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
egEnergyCorr::Resolution::MaterialGapUp
@ MaterialGapUp
Definition: egammaEnergyCorrectionTool.h:82
egEnergyCorr::es2017_R21_v0
@ es2017_R21_v0
Definition: egammaEnergyCorrectionTool.h:318
AtlasRoot::egammaEnergyCorrectionTool::mcConstantTerm
static double mcConstantTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2610
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_unconverted
std::unique_ptr< TH2 > m_G4OverAFII_resolution_unconverted
Definition: egammaEnergyCorrectionTool.h:788
egEnergyCorr::Scale::LeakageElecDown
@ LeakageElecDown
Definition: egammaEnergyCorrectionTool.h:198
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigIBL
std::unique_ptr< TH2 > m_unconvertedBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:768
AtlasRoot::egammaEnergyCorrectionTool::m_zeeFwdk
std::unique_ptr< const TH1 > m_zeeFwdk
Definition: egammaEnergyCorrectionTool.h:648
AtlasRoot::egammaEnergyCorrectionTool::getLayerNonLinearity
double getLayerNonLinearity(int iLayer, double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
Definition: egammaEnergyCorrectionTool.cxx:3737
AtlasRoot::egammaEnergyCorrectionTool::m_E4ConvertedGraphs
std::unique_ptr< TList > m_E4ConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:689
egEnergyCorr::Scale::L2LowGainUp
@ L2LowGainUp
Definition: egammaEnergyCorrectionTool.h:230
egEnergyCorr::ConfigPP0
@ ConfigPP0
Definition: egammaEnergyCorrectionTool.h:346
AtlasRoot::egammaEnergyCorrectionTool::m_use_stat_error_scaling
bool m_use_stat_error_scaling
Definition: egammaEnergyCorrectionTool.h:805
AtlasRoot::egammaEnergyCorrectionTool::m_usepTInterpolationForLeakage
bool m_usepTInterpolationForLeakage
Definition: egammaEnergyCorrectionTool.h:810
AtlasRoot::egammaEnergyCorrectionTool::getAlphaLeakage2D
double getAlphaLeakage2D(double cl_eta, double et, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4314
AtlasRoot::egammaEnergyCorrectionTool::m_psUnconvertedEtaBins
std::unique_ptr< TAxis > m_psUnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:679
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPPS_Nom
std::unique_ptr< TH1 > m_dX_IPPS_Nom
Definition: egammaEnergyCorrectionTool.h:665
egEnergyCorr::Scale::MomentumUp
@ MomentumUp
Definition: egammaEnergyCorrectionTool.h:137
AtlasRoot::egammaEnergyCorrectionTool::m_RunNumber
unsigned int m_RunNumber
Definition: egammaEnergyCorrectionTool.h:633
PATCore::ParticleType::ConvertedPhoton
@ ConvertedPhoton
Definition: PATCoreEnums.h:39
AtlasRoot::egammaEnergyCorrectionTool::m_use_etaCalo_scales
bool m_use_etaCalo_scales
Definition: egammaEnergyCorrectionTool.h:797
egEnergyCorr::es2015cPRE
@ es2015cPRE
Definition: egammaEnergyCorrectionTool.h:305
AtlasRoot::egammaEnergyCorrectionTool::m_s12ElectronEtaBins
std::unique_ptr< TAxis > m_s12ElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:691
AtlasRoot::egammaEnergyCorrectionTool::getAlphaMaterial
double getAlphaMaterial(double cl_eta, egEnergyCorr::MaterialCategory imat, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3953
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_converted_photons
Definition: egammaEnergyCorrectionTool.h:741
egEnergyCorr::Scale::LArTemperature2015PreUp
@ LArTemperature2015PreUp
Definition: egammaEnergyCorrectionTool.h:167
egEnergyCorr::Scale::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:272
AtlasRoot::egammaEnergyCorrectionTool::pileUpTerm
double pileUpTerm(double energy, double eta, int particle_type) const
Definition: egammaEnergyCorrectionTool.cxx:4637
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_LAr
std::unique_ptr< TH1 > m_dX_PSAcc_LAr
Definition: egammaEnergyCorrectionTool.h:675
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_electrons
std::unique_ptr< TH1 > m_wstot_pT_data_p1_electrons
Definition: egammaEnergyCorrectionTool.h:731
egEnergyCorr::Scale::L1GainDown
@ L1GainDown
Definition: egammaEnergyCorrectionTool.h:224
egEnergyCorr::Resolution::ZSmearingDown
@ ZSmearingDown
Definition: egammaEnergyCorrectionTool.h:69
A
AtlasRoot::egammaEnergyCorrectionTool::m_convFakeRate
std::unique_ptr< TH1 > m_convFakeRate
Definition: egammaEnergyCorrectionTool.h:713
AtlasRoot::egammaEnergyCorrectionTool::m_matX0Additions
std::vector< std::unique_ptr< TH1 > > m_matX0Additions
Definition: egammaEnergyCorrectionTool.h:749
AtlasRoot::egammaEnergyCorrectionTool::m_resolution_tool
std::unique_ptr< eg_resolution > m_resolution_tool
Definition: egammaEnergyCorrectionTool.h:466
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
egEnergyCorr::es2015_day0_3percent
@ es2015_day0_3percent
Definition: egammaEnergyCorrectionTool.h:301
egEnergyCorr::Scale::LArCalibUp
@ LArCalibUp
Definition: egammaEnergyCorrectionTool.h:155
egEnergyCorr::Resolution::MaterialPP0Down
@ MaterialPP0Down
Definition: egammaEnergyCorrectionTool.h:94
egEnergyCorr::es2010
@ es2010
Definition: egammaEnergyCorrectionTool.h:287
egEnergyCorr::Geometry
Geometry
Definition: egammaEnergyCorrectionTool.h:338
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
egEnergyCorr::Scale::LeakageUnconvDown
@ LeakageUnconvDown
Definition: egammaEnergyCorrectionTool.h:202
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
beamspotnt.graphs
graphs
Definition: bin/beamspotnt.py:1538
egEnergyCorr::MatCalo
@ MatCalo
Definition: egammaEnergyCorrectionTool.h:354
AtlasRoot::egammaEnergyCorrectionTool::m_EaccConvertedGraphs
std::unique_ptr< TList > m_EaccConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:703
egEnergyCorr::Resolution::MaterialCryoUp
@ MaterialCryoUp
Definition: egammaEnergyCorrectionTool.h:84
egEnergyCorr::es2017_R21_PRE
@ es2017_R21_PRE
Definition: egammaEnergyCorrectionTool.h:316
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_Nom
std::unique_ptr< TH1 > m_dX_PSAcc_Nom
Definition: egammaEnergyCorrectionTool.h:673
AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedEtaBins
std::unique_ptr< TAxis > m_psConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:681
egEnergyCorr::Scale::L1GainUp
@ L1GainUp
Definition: egammaEnergyCorrectionTool.h:223
egEnergyCorr::es2015cPRE_res_improved
@ es2015cPRE_res_improved
Definition: egammaEnergyCorrectionTool.h:306
lumiFormat.i
int i
Definition: lumiFormat.py:85
egEnergyCorr::Scale::topoClusterThresUp
@ topoClusterThresUp
Definition: egammaEnergyCorrectionTool.h:207
egEnergyCorr::Scale::ConvEfficiencyDown
@ ConvEfficiencyDown
Definition: egammaEnergyCorrectionTool.h:253
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_converted_photons
Definition: egammaEnergyCorrectionTool.h:740
AtlasRoot::egammaEnergyCorrectionTool::getAlphaZee
double getAlphaZee(long int runnumber, double eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3158
egEnergyCorr::Scale::LArElecUnconvDown
@ LArElecUnconvDown
Definition: egammaEnergyCorrectionTool.h:162
AtlasRoot::egammaEnergyCorrectionTool::m_use_new_resolution_model
bool m_use_new_resolution_model
Definition: egammaEnergyCorrectionTool.h:804
AtlasRoot::egammaEnergyCorrectionTool::m_psElectronEtaBins
std::unique_ptr< TAxis > m_psElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:677
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_unconv
std::unique_ptr< TH2 > m_pp0_unconv
Definition: egammaEnergyCorrectionTool.h:725
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p1_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:733
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p0_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:732
fitman.mz
mz
Definition: fitman.py:526
egEnergyCorr::Scale::LeakageUnconvUp
@ LeakageUnconvUp
Definition: egammaEnergyCorrectionTool.h:201
egEnergyCorr::Scale::MomentumDown
@ MomentumDown
Definition: egammaEnergyCorrectionTool.h:138
egEnergyCorr::Scale::ConvRecoUp
@ ConvRecoUp
Definition: egammaEnergyCorrectionTool.h:261
master.flag
bool flag
Definition: master.py:29
AtlasRoot::egammaEnergyCorrectionTool::m_zeePhys
std::unique_ptr< TH1 > m_zeePhys
Definition: egammaEnergyCorrectionTool.h:653
AtlasRoot::egammaEnergyCorrectionTool::getWtots1Uncertainty
double getWtots1Uncertainty(double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
Definition: egammaEnergyCorrectionTool.cxx:3494
AtlasRoot::egammaEnergyCorrectionTool::m_use_uA2MeV_2015_first2weeks_correction
bool m_use_uA2MeV_2015_first2weeks_correction
Definition: egammaEnergyCorrectionTool.h:814
egEnergyCorr::Resolution::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:62
plotBeamSpotCompare.ivar
int ivar
Definition: plotBeamSpotCompare.py:383
AtlasRoot::egammaEnergyCorrectionTool::isInCrack
static bool isInCrack(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:4612
AtlasRoot::egammaEnergyCorrectionTool::fcn_sigma
static double fcn_sigma(double energy, double Cdata, double Cdata_er, double S, double S_er)
Definition: egammaEnergyCorrectionTool.cxx:2955
AtlasRoot::egammaEnergyCorrectionTool::m_esmodel
egEnergyCorr::ESModel m_esmodel
Definition: egammaEnergyCorrectionTool.h:793
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_Nom
std::unique_ptr< TH1 > m_dX_IPAcc_Nom
Definition: egammaEnergyCorrectionTool.h:668
asg::AsgMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AsgMessaging.cxx:49
egEnergyCorr::es2012a
@ es2012a
Definition: egammaEnergyCorrectionTool.h:295
AtlasRoot::egammaEnergyCorrectionTool::m_applyPSCorrection
bool m_applyPSCorrection
Definition: egammaEnergyCorrectionTool.h:800
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:107
AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201516
bool m_use_temp_correction201516
Definition: egammaEnergyCorrectionTool.h:813
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2016
std::unique_ptr< TH1 > m_zeeNom_data2016
Definition: egammaEnergyCorrectionTool.h:645
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigEpLp
std::unique_ptr< TH2 > m_convertedBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:771
AtlasRoot::egammaEnergyCorrectionTool::m_aPSNom
std::unique_ptr< TH1 > m_aPSNom
Definition: egammaEnergyCorrectionTool.h:637
egEnergyCorr::Scale::S12Down
@ S12Down
Definition: egammaEnergyCorrectionTool.h:186
egEnergyCorr::es2017_summer
@ es2017_summer
Definition: egammaEnergyCorrectionTool.h:310
AtlasRoot::egammaEnergyCorrectionTool::getAlphaLeakage
double getAlphaLeakage(double cl_eta, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4279
makeComparison.rootFile
rootFile
Definition: makeComparison.py:27
egEnergyCorr::es2015c_summer
@ es2015c_summer
Definition: egammaEnergyCorrectionTool.h:307
AtlasRoot::egammaEnergyCorrectionTool::m_zeeFwdb
std::unique_ptr< const TH1 > m_zeeFwdb
Definition: egammaEnergyCorrectionTool.h:649
egEnergyCorr::Scale::G4Up
@ G4Up
Definition: egammaEnergyCorrectionTool.h:175
AtlasRoot::egammaEnergyCorrectionTool::nearestEtaBEC
static double nearestEtaBEC(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:4617
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronEtaBins
std::unique_ptr< TAxis > m_matElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:753
AtlasRoot::egammaEnergyCorrectionTool::m_leakageConverted
std::unique_ptr< TH1 > m_leakageConverted
Definition: egammaEnergyCorrectionTool.h:718
egEnergyCorr::Scale::L2MediumGainUp
@ L2MediumGainUp
Definition: egammaEnergyCorrectionTool.h:228
egEnergyCorr::Scale::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:245
egEnergyCorr::Scale::None
@ None
Definition: egammaEnergyCorrectionTool.h:129
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_converted_2D
std::unique_ptr< TH2 > m_G4OverAFII_converted_2D
Definition: egammaEnergyCorrectionTool.h:783
AtlasRoot::egammaEnergyCorrectionTool::m_convRadius
std::unique_ptr< TH1 > m_convRadius
Definition: egammaEnergyCorrectionTool.h:712
egEnergyCorr::Resolution::MaterialCryoDown
@ MaterialCryoDown
Definition: egammaEnergyCorrectionTool.h:83
egEnergyCorr::UNDEFINED
@ UNDEFINED
Definition: egammaEnergyCorrectionTool.h:332
egEnergyCorr::Scale::MatCaloUp
@ MatCaloUp
Definition: egammaEnergyCorrectionTool.h:219
egEnergyCorr::MatCryo
@ MatCryo
Definition: egammaEnergyCorrectionTool.h:353
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL3
std::unique_ptr< TH1 > m_pedestalL3
Definition: egammaEnergyCorrectionTool.h:708
egEnergyCorr::ConfigGp
@ ConfigGp
Definition: egammaEnergyCorrectionTool.h:343
egEnergyCorr::Scale::ZeeStatDown
@ ZeeStatDown
Definition: egammaEnergyCorrectionTool.h:145
AtlasRoot::egammaEnergyCorrectionTool::m_zeeSystOFC
std::unique_ptr< TH1 > m_zeeSystOFC
Definition: egammaEnergyCorrectionTool.h:652
AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronGraphs
std::unique_ptr< TList > m_EaccElectronGraphs
Definition: egammaEnergyCorrectionTool.h:699
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigA
std::unique_ptr< TH2 > m_electronBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:758
AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool_run2
std::unique_ptr< egGain::GainUncertainty > m_gain_tool_run2
Definition: egammaEnergyCorrectionTool.h:464
egEnergyCorr::Scale::PedestalUp
@ PedestalUp
Definition: egammaEnergyCorrectionTool.h:233
DeMoScan.runnumber
runnumber
Definition: DeMoScan.py:266
AtlasRoot::egammaEnergyCorrectionTool::getMaterialNonLinearity
double getMaterialNonLinearity(double cl_eta, double energy, egEnergyCorr::MaterialCategory imat, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4140
egEnergyCorr::Resolution::None
@ None
Definition: egammaEnergyCorrectionTool.h:59
AtlasRoot::egammaEnergyCorrectionTool::m_E4UnconvertedEtaBins
std::unique_ptr< TAxis > m_E4UnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:686
egEnergyCorr::Resolution::PileUpDown
@ PileUpDown
Definition: egammaEnergyCorrectionTool.h:87
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigFpMX
std::unique_ptr< TH2 > m_convertedBias_ConfigFpMX
Definition: egammaEnergyCorrectionTool.h:772
egEnergyCorr::Scale::E4ScintillatorUp
@ E4ScintillatorUp
Definition: egammaEnergyCorrectionTool.h:179
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_converted
std::unique_ptr< TH1 > m_G4OverAFII_converted
Definition: egammaEnergyCorrectionTool.h:780
egEnergyCorr::Scale::ZeePhysDown
@ ZeePhysDown
Definition: egammaEnergyCorrectionTool.h:149
egEnergyCorr::Scale::Variation
Variation
Definition: egammaEnergyCorrectionTool.h:126
AtlasRoot::egammaEnergyCorrectionTool::resolutionError
void resolutionError(double energy, double cl_eta, double &errUp, double &errDown) const
Definition: egammaEnergyCorrectionTool.cxx:2800
AtlasRoot::egammaEnergyCorrectionTool::m_convRecoEfficiency_2D
std::unique_ptr< TH2 > m_convRecoEfficiency_2D
Definition: egammaEnergyCorrectionTool.h:716
egEnergyCorr::ConfigEL
@ ConfigEL
Definition: egammaEnergyCorrectionTool.h:341
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigN
std::unique_ptr< TH2 > m_electronBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:761
AtlasRoot::egammaEnergyCorrectionTool::m_EaccUnconvertedEtaBins
std::unique_ptr< TAxis > m_EaccUnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:700
AtlasRoot::egammaEnergyCorrectionTool::resolution
double resolution(double energy, double cl_eta, double cl_etaCalo, PATCore::ParticleType::Type ptype, bool withCT, bool fast, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
Definition: egammaEnergyCorrectionTool.cxx:2839
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL0
std::unique_ptr< TH1 > m_pedestalL0
Definition: egammaEnergyCorrectionTool.h:705
AtlasRoot::egammaEnergyCorrectionTool::m_daPSCor
std::unique_ptr< TH1 > m_daPSCor
Definition: egammaEnergyCorrectionTool.h:638
egEnergyCorr::Scale::LArCalibExtra2015PreUp
@ LArCalibExtra2015PreUp
Definition: egammaEnergyCorrectionTool.h:165
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigIBL
std::unique_ptr< TH2 > m_convertedBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:774
AtlasRoot::egammaEnergyCorrectionTool::m_useLeakageCorrection
bool m_useLeakageCorrection
Definition: egammaEnergyCorrectionTool.h:809
AtlasRoot::egammaEnergyCorrectionTool::getAlphaConvSyst
double getAlphaConvSyst(double cl_eta, double energy, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4432
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
egEnergyCorr::Resolution::MaterialIBLUp
@ MaterialIBLUp
Definition: egammaEnergyCorrectionTool.h:91
asg::AsgMessaging
Class mimicking the AthMessaging class from the offline software.
Definition: AsgMessaging.h:40
AtlasRoot::egammaEnergyCorrectionTool::m_psUnconvertedGraphs
std::unique_ptr< TList > m_psUnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:680
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
egEnergyCorr::es2016PRE
@ es2016PRE
Definition: egammaEnergyCorrectionTool.h:308
egEnergyCorr::MatID
@ MatID
Definition: egammaEnergyCorrectionTool.h:352
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL2
std::unique_ptr< TH1 > m_pedestalL2
Definition: egammaEnergyCorrectionTool.h:707
egEnergyCorr::es2017_summer_final
@ es2017_summer_final
Definition: egammaEnergyCorrectionTool.h:312
AtlasRoot::egammaEnergyCorrectionTool::getMaterialEffect
double getMaterialEffect(egEnergyCorr::Geometry geo, PATCore::ParticleType::Type ptype, double cl_eta, double ET) const
Definition: egammaEnergyCorrectionTool.cxx:4045
dqt_zlumi_alleff_HIST.B
B
Definition: dqt_zlumi_alleff_HIST.py:110
egGain::GainUncertainty::GainType::LOW
@ LOW
egEnergyCorr::Scale::ADCLinUp
@ ADCLinUp
Definition: egammaEnergyCorrectionTool.h:193
egEnergyCorr::Scale::ZeeAllDown
@ ZeeAllDown
Definition: egammaEnergyCorrectionTool.h:151
egEnergyCorr::Resolution::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:101
egEnergyCorr::Scale::MatPP0Up
@ MatPP0Up
Definition: egammaEnergyCorrectionTool.h:241
egEnergyCorr::es2012XX
@ es2012XX
Definition: egammaEnergyCorrectionTool.h:302
egEnergyCorr::Scale::ADCLinDown
@ ADCLinDown
Definition: egammaEnergyCorrectionTool.h:194
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down
@ S12ExtraLastEtaBinRun2Down
Definition: egammaEnergyCorrectionTool.h:212
egEnergyCorr::ConfigFMX
@ ConfigFMX
Definition: egammaEnergyCorrectionTool.h:342
egEnergyCorr::es2023_R22_Run2_v0
@ es2023_R22_Run2_v0
Definition: egammaEnergyCorrectionTool.h:328
egEnergyCorr::es2012c
@ es2012c
Definition: egammaEnergyCorrectionTool.h:297
egEnergyCorr::Resolution::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:102
egEnergyCorr::Scale::PSb12Down
@ PSb12Down
Definition: egammaEnergyCorrectionTool.h:190
egEnergyCorr::es2017
@ es2017
Definition: egammaEnergyCorrectionTool.h:309
egEnergyCorr::es2018_R21_v1
@ es2018_R21_v1
Definition: egammaEnergyCorrectionTool.h:325
AtlasRoot::egammaEnergyCorrectionTool::m_resSystOFC
std::unique_ptr< TH1 > m_resSystOFC
Definition: egammaEnergyCorrectionTool.h:659
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
AtlasRoot::egammaEnergyCorrectionTool::getSmearingCorrection
double getSmearingCorrection(double eta, double etaCalo, double energy, RandomNumber seed, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, PATCore::ParticleDataType::DataType dataType=PATCore::ParticleDataType::Full, egEnergyCorr::Resolution::Variation value=egEnergyCorr::Resolution::Nominal, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
smearing corrections
Definition: egammaEnergyCorrectionTool.cxx:2971
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_conv
std::unique_ptr< TH2 > m_pp0_conv
Definition: egammaEnergyCorrectionTool.h:726
AtlasRoot::egammaEnergyCorrectionTool::m_matConvertedScale
std::vector< std::unique_ptr< TH1 > > m_matConvertedScale
Definition: egammaEnergyCorrectionTool.h:747
AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainInterpolation
bool m_useL2GainInterpolation
Definition: egammaEnergyCorrectionTool.h:808
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
AtlasRoot::egammaEnergyCorrectionTool::mcSamplingTerm
static double mcSamplingTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2555
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
fast
bool fast
Definition: TrigGlobEffCorrValidation.cxx:190
egEnergyCorr::Scale::LArUnconvCalibDown
@ LArUnconvCalibDown
Definition: egammaEnergyCorrectionTool.h:158
python.PyAthena.v
v
Definition: PyAthena.py:154
egEnergyCorr::Scale::ConvEfficiencyUp
@ ConvEfficiencyUp
Definition: egammaEnergyCorrectionTool.h:252
egEnergyCorr::Scale::PSb12Up
@ PSb12Up
Definition: egammaEnergyCorrectionTool.h:189
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_electron
std::unique_ptr< TH2 > m_G4OverAFII_resolution_electron
Definition: egammaEnergyCorrectionTool.h:787
AtlasRoot::egammaEnergyCorrectionTool::m_getMaterialDelta
std::unique_ptr< get_MaterialResolutionEffect > m_getMaterialDelta
Definition: egammaEnergyCorrectionTool.h:467
egEnergyCorr::Scale::E4ScintillatorDown
@ E4ScintillatorDown
Definition: egammaEnergyCorrectionTool.h:180
AtlasRoot::egammaEnergyCorrectionTool::m_pedestals_es2017
std::unique_ptr< TH1 > m_pedestals_es2017
Definition: egammaEnergyCorrectionTool.h:710
egEnergyCorr::Resolution::MaterialIDDown
@ MaterialIDDown
Definition: egammaEnergyCorrectionTool.h:77
egEnergyCorr::Scale::ConvFakeRateUp
@ ConvFakeRateUp
Definition: egammaEnergyCorrectionTool.h:254
AtlasRoot::egammaEnergyCorrectionTool::m_convRecoEfficiency
std::unique_ptr< TH1 > m_convRecoEfficiency
Definition: egammaEnergyCorrectionTool.h:714
a
TList * a
Definition: liststreamerinfos.cxx:10
egEnergyCorr::Resolution::MaterialIDUp
@ MaterialIDUp
Definition: egammaEnergyCorrectionTool.h:78
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p1_converted_photons
Definition: egammaEnergyCorrectionTool.h:735
AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronEtaBins
std::unique_ptr< TAxis > m_EaccElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:698
egEnergyCorr::Scale::Wtots1Down
@ Wtots1Down
Definition: egammaEnergyCorrectionTool.h:238
egEnergyCorr::Scale::PSUp
@ PSUp
Definition: egammaEnergyCorrectionTool.h:183
h
AtlasRoot::egammaEnergyCorrectionTool::m_peakResMC
std::unique_ptr< TH1 > m_peakResMC
Definition: egammaEnergyCorrectionTool.h:661
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverFrSh
std::unique_ptr< TH1 > m_G4OverFrSh
Definition: egammaEnergyCorrectionTool.h:785
egEnergyCorr::es2017_summer_improved
@ es2017_summer_improved
Definition: egammaEnergyCorrectionTool.h:311
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermCorError
double dataConstantTermCorError(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2661
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
egEnergyCorr::Scale::LArElecCalibDown
@ LArElecCalibDown
Definition: egammaEnergyCorrectionTool.h:160
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom
std::unique_ptr< TH1 > m_zeeNom
Definition: egammaEnergyCorrectionTool.h:643
egEnergyCorr::Scale::ZeeAllUp
@ ZeeAllUp
Definition: egammaEnergyCorrectionTool.h:150
LArCellConditions.geo
bool geo
Definition: LArCellConditions.py:46
AtlasRoot::egammaEnergyCorrectionTool::m_E4UnconvertedGraphs
std::unique_ptr< TList > m_E4UnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:687
egEnergyCorr::es2011dTight
@ es2011dTight
Definition: egammaEnergyCorrectionTool.h:293
egEnergyCorr::Resolution::LastResolutionVariation
@ LastResolutionVariation
Definition: egammaEnergyCorrectionTool.h:105
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
AtlasRoot::egammaEnergyCorrectionTool::m_ADCLinearity_tool
std::shared_ptr< LinearityADC > m_ADCLinearity_tool
Definition: egammaEnergyCorrectionTool.h:465
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_electrons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_electrons
Definition: egammaEnergyCorrectionTool.h:736
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_unconverted
std::unique_ptr< TH1 > m_G4OverAFII_unconverted
Definition: egammaEnergyCorrectionTool.h:781
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
dq_defect_virtual_defect_validation.d2
d2
Definition: dq_defect_virtual_defect_validation.py:81
egEnergyCorr::es2024_Run3_ofc0_v0
@ es2024_Run3_ofc0_v0
Definition: egammaEnergyCorrectionTool.h:329
egEnergyCorr::Resolution::MaterialCaloUp
@ MaterialCaloUp
Definition: egammaEnergyCorrectionTool.h:80
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigPP0
std::unique_ptr< TH2 > m_electronBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:763
AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncAlpha
std::pair< double, double > getAlphaUncAlpha(const TH1 &hh, double cl_eta, double et, bool useInterp) const
Definition: egammaEnergyCorrectionTool.cxx:4390
egEnergyCorr::Resolution::SamplingTermDown
@ SamplingTermDown
Definition: egammaEnergyCorrectionTool.h:73
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p0_converted_photons
Definition: egammaEnergyCorrectionTool.h:734
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_A_data
std::unique_ptr< TH1 > m_wstot_slope_A_data
Definition: egammaEnergyCorrectionTool.h:728
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_electron
std::unique_ptr< TH1 > m_G4OverAFII_electron
Definition: egammaEnergyCorrectionTool.h:779
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_electron_2D
std::unique_ptr< TH2 > m_G4OverAFII_electron_2D
Definition: egammaEnergyCorrectionTool.h:782
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermError
double dataConstantTermError(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2635
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_G4
std::unique_ptr< TH1 > m_dX_IPAcc_G4
Definition: egammaEnergyCorrectionTool.h:669
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:739
egEnergyCorr::Scale::L2MediumGainDown
@ L2MediumGainDown
Definition: egammaEnergyCorrectionTool.h:227
AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainCorrection
bool m_useL2GainCorrection
Definition: egammaEnergyCorrectionTool.h:807
egEnergyCorr::Resolution::MaterialGapDown
@ MaterialGapDown
Definition: egammaEnergyCorrectionTool.h:81
egEnergyCorr::es2017_R21_ofc0_v1
@ es2017_R21_ofc0_v1
Definition: egammaEnergyCorrectionTool.h:322
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermOFCError
double dataConstantTermOFCError(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2639
egEnergyCorr::Scale::ZeePhysUp
@ ZeePhysUp
Definition: egammaEnergyCorrectionTool.h:148
AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedEtaBins
std::unique_ptr< TAxis > m_s12UnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:693
egEnergyCorr::ConfigA
@ ConfigA
Definition: egammaEnergyCorrectionTool.h:339
egEnergyCorr::Scale::EXTRARUN3PREUp
@ EXTRARUN3PREUp
Definition: egammaEnergyCorrectionTool.h:269
AtlasRoot::egammaEnergyCorrectionTool::applyFStoG4
double applyFStoG4(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:3146
egEnergyCorr::Scale::LArTemperature2016PreDown
@ LArTemperature2016PreDown
Definition: egammaEnergyCorrectionTool.h:172
egEnergyCorr::es2022_R22_PRE
@ es2022_R22_PRE
Definition: egammaEnergyCorrectionTool.h:327
egEnergyCorr::Scale::PedestalDown
@ PedestalDown
Definition: egammaEnergyCorrectionTool.h:234
AtlasRoot::egammaEnergyCorrectionTool::m_trkSyst
std::unique_ptr< TH1 > m_trkSyst
Definition: egammaEnergyCorrectionTool.h:635
egEnergyCorr::Scale::ConvRadiusDown
@ ConvRadiusDown
Definition: egammaEnergyCorrectionTool.h:257
egEnergyCorr::Scale::LArCalibDown
@ LArCalibDown
Definition: egammaEnergyCorrectionTool.h:156
PATCore::ParticleType::Electron
@ Electron
Definition: PATCoreEnums.h:40
PATCore::ParticleDataType::FastShower
@ FastShower
Definition: PATCoreEnums.h:22
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigFpMX
std::unique_ptr< TH2 > m_electronBias_ConfigFpMX
Definition: egammaEnergyCorrectionTool.h:760
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2017
std::unique_ptr< TH1 > m_zeeNom_data2017
Definition: egammaEnergyCorrectionTool.h:646
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigN
std::unique_ptr< TH2 > m_convertedBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:773
AtlasRoot::egammaEnergyCorrectionTool::getZeeMeanET
double getZeeMeanET(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2539
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_LAr
std::unique_ptr< TH1 > m_dX_IPAcc_LAr
Definition: egammaEnergyCorrectionTool.h:670
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigEpLp
std::unique_ptr< TH2 > m_electronBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:759
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigIBL
std::unique_ptr< TH2 > m_electronBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:762
plotBeamSpotCompare.histo
histo
Definition: plotBeamSpotCompare.py:415
AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201215
bool m_use_temp_correction201215
Definition: egammaEnergyCorrectionTool.h:812
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigA
std::unique_ptr< TH2 > m_unconvertedBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:764
egEnergyCorr::Scale::MatCryoUp
@ MatCryoUp
Definition: egammaEnergyCorrectionTool.h:217
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronGraphs
std::vector< std::unique_ptr< TList > > m_matElectronGraphs
Definition: egammaEnergyCorrectionTool.h:754
egEnergyCorr::Resolution::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:97
egEnergyCorr::Scale::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:246
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_unconverted_2D
std::unique_ptr< TH2 > m_G4OverAFII_unconverted_2D
Definition: egammaEnergyCorrectionTool.h:784
python.compressB64.c
def c
Definition: compressB64.py:93
egEnergyCorr::es2015_5TeV
@ es2015_5TeV
Definition: egammaEnergyCorrectionTool.h:314
egEnergyCorr::Resolution::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:66
egEnergyCorr::Resolution::MaterialCaloDown
@ MaterialCaloDown
Definition: egammaEnergyCorrectionTool.h:79
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_converted
std::unique_ptr< TH2 > m_G4OverAFII_resolution_converted
Definition: egammaEnergyCorrectionTool.h:789
AtlasRoot::egammaEnergyCorrectionTool::getLayerUncertainty
double getLayerUncertainty(int iLayer, double cl_eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3572
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up
@ S12ExtraLastEtaBinRun2Up
Definition: egammaEnergyCorrectionTool.h:211
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigPP0
std::unique_ptr< TH2 > m_convertedBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:775
AtlasRoot::egammaEnergyCorrectionTool::m_daPSb12
std::unique_ptr< TH1 > m_daPSb12
Definition: egammaEnergyCorrectionTool.h:639
AtlasRoot::egammaEnergyCorrectionTool::getLayerPedestal
double getLayerPedestal(double cl_eta, PATCore::ParticleType::Type ptype, int iLayer, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4579
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
egEnergyCorr::es2018_R21_v0
@ es2018_R21_v0
Definition: egammaEnergyCorrectionTool.h:324
egEnergyCorr::es2015PRE
@ es2015PRE
Definition: egammaEnergyCorrectionTool.h:303
AtlasRoot::egammaEnergyCorrectionTool::m_zeeSyst
std::unique_ptr< TH1 > m_zeeSyst
Definition: egammaEnergyCorrectionTool.h:651
AtlasRoot::egammaEnergyCorrectionTool::dataZPeakResolution
double dataZPeakResolution(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2645
AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncertainty
double getAlphaUncertainty(long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:2455
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
AtlasRoot::egammaEnergyCorrectionTool::getE4Uncertainty
static double getE4Uncertainty(double eta)
Definition: egammaEnergyCorrectionTool.cxx:3467
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_G4
std::unique_ptr< TH1 > m_dX_PSAcc_G4
Definition: egammaEnergyCorrectionTool.h:674
AtlasRoot::egammaEnergyCorrectionTool::get_OFCSyst
double get_OFCSyst(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:5239
egEnergyCorr::Scale::topoClusterThresDown
@ topoClusterThresDown
Definition: egammaEnergyCorrectionTool.h:208
egEnergyCorr::Resolution::MaterialIBLDown
@ MaterialIBLDown
Definition: egammaEnergyCorrectionTool.h:92
AtlasRoot::egammaEnergyCorrectionTool::m_E4ElectronEtaBins
std::unique_ptr< TAxis > m_E4ElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:684
egEnergyCorr::Scale::LArUnconvCalibUp
@ LArUnconvCalibUp
Definition: egammaEnergyCorrectionTool.h:157
AtlasRoot::egammaEnergyCorrectionTool::m_E4ElectronGraphs
std::unique_ptr< TList > m_E4ElectronGraphs
Definition: egammaEnergyCorrectionTool.h:685
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2018
std::unique_ptr< TH1 > m_zeeNom_data2018
Definition: egammaEnergyCorrectionTool.h:647
egEnergyCorr::Resolution::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:65
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_GL1
std::unique_ptr< TH1 > m_dX_IPAcc_GL1
Definition: egammaEnergyCorrectionTool.h:671
Generated on Sun Dec 22 2024 21:56:35 for ATLAS Offline Software by   doxygen 1.8.18