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 362 of file egammaEnergyCorrectionTool.h.

Member Typedef Documentation

◆ RandomNumber

typedef unsigned int AtlasRoot::egammaEnergyCorrectionTool::RandomNumber

Definition at line 365 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/v32/"
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 3040 of file egammaEnergyCorrectionTool.cxx.

3041  {
3042  const double aeta = std::abs(eta);
3043  if (aeta > 2.47)
3044  return 1.;
3045 
3046  if (m_esmodel == egEnergyCorr::es2015PRE or
3047  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3048  m_esmodel == egEnergyCorr::es2015cPRE or
3049  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3050  m_esmodel == egEnergyCorr::es2015c_summer or
3051  m_esmodel == egEnergyCorr::es2016PRE or
3052  m_esmodel == egEnergyCorr::es2017 or
3053  m_esmodel == egEnergyCorr::es2017_summer or
3054  m_esmodel == egEnergyCorr::es2017_summer_improved or
3055  m_esmodel == egEnergyCorr::es2017_summer_final or
3056  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3057  m_esmodel == egEnergyCorr::es2017_R21_v0 or
3058  m_esmodel == egEnergyCorr::es2017_R21_v1 or
3059  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
3060  m_esmodel == egEnergyCorr::es2018_R21_v0 or
3061  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3062  m_esmodel == egEnergyCorr::es2022_R22_PRE or
3063  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
3064 
3065  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
3066  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
3067  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3068  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
3069  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
3070  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
3071  //
3072  // in es02017_R21_v1 : AF2 to FullSim correction is in a 2D eta-Pt
3073  // histogram
3074 
3075  if (ptype == PATCore::ParticleType::Electron) {
3076  return (1. + getValueHistAt(*m_G4OverAFII_electron_2D, aeta, ptGeV,
3077  true, true, true, true));
3078  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3079  return (1. + getValueHistAt(*m_G4OverAFII_converted_2D, aeta, ptGeV,
3080  true, true, true, true));
3081  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3082  return (1. + getValueHistAt(*m_G4OverAFII_unconverted_2D, aeta, ptGeV,
3083  true, true, true, true));
3084  } else {
3085  throw std::runtime_error("particle not valid");
3086  }
3087  } else {
3088  if (ptype == PATCore::ParticleType::Electron) {
3089  return getValueHistoAt(*m_G4OverAFII_electron, aeta);
3090  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3091  return getValueHistoAt(*m_G4OverAFII_converted, aeta);
3092  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3093  return getValueHistoAt(*m_G4OverAFII_unconverted, aeta);
3094  } else {
3095  throw std::runtime_error("particle not valid");
3096  }
3097  }
3098  } else {
3099  // run 1
3100  return m_G4OverAFII_electron->GetBinContent(
3101  std::as_const(*m_G4OverAFII_electron).GetXaxis()->FindBin(eta));
3102  }
3103 }

◆ applyFStoG4()

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

Definition at line 3107 of file egammaEnergyCorrectionTool.cxx.

3107  {
3108 
3109  double aeta = std::abs(eta);
3110  if (aeta < 3.3 || aeta > 4.9)
3111  return 1.;
3112 
3113  return m_G4OverFrSh->GetBinContent(
3114  std::as_const(*m_G4OverFrSh).GetXaxis()->FindBin(aeta));
3115 }

◆ applyMCCalibration()

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

Definition at line 3005 of file egammaEnergyCorrectionTool.cxx.

3006  {
3007 
3008  if (ptype != PATCore::ParticleType::Electron ||
3009  m_esmodel != egEnergyCorr::es2011c)
3010  return 1.;
3011 
3012  double aeta = std::abs(eta);
3013 
3014  if (aeta < 1.42 || aeta > 1.55)
3015  return 1.;
3016 
3017  const int nBoundaries = 18;
3018  double ETBoundaries[nBoundaries] = {0., 5.4, 8.5, 12.9, 16., 20.,
3019  25., 30., 35., 40., 45., 50.,
3020  55., 60., 65., 70., 75., 99999.};
3021 
3022  double CalibFactors[nBoundaries - 1] = {
3023  0.884845, 0.898526, 0.902439, 0.91899, 0.925868, 0.929440,
3024  0.948080, 0.943788, 0.96026, 0.955709, 0.964285, 0.95762,
3025  0.970385, 0.963489, 0.968149, 0.970799, 0.961617};
3026 
3027  int i0 = -1;
3028  for (int i = 0; i < nBoundaries - 1; i++)
3029  if (ET / GeV > ETBoundaries[i] && ET / GeV <= ETBoundaries[i + 1])
3030  i0 = i;
3031 
3032  if (i0 >= 0 && i0 < nBoundaries - 1)
3033  return 1. / CalibFactors[i0];
3034 
3035  return 1.;
3036 }

◆ dataConstantTerm()

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

Definition at line 2596 of file egammaEnergyCorrectionTool.cxx.

2596  {
2597  return std::max(0., m_resNom->GetBinContent(m_resNom->FindFixBin(eta)));
2598 }

◆ dataConstantTermCorError()

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

Definition at line 2626 of file egammaEnergyCorrectionTool.cxx.

2627  {
2628 
2629  double mz = 91.2;
2630 
2631  double resData = dataZPeakResolution(cl_eta);
2632  double resMC = mcZPeakResolution(cl_eta);
2633  double cmc = mcConstantTerm(cl_eta);
2634 
2635  double smpup = 1. + mcSamplingTermRelError(cl_eta);
2636  double smpdo = 1. - mcSamplingTermRelError(cl_eta);
2637 
2638  double central =
2639  sqrt(2 * (resData * resData - resMC * resMC) / mz / mz + cmc * cmc);
2640  double vardown =
2641  sqrt(2 * (resData * resData - resMC * resMC * smpup * smpup) / mz / mz +
2642  cmc * cmc);
2643  double varup =
2644  sqrt(2 * (resData * resData - resMC * resMC * smpdo * smpdo) / mz / mz +
2645  cmc * cmc);
2646 
2647  double errdown = std::abs(central - vardown);
2648  double errup = std::abs(central - varup);
2649 
2650  return .5 * (errup + errdown);
2651 }

◆ dataConstantTermError()

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

Definition at line 2600 of file egammaEnergyCorrectionTool.cxx.

2600  {
2601  return m_resSyst->GetBinContent(m_resSyst->FindFixBin(eta));
2602 }

◆ dataConstantTermOFCError()

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

Definition at line 2604 of file egammaEnergyCorrectionTool.cxx.

2604  {
2605  return m_resSystOFC->GetBinContent(m_resSystOFC->FindFixBin(eta));
2606 }

◆ dataZPeakResolution()

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

Definition at line 2610 of file egammaEnergyCorrectionTool.cxx.

2610  {
2611 
2612  return m_peakResData->GetBinContent(
2613  std::as_const(*m_peakResData).GetXaxis()->FindBin(cl_eta));
2614 }

◆ fcn_sigma()

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

Definition at line 2918 of file egammaEnergyCorrectionTool.cxx.

2920  {
2921 
2922  double sigma2 = std::pow((Cdata + Cdata_er) * energy, 2) +
2923  std::pow(S * (1 + S_er) * std::sqrt(energy), 2);
2924 
2925  double sigma = 0;
2926  if (sigma2 > 0)
2927  sigma = sqrt(sigma2);
2928 
2929  return sigma / energy;
2930 }

◆ get_OFCSyst()

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

Definition at line 5185 of file egammaEnergyCorrectionTool.cxx.

5185  {
5186  const auto ieta = std::as_const(*m_zeeSystOFC).GetXaxis()->FindFixBin(eta);
5187  auto value_histo = m_zeeSystOFC->GetBinContent(ieta);
5188 
5189  return value_histo;
5190 }

◆ get_ZeeStat_eta_axis()

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

Definition at line 5192 of file egammaEnergyCorrectionTool.cxx.

5192  {
5193  return *std::as_const(*m_zeeNom).GetXaxis();
5194 }

◆ get_ZeeSyst()

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

Definition at line 5178 of file egammaEnergyCorrectionTool.cxx.

5178  {
5179  const auto ieta = std::as_const(*m_zeeSyst).GetXaxis()->FindFixBin(eta);
5180  auto value_histo = m_zeeSyst->GetBinContent(ieta);
5181 
5182  return value_histo;
5183 }

◆ 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 4383 of file egammaEnergyCorrectionTool.cxx.

4385  {
4386 
4387  double alpha = 0.;
4388  double aeta = std::abs(cl_eta);
4389  if (aeta > 2.37)
4390  aeta = 2.36;
4391  double ET = energy / std::cosh(cl_eta);
4392 
4393  if (var == egEnergyCorr::Scale::Nominal ||
4394  ptype == PATCore::ParticleType::Electron)
4395  return alpha;
4396 
4397  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4398 
4399  if (var == egEnergyCorr::Scale::ConvEfficiencyUp &&
4400  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4401  alpha = m_convRecoEfficiency->GetBinContent(
4402  m_convRecoEfficiency->FindFixBin(aeta));
4403  else if (var == egEnergyCorr::Scale::ConvEfficiencyDown &&
4404  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4405  alpha = -m_convRecoEfficiency->GetBinContent(
4406  m_convRecoEfficiency->FindFixBin(aeta));
4407  else if (var == egEnergyCorr::Scale::ConvRecoUp &&
4408  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4409  alpha = getInterpolateConvSyst2D(*m_convRecoEfficiency_2D, aeta, ET);
4410  else if (var == egEnergyCorr::Scale::ConvRecoDown &&
4411  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4412  alpha =
4413  -1. * getInterpolateConvSyst2D(*m_convRecoEfficiency_2D, aeta, ET);
4414 
4415  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4416 
4417  if (var == egEnergyCorr::Scale::ConvFakeRateUp &&
4418  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4419  alpha = m_convFakeRate->GetBinContent(m_convFakeRate->FindFixBin(aeta));
4420  else if (var == egEnergyCorr::Scale::ConvFakeRateDown &&
4421  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4422  alpha = -m_convFakeRate->GetBinContent(m_convFakeRate->FindFixBin(aeta));
4423  else if (var == egEnergyCorr::Scale::ConvRecoUp &&
4424  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4425  alpha = getInterpolateConvSyst2D(*m_convFakeRate_2D, aeta, ET);
4426  else if (var == egEnergyCorr::Scale::ConvRecoDown &&
4427  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4428  alpha = -1. * getInterpolateConvSyst2D(*m_convFakeRate_2D, aeta, ET);
4429  else if (var == egEnergyCorr::Scale::ConvRadiusUp)
4430  alpha =
4431  m_convRadius->GetBinContent(m_convRadius->FindFixBin(aeta, ET / GeV));
4432  else if (var == egEnergyCorr::Scale::ConvRadiusDown)
4433  alpha = -m_convRadius->GetBinContent(
4434  m_convRadius->FindFixBin(aeta, ET / GeV));
4435  }
4436 
4437  return alpha * varSF;
4438 }

◆ 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 4230 of file egammaEnergyCorrectionTool.cxx.

4232  {
4233 
4234  double alpha = 0.;
4235  double aeta = std::abs(cl_eta);
4236 
4237  if (var == egEnergyCorr::Scale::Nominal ||
4238  ptype == PATCore::ParticleType::Electron)
4239  return alpha;
4240 
4241  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4242 
4243  if (var == egEnergyCorr::Scale::LeakageUnconvUp) {
4244  alpha = m_leakageUnconverted->GetBinContent(
4245  m_leakageUnconverted->FindFixBin(aeta));
4246  } else if (var == egEnergyCorr::Scale::LeakageUnconvDown) {
4247  alpha = -m_leakageUnconverted->GetBinContent(
4248  m_leakageUnconverted->FindFixBin(aeta));
4249  }
4250 
4251  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4252 
4253  if (var == egEnergyCorr::Scale::LeakageConvUp) {
4254  alpha = m_leakageConverted->GetBinContent(
4255  m_leakageConverted->FindFixBin(aeta));
4256  } else if (var == egEnergyCorr::Scale::LeakageConvDown) {
4257  alpha = -m_leakageConverted->GetBinContent(
4258  m_leakageConverted->FindFixBin(aeta));
4259  }
4260  }
4261 
4262  return alpha * varSF;
4263 }

◆ 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 4265 of file egammaEnergyCorrectionTool.cxx.

4267  {
4268 
4269  // To be on the safe side
4270  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
4271  return getAlphaLeakage(cl_eta, ptype, var, varSF);
4272  }
4273 
4274  // No correction for electron
4275  if (ptype == PATCore::ParticleType::Electron &&
4276  var != egEnergyCorr::Scale::LeakageElecDown &&
4277  var != egEnergyCorr::Scale::LeakageElecUp)
4278  return 0.;
4279 
4280  // Outside acceptance. Should never happen
4281  double aeta = std::abs(cl_eta);
4282  if (aeta > 2.47) {
4283  ATH_MSG_WARNING("Very high |eta| object, eta = " << cl_eta);
4284  return 0.;
4285  }
4286 
4287  // If no correction applied, can only be the egEnergyCorr::Scale::LeakageXXX
4288  // syst
4289  if (!m_useLeakageCorrection && var != egEnergyCorr::Scale::LeakageConvDown &&
4290  var != egEnergyCorr::Scale::LeakageConvUp &&
4291  var != egEnergyCorr::Scale::LeakageUnconvDown &&
4292  var != egEnergyCorr::Scale::LeakageUnconvUp &&
4293  var != egEnergyCorr::Scale::LeakageElecDown &&
4294  var != egEnergyCorr::Scale::LeakageElecUp)
4295  return 0.;
4296 
4297  double etGeV = et / GeV;
4298  double alpha = 0, dalpha = 0;
4299  if (var == egEnergyCorr::Scale::LeakageElecDown ||
4300  var == egEnergyCorr::Scale::LeakageElecUp) {
4301  dalpha = getAlphaUncAlpha(*m_leakageElectron, aeta, etGeV,
4302  m_usepTInterpolationForLeakage)
4303  .first;
4304  if (var == egEnergyCorr::Scale::LeakageElecDown)
4305  dalpha *= -1;
4306  if (ptype == PATCore::ParticleType::Electron)
4307  return dalpha;
4308  }
4309 
4310  bool isConv = ptype == PATCore::ParticleType::ConvertedPhoton;
4311  TH1* hh = isConv ? m_leakageConverted.get() : m_leakageUnconverted.get();
4312  std::pair<double, double> p =
4313  getAlphaUncAlpha(*hh, aeta, etGeV, m_usepTInterpolationForLeakage);
4314 
4315  if (m_useLeakageCorrection) {
4316  alpha = p.first;
4317  }
4318  if ((isConv && (var == egEnergyCorr::Scale::LeakageConvDown ||
4319  var == egEnergyCorr::Scale::LeakageConvUp)) ||
4320  (!isConv && (var == egEnergyCorr::Scale::LeakageUnconvDown ||
4321  var == egEnergyCorr::Scale::LeakageUnconvUp))) {
4322  // If we correct, use uncertainty. Else use full size of the effect
4323  // for es2023_R22_Run2_v0, use full size of correction as uncertainty
4324  if (m_useLeakageCorrection && m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4325  dalpha = p.second;
4326  else
4327  dalpha = alpha;
4328 
4329  if (var == egEnergyCorr::Scale::LeakageConvDown ||
4330  var == egEnergyCorr::Scale::LeakageUnconvDown)
4331  dalpha *= -1;
4332  }
4333  alpha += dalpha;
4334 
4335  ATH_MSG_VERBOSE(
4336  "In leakage2D alpha = " << alpha << " from var = " << variationName(var));
4337 
4338  return alpha * varSF;
4339 }

◆ 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 3907 of file egammaEnergyCorrectionTool.cxx.

3910  {
3911 
3912  double value = 0.;
3913  if (ptype == PATCore::ParticleType::Electron)
3914  return value;
3915  if (var == egEnergyCorr::Scale::Nominal)
3916  return value;
3917 
3918  egEnergyCorr::Geometry geoID, geoCryo, geoCalo, geoGp;
3919  geoID = egEnergyCorr::ConfigA;
3920  if (std::abs(cl_eta) < 2.)
3921  geoCryo = egEnergyCorr::ConfigEL;
3922  else
3923  geoCryo = egEnergyCorr::ConfigFMX;
3924  geoCalo = egEnergyCorr::ConfigFMX;
3925  geoGp = egEnergyCorr::ConfigGp;
3926 
3927  // look up material bias
3928 
3929  double DeltaX = getDeltaX(cl_eta, imat, var) -
3930  getDeltaX(cl_eta, imat, egEnergyCorr::Scale::Nominal);
3931 
3932  // calculate scale change per unit added material
3933 
3934  double DAlphaDXID, DAlphaDXCryo, DAlphaDXCalo, DAlphaDXGp;
3935  DAlphaDXID = DAlphaDXCryo = DAlphaDXCalo = DAlphaDXGp = 0;
3936  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3937  DAlphaDXGp = m_matUnconvertedScale[geoGp]->GetBinContent(
3938  m_matUnconvertedScale[geoGp]->FindBin(cl_eta));
3939  DAlphaDXID = m_matUnconvertedScale[geoID]->GetBinContent(
3940  m_matUnconvertedScale[geoID]->FindBin(cl_eta));
3941  DAlphaDXCryo = m_matUnconvertedScale[geoCryo]->GetBinContent(
3942  m_matUnconvertedScale[geoCryo]->FindBin(cl_eta));
3943  DAlphaDXCalo = m_matUnconvertedScale[geoCalo]->GetBinContent(
3944  m_matUnconvertedScale[geoCalo]->FindBin(cl_eta));
3945  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3946  DAlphaDXGp = m_matConvertedScale[geoGp]->GetBinContent(
3947  m_matConvertedScale[geoGp]->FindBin(cl_eta));
3948  DAlphaDXID = m_matConvertedScale[geoID]->GetBinContent(
3949  m_matConvertedScale[geoID]->FindBin(cl_eta));
3950  DAlphaDXCryo = m_matConvertedScale[geoCryo]->GetBinContent(
3951  m_matConvertedScale[geoCryo]->FindBin(cl_eta));
3952  DAlphaDXCalo = m_matConvertedScale[geoCalo]->GetBinContent(
3953  m_matConvertedScale[geoCalo]->FindBin(cl_eta));
3954  }
3955 
3956  // when in crack, use G', exit
3957 
3958  if (isInCrack(cl_eta)) {
3959  if (imat == egEnergyCorr::MatID && var == egEnergyCorr::Scale::MatIDUp)
3960  value = DAlphaDXGp;
3961  else if (imat == egEnergyCorr::MatID &&
3962  var == egEnergyCorr::Scale::MatIDDown)
3963  value = -DAlphaDXGp;
3964  return value;
3965  }
3966 
3967  // normal case
3968 
3969  int idx = m_matX0Additions[geoID]->FindBin(std::abs(cl_eta));
3970  if (idx < 1 || idx > m_matX0Additions[geoID]->GetNbinsX())
3971  DAlphaDXID = 0;
3972  else
3973  DAlphaDXID /= m_matX0Additions[geoID]->GetBinContent(idx);
3974 
3975  idx = m_matX0Additions[geoCryo]->FindBin(std::abs(cl_eta));
3976  if (idx < 1 || idx > m_matX0Additions[geoCryo]->GetNbinsX())
3977  DAlphaDXCryo = 0;
3978  else
3979  DAlphaDXCryo /= m_matX0Additions[geoCryo]->GetBinContent(idx);
3980 
3981  idx = m_matX0Additions[geoCalo]->FindBin(std::abs(cl_eta));
3982  if (idx < 1 || idx > m_matX0Additions[geoCalo]->GetNbinsX())
3983  DAlphaDXCalo = 0;
3984  else
3985  DAlphaDXCalo /= m_matX0Additions[geoCalo]->GetBinContent(idx);
3986 
3987  // final value
3988 
3989  if (imat == egEnergyCorr::MatID)
3990  value = DeltaX * (DAlphaDXID - DAlphaDXCryo);
3991  else if (imat == egEnergyCorr::MatCryo)
3992  value = DeltaX * DAlphaDXCryo;
3993  else if (imat == egEnergyCorr::MatCalo)
3994  value = DeltaX * DAlphaDXCalo;
3995 
3996  return value * varSF;
3997 }

◆ 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 4480 of file egammaEnergyCorrectionTool.cxx.

4483  {
4484  double alpha = 0.;
4485  if (var == egEnergyCorr::Scale::PedestalUp ||
4486  var == egEnergyCorr::Scale::PedestalDown) {
4487  if (m_esmodel == egEnergyCorr::es2017) {
4488  const double delta =
4489  getValueHistoAt(*m_pedestals_es2017, std::abs(cl_eta));
4490  alpha = delta / (energy / cosh(cl_eta));
4491  if (var == egEnergyCorr::Scale::PedestalDown)
4492  alpha *= -1;
4493  } else if (m_esmodel == egEnergyCorr::es2017_summer or
4494  m_esmodel == egEnergyCorr::es2017_summer_improved or
4495  m_esmodel == egEnergyCorr::es2017_summer_final or
4496  m_esmodel == egEnergyCorr::es2017_R21_PRE or
4497  m_esmodel == egEnergyCorr::es2015_5TeV or
4498  m_esmodel == egEnergyCorr::es2017_R21_v0 or
4499  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4500  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4501  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4502  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4503  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4504  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4505  // Et uncertainty band: 10 MeV for the corrected cluster
4506  alpha = 10. / (energy / cosh(cl_eta));
4507  if (var == egEnergyCorr::Scale::PedestalDown)
4508  alpha *= -1;
4509  } else {
4510  // observed pedestal corrected as a systematic on MC for now.
4511  // TODO : correct for it in the data
4512 
4513  double pedestal = getLayerPedestal(cl_eta, ptype, 0, var, varSF) +
4514  getLayerPedestal(cl_eta, ptype, 1, var, varSF) +
4515  getLayerPedestal(cl_eta, ptype, 2, var, varSF) +
4516  getLayerPedestal(cl_eta, ptype, 3, var, varSF);
4517 
4518  if (isRef)
4519  alpha = pedestal / energy *
4520  1.06; // approximate average ratio between calibrated and raw
4521  else
4522  alpha = pedestal / eraw;
4523  }
4524  }
4525 
4526  return alpha * varSF;
4527 }

◆ getAlphaUncAlpha()

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

Definition at line 4341 of file egammaEnergyCorrectionTool.cxx.

4342  {
4343 
4344  // stay within the histogram limits in pT
4345  // no warning to say the pT is not in the "validity" range...
4346  int ibeta = hh.GetXaxis()->FindBin(aeta);
4347  int nbpT = hh.GetYaxis()->GetNbins();
4348  int ibpT = hh.GetYaxis()->FindBin(et);
4349  bool isOUFlow = false;
4350  if (ibpT > nbpT) {
4351  ibpT = nbpT;
4352  isOUFlow = true;
4353  } else if (ibpT == 0) {
4354  ibpT = 1;
4355  isOUFlow = true;
4356  }
4357  double alpha = 0.;
4358  double pTp = hh.GetYaxis()->GetBinCenter(ibpT), pTn = pTp;
4359  if (!useInterp || isOUFlow || (ibpT == nbpT && et > pTp) ||
4360  (ibpT == 1 && et < pTp))
4361  alpha = hh.GetBinContent(ibeta, ibpT);
4362  else {
4363  int jp = ibpT, jn = ibpT - 1;
4364  if (et > pTp) {
4365  jp = ibpT + 1;
4366  jn = ibpT;
4367  pTn = pTp;
4368  pTp = hh.GetYaxis()->GetBinCenter(jp);
4369  } else {
4370  pTn = hh.GetYaxis()->GetBinCenter(jn);
4371  }
4372  double aPos = hh.GetBinContent(ibeta, jp);
4373  double aNeg = hh.GetBinContent(ibeta, jn);
4374  alpha = (aPos * (et - pTn) + aNeg * (pTp - et)) / (pTp - pTn);
4375  ATH_MSG_VERBOSE("interp et = " << et << " alpha+ = " << aPos << " alpha- = "
4376  << aNeg << " alpha = " << alpha);
4377  }
4378  double dalpha = hh.GetBinError(ibeta, ibpT);
4379 
4380  return std::make_pair(alpha, dalpha);
4381 }

◆ 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 2420 of file egammaEnergyCorrectionTool.cxx.

2423  {
2424 
2425  double alphaNom =
2426  getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy, energyS2, eraw,
2427  ptype, egEnergyCorr::Scale::Nominal);
2428  double alphaVar = 0.;
2429 
2430  if (var != egEnergyCorr::Scale::AllUp &&
2431  var != egEnergyCorr::Scale::AllDown and
2432  var != egEnergyCorr::Scale::AllCorrelatedUp and
2433  var != egEnergyCorr::Scale::AllCorrelatedDown) {
2434  // not an ALLUP
2435  alphaVar = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy, energyS2,
2436  eraw, ptype, var, varSF) -
2437  alphaNom;
2438  } else if (var == egEnergyCorr::Scale::AllUp) {
2439  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatUp;
2440  ivar < egEnergyCorr::Scale::AllUp;
2441  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2442  if (ivar == egEnergyCorr::Scale::ZeeAllUp)
2443  continue;
2444  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2445  energyS2, eraw, ptype, ivar, varSF) -
2446  alphaNom;
2447  ATH_MSG_DEBUG("computing ALLUP, adding " << variationName(ivar) << ": "
2448  << v);
2449  alphaVar += pow(v, 2);
2450  }
2451  alphaVar = sqrt(alphaVar);
2452  } else if (var == egEnergyCorr::Scale::AllDown) {
2453  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatDown;
2454  ivar < egEnergyCorr::Scale::AllDown;
2455  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2456  if (ivar == egEnergyCorr::Scale::ZeeAllDown)
2457  continue;
2458  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2459  energyS2, eraw, ptype, ivar, varSF) -
2460  alphaNom;
2461  ATH_MSG_DEBUG("computing ALLDOWN, adding " << variationName(ivar) << ": "
2462  << v);
2463  alphaVar += pow(v, 2);
2464  }
2465  alphaVar = -sqrt(alphaVar);
2466  } else if (var == egEnergyCorr::Scale::AllCorrelatedUp) {
2467  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatUp;
2468  ivar < egEnergyCorr::Scale::AllUp;
2469  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2470  if (ivar == egEnergyCorr::Scale::ZeeAllUp or
2471  ivar == egEnergyCorr::Scale::LArCalibExtra2015PreUp or
2472  ivar == egEnergyCorr::Scale::LArTemperature2015PreUp or
2473  ivar == egEnergyCorr::Scale::LArTemperature2016PreUp or
2474  ivar == egEnergyCorr::Scale::E4ScintillatorUp)
2475  continue;
2476  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2477  energyS2, eraw, ptype, ivar, varSF) -
2478  alphaNom;
2479  alphaVar += pow(v, 2);
2480  }
2481  alphaVar = sqrt(alphaVar);
2482  } else if (var == egEnergyCorr::Scale::AllCorrelatedDown) {
2483  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatDown;
2484  ivar < egEnergyCorr::Scale::AllDown;
2485  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2486  if (ivar == egEnergyCorr::Scale::ZeeAllDown or
2487  ivar == egEnergyCorr::Scale::LArCalibExtra2015PreDown or
2488  ivar == egEnergyCorr::Scale::LArTemperature2015PreDown or
2489  ivar == egEnergyCorr::Scale::LArTemperature2016PreDown or
2490  ivar == egEnergyCorr::Scale::E4ScintillatorDown)
2491  continue;
2492  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2493  energyS2, eraw, ptype, ivar, varSF) -
2494  alphaNom;
2495  alphaVar += pow(v, 2);
2496  }
2497  alphaVar = -sqrt(alphaVar);
2498  }
2499 
2500  return alphaVar;
2501 }

◆ 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 1992 of file egammaEnergyCorrectionTool.cxx.

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

◆ 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 3119 of file egammaEnergyCorrectionTool.cxx.

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

◆ 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 1872 of file egammaEnergyCorrectionTool.cxx.

1878  {
1879  double fullyCorrectedEnergy = energy;
1880 
1881  // Correct fast sim flavours
1882 
1883  if (dataType == PATCore::ParticleDataType::FastShower) // Frozen shower sim
1884  fullyCorrectedEnergy = energy * this->applyFStoG4(cl_eta);
1885  else if (dataType == PATCore::ParticleDataType::Fast) // AtlFast2 sim
1886  {
1887  fullyCorrectedEnergy =
1888  energy *
1889  this->applyAFtoG4(cl_eta, 0.001 * energy / cosh(cl_eta), ptype);
1890  }
1891 
1892  // If nothing is to be done
1893 
1894  if (scaleVar == egEnergyCorr::Scale::None &&
1895  resVar == egEnergyCorr::Resolution::None)
1896  return fullyCorrectedEnergy;
1897 
1898  ATH_MSG_DEBUG(std::format("after sim fl = {:.2f}", fullyCorrectedEnergy));
1899 
1900  // main E-scale corrections
1901 
1902  if (dataType == PATCore::ParticleDataType::Data) { // ... Data
1903 
1904  if (scaleVar == egEnergyCorr::Scale::Nominal) {
1905  double alpha =
1906  getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, fullyCorrectedEnergy,
1907  energyS2, eraw, ptype, scaleVar, varSF);
1908  fullyCorrectedEnergy /= (1 + alpha);
1909  // apply additional k.E+b corrections if histograms exist (like in
1910  // es2017_R21_v1)
1911  if (m_zeeFwdk && m_zeeFwdb && std::abs(cl_eta) > 2.5) { // calo eta?
1912  int ieta_k = m_zeeFwdk->GetXaxis()->FindFixBin(cl_eta);
1913  double value_k = m_zeeFwdk->GetBinContent(ieta_k);
1914  int ieta_b = m_zeeFwdb->GetXaxis()->FindFixBin(cl_eta);
1915  double value_b = m_zeeFwdb->GetBinContent(ieta_b);
1916  fullyCorrectedEnergy =
1917  value_k * fullyCorrectedEnergy +
1918  value_b * GeV; // value is stored in GeV in the histogram file
1919  }
1920  ATH_MSG_DEBUG(std::format("after alpha = {:.2f}", fullyCorrectedEnergy));
1921  }
1922 
1923  } else { // ... MC
1924 
1925  // Do the energy scale correction (for systematic variations)
1926 
1927  if (scaleVar != egEnergyCorr::Scale::None &&
1928  scaleVar != egEnergyCorr::Scale::Nominal) {
1929  double deltaAlpha = getAlphaUncertainty(runnumber, cl_eta, cl_etaS2, cl_etaCalo,
1930  fullyCorrectedEnergy, energyS2,
1931  eraw, ptype, scaleVar, varSF);
1932  ATH_MSG_DEBUG("alpha sys " << variationName(scaleVar) << " = "
1933  << deltaAlpha);
1934  fullyCorrectedEnergy *= (1 + deltaAlpha);
1935  ATH_MSG_DEBUG(std::format("after mc alpha = {:.2f}", fullyCorrectedEnergy));
1936  }
1937 
1938  // AF2 systematics (this will not be in the sum of all other NP in the 1 NP
1939  // model)
1940  if (dataType == PATCore::ParticleDataType::Fast &&
1941  (m_esmodel == egEnergyCorr::es2017_R21_v0 ||
1942  m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1943  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1944  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1945  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1946  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1947  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
1948  if (scaleVar == egEnergyCorr::Scale::af2Up or
1949  scaleVar == egEnergyCorr::Scale::af2Down) {
1950  double daAF2 = 0.;
1951  if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1952  if (scaleVar == egEnergyCorr::Scale::af2Up)
1953  daAF2 = 0.005;
1954  if (scaleVar == egEnergyCorr::Scale::af2Down)
1955  daAF2 = -0.005;
1956  }
1957  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1958  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1959  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1960  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1961  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1962  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1963  if (scaleVar == egEnergyCorr::Scale::af2Up)
1964  daAF2 = 0.001;
1965  if (scaleVar == egEnergyCorr::Scale::af2Down)
1966  daAF2 = -0.001;
1967  }
1968  fullyCorrectedEnergy *= (1 + daAF2);
1969  }
1970  }
1971 
1972  // Do the resolution correction
1973  if (resVar != egEnergyCorr::Resolution::None)
1974  fullyCorrectedEnergy *=
1975  getSmearingCorrection(cl_eta, cl_etaCalo, fullyCorrectedEnergy,
1976  random_seed, ptype, dataType, resVar, resType);
1977 
1978  ATH_MSG_DEBUG(std::format("after resolution correction = {:.2f}", fullyCorrectedEnergy));
1979  }
1980 
1981  return fullyCorrectedEnergy;
1982 }

◆ 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 1847 of file egammaEnergyCorrectionTool.cxx.

1850  {
1851 
1852  double correctedMomentum = momentum;
1853  double aeta = std::abs(trk_eta);
1854 
1855  if (ptype == PATCore::ParticleType::Electron &&
1856  dataType != PATCore::ParticleDataType::Data) {
1857 
1858  double corr = 0;
1859  if (scaleVar == egEnergyCorr::Scale::MomentumUp)
1860  corr = m_trkSyst->GetBinContent(m_trkSyst->FindFixBin(aeta));
1861  else if (scaleVar == egEnergyCorr::Scale::MomentumDown)
1862  corr = -m_trkSyst->GetBinContent(m_trkSyst->FindFixBin(aeta));
1863 
1864  correctedMomentum *= 1. + corr * varSF;
1865  }
1866 
1867  return correctedMomentum;
1868 }

◆ getDeltaX()

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

Definition at line 3802 of file egammaEnergyCorrectionTool.cxx.

3804  {
3805 
3806  double value = 0.;
3807  double aeta = std::abs(cl_eta);
3808 
3809  // "ID" : inner detector material; bottom-up (from construction/simulation
3810  // accuracy : ConfigA)
3811 
3812  if (imat == egEnergyCorr::MatID && m_dX_ID_Nom) {
3813 
3814  // ... NOTE : watch out here : this histo does not follow the usual
3815  // value/error look-up convention
3816 
3817  if (var == egEnergyCorr::Scale::MatIDUp)
3818  value += m_dX_ID_Nom->GetBinContent(m_dX_ID_Nom->FindFixBin(aeta));
3819  else if (var == egEnergyCorr::Scale::MatIDDown)
3820  value -= m_dX_ID_Nom->GetBinContent(m_dX_ID_Nom->FindFixBin(aeta));
3821 
3822  // "Cryo" : integral from IP to PS or Acc, depending on eta
3823 
3824  } else if (imat == egEnergyCorr::MatCryo && aeta < 1.82 &&
3825  m_dX_IPPS_Nom) { // Integral between IP and PS
3826 
3827  value = m_dX_IPPS_Nom->GetBinContent(m_dX_IPPS_Nom->FindFixBin(aeta));
3828 
3829  if (var == egEnergyCorr::Scale::MatCryoUp)
3830  value += m_dX_IPPS_Nom->GetBinError(m_dX_IPPS_Nom->FindFixBin(aeta));
3831  else if (var == egEnergyCorr::Scale::MatCryoDown)
3832  value -= m_dX_IPPS_Nom->GetBinError(m_dX_IPPS_Nom->FindFixBin(aeta));
3833 
3834  // ... careful : sign below should be opposite to the effect of this source
3835  // on the PS scale!
3836  if (var == egEnergyCorr::Scale::LArElecUnconvUp && m_dX_IPPS_LAr)
3837  value -= m_dX_IPPS_LAr->GetBinContent(m_dX_IPPS_LAr->FindFixBin(aeta));
3838  else if (var == egEnergyCorr::Scale::LArElecUnconvDown && m_dX_IPPS_LAr)
3839  value += m_dX_IPPS_LAr->GetBinContent(m_dX_IPPS_LAr->FindFixBin(aeta));
3840 
3841  } else if (imat == egEnergyCorr::MatCryo && aeta > 1.82 &&
3842  m_dX_IPAcc_Nom) { // Integral between IP and Accordion
3843 
3844  value = m_dX_IPAcc_Nom->GetBinContent(m_dX_IPAcc_Nom->FindFixBin(aeta));
3845 
3846  if (var == egEnergyCorr::Scale::MatCryoUp)
3847  value += m_dX_IPAcc_Nom->GetBinError(m_dX_IPAcc_Nom->FindFixBin(aeta));
3848  else if (var == egEnergyCorr::Scale::MatCryoDown)
3849  value -= m_dX_IPAcc_Nom->GetBinError(m_dX_IPAcc_Nom->FindFixBin(aeta));
3850 
3851  if (var == egEnergyCorr::Scale::LArElecCalibUp && m_dX_IPAcc_LAr)
3852  value += m_dX_IPAcc_LAr->GetBinContent(m_dX_IPAcc_LAr->FindFixBin(aeta));
3853  else if (var == egEnergyCorr::Scale::LArElecCalibDown && m_dX_IPAcc_LAr)
3854  value -= m_dX_IPAcc_LAr->GetBinContent(m_dX_IPAcc_LAr->FindFixBin(aeta));
3855 
3856  if (var == egEnergyCorr::Scale::G4Up && m_dX_IPAcc_G4)
3857  value += m_dX_IPAcc_G4->GetBinContent(m_dX_IPAcc_G4->FindFixBin(aeta));
3858  else if (var == egEnergyCorr::Scale::G4Down && m_dX_IPAcc_G4)
3859  value -= m_dX_IPAcc_G4->GetBinContent(m_dX_IPAcc_G4->FindFixBin(aeta));
3860 
3861  if (var == egEnergyCorr::Scale::L1GainUp && m_dX_IPAcc_GL1)
3862  value += m_dX_IPAcc_GL1->GetBinContent(m_dX_IPAcc_GL1->FindFixBin(aeta));
3863  else if (var == egEnergyCorr::Scale::L1GainDown && m_dX_IPAcc_GL1)
3864  value -= m_dX_IPAcc_GL1->GetBinContent(m_dX_IPAcc_GL1->FindFixBin(aeta));
3865 
3866  // "Calo" : between PS and Strips
3867 
3868  } else if (imat == egEnergyCorr::MatCalo && aeta < 1.82 && m_dX_PSAcc_Nom) {
3869 
3870  value = m_dX_PSAcc_Nom->GetBinContent(m_dX_PSAcc_Nom->FindFixBin(aeta));
3871 
3872  if (var == egEnergyCorr::Scale::MatCaloUp)
3873  value += m_dX_PSAcc_Nom->GetBinError(m_dX_PSAcc_Nom->FindFixBin(aeta));
3874  else if (var == egEnergyCorr::Scale::MatCaloDown)
3875  value -= m_dX_PSAcc_Nom->GetBinError(m_dX_PSAcc_Nom->FindFixBin(aeta));
3876 
3877  if (var == egEnergyCorr::Scale::LArUnconvCalibUp && m_dX_PSAcc_LAr)
3878  value += m_dX_PSAcc_LAr->GetBinContent(m_dX_PSAcc_LAr->FindFixBin(aeta));
3879  else if (var == egEnergyCorr::Scale::LArUnconvCalibDown && m_dX_PSAcc_LAr)
3880  value -= m_dX_PSAcc_LAr->GetBinContent(m_dX_PSAcc_LAr->FindFixBin(aeta));
3881 
3882  if (var == egEnergyCorr::Scale::G4Up && m_dX_PSAcc_G4)
3883  value += m_dX_PSAcc_G4->GetBinContent(m_dX_PSAcc_G4->FindFixBin(aeta));
3884  else if (var == egEnergyCorr::Scale::G4Down && m_dX_PSAcc_G4)
3885  value -= m_dX_PSAcc_G4->GetBinContent(m_dX_PSAcc_G4->FindFixBin(aeta));
3886  }
3887 
3888  return value;
3889 }

◆ getE4NonLinearity()

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

Definition at line 3659 of file egammaEnergyCorrectionTool.cxx.

3660  {
3661  double value = 0;
3662  const double aeta = std::abs(cl_eta);
3663  const double ETGeV = energy / cosh(cl_eta) / 1E3;
3664 
3665  // This will point to the return of get() of a unique_ptr
3666  const TAxis* axis;
3667  const TList* graphs;
3668 
3669  if (ptype == PATCore::ParticleType::Electron) {
3670  axis = m_E4ElectronEtaBins.get();
3671  graphs = m_E4ElectronGraphs.get();
3672  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3673  axis = m_E4UnconvertedEtaBins.get();
3674  graphs = m_E4UnconvertedGraphs.get();
3675  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3676  axis = m_E4ConvertedEtaBins.get();
3677  graphs = m_E4ConvertedGraphs.get();
3678  } else {
3679  ATH_MSG_FATAL("invalid particle type");
3680  return -1;
3681  }
3682 
3683  const int ieta = axis->FindFixBin(aeta) - 1;
3684  if (ieta >= 0 and ieta < graphs->GetSize()) {
3685  value = static_cast<TGraph*>(graphs->At(ieta))->Eval(ETGeV);
3686  }
3687 
3688  return value;
3689 }

◆ getE4Uncertainty()

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

Definition at line 3421 of file egammaEnergyCorrectionTool.cxx.

3421  {
3422  const double aeta = std::abs(eta);
3423  if ((aeta > 1.6) or (aeta < 1.4)) {
3424  return 0.;
3425  }
3426 
3427  // numbers from Archil 20/5/2016
3428 
3429  double data_mc_difference = 0.;
3430  if (aeta < 1.46) {
3431  data_mc_difference = 1E-2;
3432  } // 1.4 - 1.46
3433  else if (aeta < 1.52) {
3434  data_mc_difference = 3E-2;
3435  } // 1.46 - 1.52
3436  else {
3437  data_mc_difference = 4.3E-2;
3438  } // 1.52 - 1.6
3439 
3440  const double em_scale = 2.4E-2;
3441  const double mbias = 1E-2; // Archil presentation 26/5/2016
3442  const double laser = 4E-2;
3443 
3444  return std::sqrt(data_mc_difference * data_mc_difference +
3445  em_scale * em_scale + mbias * mbias + laser * laser);
3446 }

◆ getInterpolateConvSyst2D()

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

Definition at line 4440 of file egammaEnergyCorrectionTool.cxx.

4441  {
4442 
4443  // use one bin in eta and linear interpolation in Et between 2 bins
4444  int ieta = conv_hist.GetXaxis()->FindBin(aeta);
4445 
4446  int ipt = conv_hist.GetYaxis()->FindBin(ET);
4447  double ptBin = conv_hist.GetYaxis()->GetBinCenter(ipt);
4448 
4449  int i1, i2;
4450  double pt1, pt2;
4451  if (ET > ptBin) {
4452  i1 = ipt;
4453  i2 = ipt + 1;
4454  pt1 = ptBin;
4455  pt2 = conv_hist.GetYaxis()->GetBinCenter(i2);
4456  } else {
4457  i1 = ipt - 1;
4458  i2 = ipt;
4459  pt1 = conv_hist.GetYaxis()->GetBinCenter(i1);
4460  pt2 = ptBin;
4461  }
4462 
4463  int nbins = conv_hist.GetYaxis()->GetNbins();
4464  double value = 0;
4465  if (i1 >= 1 && i1 < nbins) {
4466  double v1 = conv_hist.GetBinContent(ieta, i1);
4467  double v2 = conv_hist.GetBinContent(ieta, i2);
4468  value = (v1 * (pt2 - ET) + v2 * (ET - pt1)) / (pt2 - pt1);
4469  } else {
4470  if (ipt < 1)
4471  ipt = 1;
4472  if (ipt > nbins)
4473  ipt = nbins;
4474  value = conv_hist.GetBinContent(ieta, ipt);
4475  }
4476 
4477  return value;
4478 }

◆ getLayerNonLinearity()

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

Definition at line 3691 of file egammaEnergyCorrectionTool.cxx.

3693  {
3694 
3695  double value = 0;
3696  // Accordion histogram specicif condition
3697  if (iLayer == 6 && std::abs(cl_eta) >= 2.47)
3698  cl_eta = 2.46;
3699  double aeta = std::abs(cl_eta);
3700  double ET = energy / cosh(cl_eta);
3701 
3702  // move out of crack
3703  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
3704  aeta = nearestEtaBEC(aeta);
3705 
3706  // argument ET is transverse energy in MeV
3707 
3708  if (iLayer == 0 && aeta >= 1.82)
3709  return value;
3710 
3711  if (ptype == PATCore::ParticleType::Electron) {
3712 
3713  if (iLayer == 0) {
3714 
3715  const int ieta = m_psElectronEtaBins->FindFixBin(aeta) - 1;
3716  if (ieta >= 0 and ieta < m_psElectronGraphs->GetSize()) {
3717  value = ((TF1*)m_psElectronGraphs->At(ieta))->Eval(ET);
3718  }
3719  } else if (iLayer == 1) {
3720 
3721  const int ieta = m_s12ElectronEtaBins->FindFixBin(aeta) - 1;
3722  if (ieta >= 0 and ieta < m_s12ElectronGraphs->GetSize()) {
3723  value = ((TF1*)m_s12ElectronGraphs->At(ieta))->Eval(ET);
3724  }
3725  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3726 
3727  const int ieta = m_EaccElectronEtaBins->FindFixBin(aeta) - 1;
3728  if (ieta >= 0 && ieta < m_EaccElectronGraphs->GetSize()) {
3729  value = ((TF1*)m_EaccElectronGraphs->At(ieta))->Eval(ET);
3730  }
3731  }
3732 
3733  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3734 
3735  if (iLayer == 0) {
3736 
3737  const int ieta = m_psUnconvertedEtaBins->FindFixBin(aeta) - 1;
3738  if (ieta >= 0 and ieta < m_psUnconvertedGraphs->GetSize()) {
3739  value = ((TF1*)m_psUnconvertedGraphs->At(ieta))->Eval(ET);
3740  }
3741 
3742  } else if (iLayer == 1) {
3743 
3744  const int ieta = m_s12UnconvertedEtaBins->FindFixBin(aeta) - 1;
3745  if (ieta >= 0 and ieta < m_s12UnconvertedGraphs->GetSize()) {
3746  value = ((TF1*)m_s12UnconvertedGraphs->At(ieta))->Eval(ET);
3747  }
3748  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3749 
3750  const int ieta = m_EaccUnconvertedEtaBins->FindFixBin(aeta) - 1;
3751  if (ieta >= 0 && ieta < m_EaccUnconvertedGraphs->GetSize()) {
3752  value = ((TF1*)m_EaccUnconvertedGraphs->At(ieta))->Eval(ET);
3753  }
3754  }
3755 
3756  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3757 
3758  if (iLayer == 0) {
3759 
3760  const int ieta = m_psConvertedEtaBins->FindFixBin(aeta) - 1;
3761  if (ieta >= 0 and ieta < m_psConvertedGraphs->GetSize()) {
3762  value = ((TF1*)m_psConvertedGraphs->At(ieta))->Eval(ET);
3763  }
3764 
3765  } else if (iLayer == 1) {
3766 
3767  const int ieta = m_s12ConvertedEtaBins->FindFixBin(aeta) - 1;
3768  if (ieta >= 0 and ieta < m_s12ConvertedGraphs->GetSize()) {
3769  value = ((TF1*)m_s12ConvertedGraphs->At(ieta))->Eval(ET);
3770  }
3771  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3772 
3773  const int ieta = m_EaccConvertedEtaBins->FindFixBin(aeta) - 1;
3774  if (ieta >= 0 && ieta < m_EaccConvertedGraphs->GetSize()) {
3775  if (ET < 10000. && (aeta < 1.2 || (aeta >= 1.59 && aeta < 1.73))) {
3776  // harcoded condition to correct bad beahviour of function at low ET
3777  // <10GeV
3778  value = ((TF1*)m_EaccConvertedGraphs->At(ieta))->Eval(10000.);
3779  } else {
3780  value = ((TF1*)m_EaccConvertedGraphs->At(ieta))->Eval(ET);
3781  }
3782  }
3783  }
3784  }
3785 
3786  ATH_MSG_DEBUG("Layer non-linearity: " << iLayer << " value: " << value);
3787 
3788  if (value < 0) {
3789  ATH_MSG_DEBUG("Value is negative -> set to 0");
3790  value = 0;
3791  }
3792 
3793  return value;
3794 }

◆ 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 4529 of file egammaEnergyCorrectionTool.cxx.

4531  {
4532 
4533  double pedestal = 0.;
4534  double aeta = std::abs(cl_eta);
4535 
4536  if (var == egEnergyCorr::Scale::PedestalUp ||
4537  var == egEnergyCorr::Scale::PedestalDown) {
4538 
4539  if (iLayer == 0)
4540  pedestal = m_pedestalL0->GetBinContent(m_pedestalL0->FindFixBin(aeta));
4541  else if (iLayer == 1)
4542  pedestal = m_pedestalL1->GetBinContent(m_pedestalL1->FindFixBin(aeta));
4543  else if (iLayer == 2)
4544  pedestal = m_pedestalL2->GetBinContent(m_pedestalL2->FindFixBin(aeta));
4545  else if (iLayer == 3)
4546  pedestal = m_pedestalL3->GetBinContent(m_pedestalL3->FindFixBin(aeta));
4547 
4548  if (ptype == PATCore::ParticleType::UnconvertedPhoton && aeta < 1.4) {
4549  if (iLayer <= 1)
4550  pedestal /= 1.5;
4551  else if (iLayer == 2)
4552  pedestal *= 15. / 21.;
4553  }
4554 
4555  if (var == egEnergyCorr::Scale::PedestalDown)
4556  pedestal *= -1.;
4557  }
4558 
4559  return pedestal * varSF;
4560 }

◆ 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 3526 of file egammaEnergyCorrectionTool.cxx.

3528  {
3529 
3530  double value = 0.;
3531 
3532  if (var == egEnergyCorr::Scale::Nominal)
3533  return value;
3534 
3535  // nearest eta outside of crack (for PS scale values and uncertainties)
3536  double nearestEta = cl_eta;
3537  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
3538  nearestEta = nearestEtaBEC(cl_eta);
3539 
3540  if (iLayer == 0) { // use nearestEta
3541 
3542  if (var == egEnergyCorr::Scale::PSUp && m_aPSNom)
3543  value = m_aPSNom->GetBinError(m_aPSNom->FindFixBin(nearestEta));
3544 
3545  else if (var == egEnergyCorr::Scale::PSDown && m_aPSNom)
3546  value = -m_aPSNom->GetBinError(m_aPSNom->FindFixBin(nearestEta));
3547 
3548  else if (var == egEnergyCorr::Scale::PSb12Up && m_daPSb12)
3549  value = m_daPSb12->GetBinContent(m_daPSb12->FindFixBin(nearestEta));
3550 
3551  else if (var == egEnergyCorr::Scale::PSb12Down && m_daPSb12)
3552  value = -m_daPSb12->GetBinContent(m_daPSb12->FindFixBin(nearestEta));
3553 
3554  else if (var == egEnergyCorr::Scale::LArElecUnconvUp && m_daPSCor)
3555  value = m_daPSCor->GetBinContent(m_daPSCor->FindFixBin(nearestEta));
3556 
3557  else if (var == egEnergyCorr::Scale::LArElecUnconvDown && m_daPSCor)
3558  value = -m_daPSCor->GetBinContent(m_daPSCor->FindFixBin(nearestEta));
3559 
3560  }
3561 
3562  else if (iLayer == 1) { // use cl_eta
3563 
3564  if (var == egEnergyCorr::Scale::S12Up && m_aS12Nom) {
3565  value = m_aS12Nom->GetBinError(m_aS12Nom->FindFixBin(cl_eta));
3566  } else if (var == egEnergyCorr::Scale::S12Down && m_aS12Nom) {
3567  value = -m_aS12Nom->GetBinError(m_aS12Nom->FindFixBin(cl_eta));
3568  } else if (var == egEnergyCorr::Scale::LArCalibUp && m_daS12Cor) {
3569  value = m_daS12Cor->GetBinContent(m_daS12Cor->FindFixBin(cl_eta));
3570  } else if (var == egEnergyCorr::Scale::LArCalibDown && m_daS12Cor) {
3571  value = -m_daS12Cor->GetBinContent(m_daS12Cor->FindFixBin(cl_eta));
3572  } else if (var == egEnergyCorr::Scale::LArCalibExtra2015PreUp and
3573  (m_esmodel == egEnergyCorr::es2015PRE or
3574  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3575  m_esmodel == egEnergyCorr::es2015cPRE or
3576  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3577  m_esmodel == egEnergyCorr::es2015c_summer or
3578  m_esmodel == egEnergyCorr::es2016PRE or
3579  m_esmodel == egEnergyCorr::es2017 or
3580  m_esmodel == egEnergyCorr::es2017_summer or
3581  m_esmodel == egEnergyCorr::es2017_summer_improved or
3582  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3583  m_esmodel == egEnergyCorr::es2015_5TeV)) {
3584  // special case for es2015PRE and also for es2015c_summer and also for
3585  // es2017 numbers from Lydia and Christophe,
3586  // https://indico.cern.ch/event/395345/contribution/2/material/slides/0.pdf
3587  // assuming constant uncertainty
3588  // es2017_summer: increased to 5% in the endcap
3589  const double aeta = std::abs(cl_eta);
3590  // endcap
3591  if (aeta >= 1.37 and aeta < 2.5) {
3592  if (m_esmodel == egEnergyCorr::es2017_summer or
3593  m_esmodel == egEnergyCorr::es2017_summer_improved or
3594  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3595  m_esmodel == egEnergyCorr::es2015_5TeV)
3596  value = 5.0E-2;
3597  else
3598  value = 1.5E-2;
3599  } else { // barrel
3600  if (m_esmodel == egEnergyCorr::es2017_summer_improved)
3601  value = 2.5E-2;
3602  else
3603  value = 1.5E-2;
3604  }
3605  } else if (var == egEnergyCorr::Scale::LArCalibExtra2015PreDown and
3606  (m_esmodel == egEnergyCorr::es2015PRE or
3607  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3608  m_esmodel == egEnergyCorr::es2015cPRE or
3609  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3610  m_esmodel == egEnergyCorr::es2015c_summer or
3611  m_esmodel == egEnergyCorr::es2016PRE or
3612  m_esmodel == egEnergyCorr::es2017 or
3613  m_esmodel == egEnergyCorr::es2017_summer or
3614  m_esmodel == egEnergyCorr::es2017_summer_improved or
3615  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3616  m_esmodel == egEnergyCorr::es2015_5TeV)) {
3617  const double aeta = std::abs(cl_eta);
3618  // endcap
3619  if (aeta >= 1.37 and aeta < 2.5) {
3620  if (m_esmodel == egEnergyCorr::es2017_summer or
3621  m_esmodel == egEnergyCorr::es2017_summer_improved or
3622  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3623  m_esmodel == egEnergyCorr::es2015_5TeV)
3624  value = -5.0E-2;
3625  else
3626  value = -1.5E-2;
3627  } else { // barrel
3628  if (m_esmodel == egEnergyCorr::es2017_summer_improved or
3629  m_esmodel == egEnergyCorr::es2015_5TeV)
3630  value = -2.5E-2;
3631  else
3632  value = -1.5E-2;
3633  }
3634  }
3635 
3636  else if (var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up or
3637  var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down) {
3638  // special large sys for run2 in the last eta-bin in es2017, see
3639  // ATLASEG-42
3640  if (m_esmodel == egEnergyCorr::es2017 or
3641  m_esmodel == egEnergyCorr::es2017_summer or
3642  m_esmodel == egEnergyCorr::es2017_summer_improved or
3643  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3644  m_esmodel == egEnergyCorr::es2015_5TeV) {
3645  const double aeta = std::abs(cl_eta);
3646  if (aeta >= 2.4 and aeta < 2.5) {
3647  if (var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up)
3648  value = 25E-2;
3649  else
3650  value = -25E-2;
3651  }
3652  }
3653  }
3654  }
3655 
3656  return value * varSF;
3657 }

◆ getMaterialEffect()

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

Definition at line 3999 of file egammaEnergyCorrectionTool.cxx.

4001  {
4002 
4003  // Again this does no need to be ptr just get the one owned
4004  TH2D* hmat;
4005 
4006  if (ptype == PATCore::ParticleType::Electron) {
4007  if (geo == egEnergyCorr::ConfigA)
4008  hmat = ((TH2D*)m_electronBias_ConfigA.get());
4009  else if (geo == egEnergyCorr::ConfigEL)
4010  hmat = ((TH2D*)m_electronBias_ConfigEpLp.get());
4011  else if (geo == egEnergyCorr::ConfigFMX)
4012  hmat = ((TH2D*)m_electronBias_ConfigFpMX.get());
4013  else if (geo == egEnergyCorr::ConfigN)
4014  hmat = ((TH2D*)m_electronBias_ConfigN.get());
4015  else if (geo == egEnergyCorr::ConfigIBL)
4016  hmat = ((TH2D*)m_electronBias_ConfigIBL.get());
4017  else if (geo == egEnergyCorr::ConfigPP0)
4018  hmat = ((TH2D*)m_electronBias_ConfigPP0.get());
4019  else
4020  return 0;
4021  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4022  if (geo == egEnergyCorr::ConfigA)
4023  hmat = ((TH2D*)m_unconvertedBias_ConfigA.get());
4024  else if (geo == egEnergyCorr::ConfigEL)
4025  hmat = ((TH2D*)m_unconvertedBias_ConfigEpLp.get());
4026  else if (geo == egEnergyCorr::ConfigFMX)
4027  hmat = ((TH2D*)m_unconvertedBias_ConfigFpMX.get());
4028  else if (geo == egEnergyCorr::ConfigN)
4029  hmat = ((TH2D*)m_unconvertedBias_ConfigN.get());
4030  else if (geo == egEnergyCorr::ConfigIBL)
4031  hmat = ((TH2D*)m_unconvertedBias_ConfigIBL.get());
4032  else if (geo == egEnergyCorr::ConfigPP0)
4033  hmat = ((TH2D*)m_unconvertedBias_ConfigIBL.get());
4034  else
4035  return 0;
4036  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4037  if (geo == egEnergyCorr::ConfigA)
4038  hmat = ((TH2D*)m_convertedBias_ConfigA.get());
4039  else if (geo == egEnergyCorr::ConfigEL)
4040  hmat = ((TH2D*)m_convertedBias_ConfigEpLp.get());
4041  else if (geo == egEnergyCorr::ConfigFMX)
4042  hmat = ((TH2D*)m_convertedBias_ConfigFpMX.get());
4043  else if (geo == egEnergyCorr::ConfigN)
4044  hmat = ((TH2D*)m_convertedBias_ConfigN.get());
4045  else if (geo == egEnergyCorr::ConfigIBL)
4046  hmat = ((TH2D*)m_convertedBias_ConfigIBL.get());
4047  else if (geo == egEnergyCorr::ConfigPP0)
4048  hmat = ((TH2D*)m_convertedBias_ConfigPP0.get());
4049  else
4050  return 0;
4051  } else
4052  return 0;
4053 
4054  // use one bin in eta and linear interpolation in Et between 2 bins
4055 
4056  double aeta = std::abs(cl_eta);
4057  int ieta = hmat->GetXaxis()->FindBin(aeta);
4058 
4059  int ipt = hmat->GetYaxis()->FindBin(ET);
4060  double ptBin = hmat->GetYaxis()->GetBinCenter(ipt);
4061 
4062  int i1, i2;
4063  double pt1, pt2;
4064  if (ET > ptBin) {
4065  i1 = ipt;
4066  i2 = ipt + 1;
4067  pt1 = ptBin;
4068  pt2 = hmat->GetYaxis()->GetBinCenter(i2);
4069  } else {
4070  i1 = ipt - 1;
4071  i2 = ipt;
4072  pt1 = hmat->GetYaxis()->GetBinCenter(i1);
4073  pt2 = ptBin;
4074  }
4075 
4076  int nbins = hmat->GetYaxis()->GetNbins();
4077  double value = 0;
4078  if (i1 >= 1 && i1 < nbins) {
4079  double v1 = hmat->GetBinContent(ieta, i1);
4080  double v2 = hmat->GetBinContent(ieta, i2);
4081  value = (v1 * (pt2 - ET) + v2 * (ET - pt1)) / (pt2 - pt1);
4082  } else {
4083  if (ipt < 1)
4084  ipt = 1;
4085  if (ipt > nbins)
4086  ipt = nbins;
4087  value = hmat->GetBinContent(ieta, ipt);
4088  }
4089  return value;
4090 }

◆ 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 4094 of file egammaEnergyCorrectionTool.cxx.

4097  {
4098 
4099  double value = 0;
4100  double ET = energy / cosh(cl_eta) / GeV;
4101 
4102  if ((ptype != PATCore::ParticleType::Electron &&
4103  (m_esmodel != egEnergyCorr::es2017_R21_v1 &&
4104  m_esmodel != egEnergyCorr::es2017_R21_ofc0_v1 &&
4105  m_esmodel != egEnergyCorr::es2018_R21_v0 &&
4106  m_esmodel != egEnergyCorr::es2018_R21_v1 &&
4107  m_esmodel != egEnergyCorr::es2022_R22_PRE &&
4108  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)) ||
4109  var == egEnergyCorr::Scale::Nominal)
4110  return value;
4111 
4112  egEnergyCorr::Geometry geoID, geoCryo, geoCalo, geoGp;
4113  geoID = egEnergyCorr::ConfigA;
4114  if (std::abs(cl_eta) < 2.)
4115  geoCryo = egEnergyCorr::ConfigEL;
4116  else
4117  geoCryo = egEnergyCorr::ConfigFMX;
4118 
4119  // G.Unal 21.08.2018
4120  // for Calo material use correctly ConfigN material for endcap (PS to Calo) in
4121  // release 21 (not done for run 1, which used FMX in this case)
4122  if (std::abs(cl_eta) > 1.52 &&
4123  (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4124  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4125  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4126  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4127  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4128  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0))
4129  geoCalo = egEnergyCorr::ConfigN;
4130  else
4131  geoCalo = egEnergyCorr::ConfigFMX;
4132  geoGp = egEnergyCorr::ConfigGp;
4133 
4134  // look up material bias
4135 
4136  double DeltaX = getDeltaX(cl_eta, imat, var) -
4137  getDeltaX(cl_eta, imat, egEnergyCorr::Scale::Nominal);
4138 
4139  // calculate scale change per unit added material
4140 
4141  // G.Unal 21.08.2019 new code called for release 21 sensivitities
4142 
4143  double DAlphaDXGp, DAlphaDXID, DAlphaDXCryo, DAlphaDXCalo;
4144 
4145  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4146  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4147  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4148  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4149  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4150  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4151  DAlphaDXGp =
4152  getMaterialEffect(egEnergyCorr::ConfigFMX, ptype, cl_eta,
4153  ET); // no G' in release 21, use FMX for the crack
4154  DAlphaDXID = getMaterialEffect(geoID, ptype, cl_eta, ET);
4155  DAlphaDXCryo = getMaterialEffect(geoCryo, ptype, cl_eta, ET);
4156  DAlphaDXCalo = getMaterialEffect(geoCalo, ptype, cl_eta, ET);
4157 
4158  } else {
4159  int ialpha = m_matElectronEtaBins->FindFixBin(std::abs(cl_eta)) - 1;
4160  if (ialpha < 0 || ialpha >= m_matElectronGraphs[geoGp]->GetSize())
4161  return 0.;
4162 
4163  DAlphaDXGp = ((TGraphErrors*)m_matElectronGraphs[geoGp]->At(ialpha))
4164  ->GetFunction("fNonLin")
4165  ->Eval(ET);
4166  DAlphaDXID = ((TGraphErrors*)m_matElectronGraphs[geoID]->At(ialpha))
4167  ->GetFunction("fNonLin")
4168  ->Eval(ET);
4169  DAlphaDXCryo = ((TGraphErrors*)m_matElectronGraphs[geoCryo]->At(ialpha))
4170  ->GetFunction("fNonLin")
4171  ->Eval(ET);
4172  DAlphaDXCalo = ((TGraphErrors*)m_matElectronGraphs[geoCalo]->At(ialpha))
4173  ->GetFunction("fNonLin")
4174  ->Eval(ET);
4175  }
4176 
4177  // when in crack, use G', exit
4178 
4179  if (isInCrack(cl_eta)) {
4180  if (imat == egEnergyCorr::MatID && var == egEnergyCorr::Scale::MatIDUp)
4181  value = DAlphaDXGp;
4182  else if (imat == egEnergyCorr::MatID &&
4183  var == egEnergyCorr::Scale::MatIDDown)
4184  value = -DAlphaDXGp;
4185  return value;
4186  }
4187 
4188  int idx = m_matX0Additions[geoID]->FindBin(std::abs(cl_eta));
4189  if (idx < 1 || idx > m_matX0Additions[geoID]->GetNbinsX())
4190  DAlphaDXID = 0;
4191  else {
4192  if (m_matX0Additions[geoID]->GetBinContent(idx) > 0.)
4193  DAlphaDXID /= m_matX0Additions[geoID]->GetBinContent(idx);
4194  else
4195  DAlphaDXID = 0.;
4196  }
4197 
4198  idx = m_matX0Additions[geoCryo]->FindBin(std::abs(cl_eta));
4199  if (idx < 1 || idx > m_matX0Additions[geoCryo]->GetNbinsX())
4200  DAlphaDXCryo = 0;
4201  else {
4202  if (m_matX0Additions[geoCryo]->GetBinContent(idx) > 0.)
4203  DAlphaDXCryo /= m_matX0Additions[geoCryo]->GetBinContent(idx);
4204  else
4205  DAlphaDXCryo = 0.;
4206  }
4207 
4208  idx = m_matX0Additions[geoCalo]->FindBin(std::abs(cl_eta));
4209  if (idx < 1 || idx > m_matX0Additions[geoCalo]->GetNbinsX())
4210  DAlphaDXCalo = 0;
4211  else {
4212  if (m_matX0Additions[geoCalo]->GetBinContent(idx) > 0.)
4213  DAlphaDXCalo /= m_matX0Additions[geoCalo]->GetBinContent(idx);
4214  else
4215  DAlphaDXCalo = 0.;
4216  }
4217 
4218  // final value
4219 
4220  if (imat == egEnergyCorr::MatID)
4221  value = DeltaX * (DAlphaDXID - DAlphaDXCryo);
4222  else if (imat == egEnergyCorr::MatCryo)
4223  value = DeltaX * DAlphaDXCryo;
4224  else if (imat == egEnergyCorr::MatCalo)
4225  value = DeltaX * DAlphaDXCalo;
4226 
4227  return value * varSF;
4228 }

◆ 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 4624 of file egammaEnergyCorrectionTool.cxx.

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

◆ 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 2655 of file egammaEnergyCorrectionTool.cxx.

2661 {
2662 
2663  int eg_resolution_ptype;
2664  if (ptype == PATCore::ParticleType::Electron)
2665  eg_resolution_ptype = 0;
2666  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2667  eg_resolution_ptype = 1;
2668  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2669  eg_resolution_ptype = 2;
2670  else
2671  return -1;
2672 
2673  int isys = 0;
2674  if (value == egEnergyCorr::Resolution::AllUp ||
2675  value == egEnergyCorr::Resolution::AllDown) {
2676  isys = 0xFFFF;
2677  }
2678  if (value == egEnergyCorr::Resolution::ZSmearingUp ||
2679  value == egEnergyCorr::Resolution::ZSmearingDown) {
2680  isys = 0x1;
2681  }
2682  if (value == egEnergyCorr::Resolution::SamplingTermUp ||
2683  value == egEnergyCorr::Resolution::SamplingTermDown) {
2684  isys = 0x2;
2685  }
2686  if (value == egEnergyCorr::Resolution::MaterialIDUp ||
2687  value == egEnergyCorr::Resolution::MaterialIDDown) {
2688  isys = 0x4;
2689  }
2690  if (value == egEnergyCorr::Resolution::MaterialCaloUp ||
2691  value == egEnergyCorr::Resolution::MaterialCaloDown) {
2692  isys = 0x8;
2693  }
2694  if (value == egEnergyCorr::Resolution::MaterialGapUp ||
2695  value == egEnergyCorr::Resolution::MaterialGapDown) {
2696  isys = 0x10;
2697  }
2698  if (value == egEnergyCorr::Resolution::MaterialCryoUp ||
2699  value == egEnergyCorr::Resolution::MaterialCryoDown) {
2700  isys = 0x20;
2701  }
2702  if (value == egEnergyCorr::Resolution::PileUpUp ||
2703  value == egEnergyCorr::Resolution::PileUpDown) {
2704  isys = 0x40;
2705  }
2706 
2707  if (value == egEnergyCorr::Resolution::MaterialIBLUp ||
2708  value == egEnergyCorr::Resolution::MaterialIBLDown) {
2709  isys = 0x80;
2710  }
2711  if (value == egEnergyCorr::Resolution::MaterialPP0Up ||
2712  value == egEnergyCorr::Resolution::MaterialPP0Down) {
2713  isys = 0x100;
2714  }
2715  if (value == egEnergyCorr::Resolution::af2Up ||
2716  value == egEnergyCorr::Resolution::af2Down) {
2717  isys = 0x200;
2718  }
2719  if (value == egEnergyCorr::Resolution::OFCUp ||
2720  value == egEnergyCorr::Resolution::OFCDown) {
2721  isys = 0x400;
2722  }
2723 
2724  double sign = 1.;
2725  if (value == egEnergyCorr::Resolution::AllDown ||
2726  value == egEnergyCorr::Resolution::ZSmearingDown ||
2727  value == egEnergyCorr::Resolution::SamplingTermDown ||
2728  value == egEnergyCorr::Resolution::MaterialIDDown ||
2729  value == egEnergyCorr::Resolution::MaterialGapDown ||
2730  value == egEnergyCorr::Resolution::MaterialCaloDown ||
2731  value == egEnergyCorr::Resolution::MaterialCryoDown ||
2732  value == egEnergyCorr::Resolution::PileUpDown ||
2733  value == egEnergyCorr::Resolution::MaterialIBLDown ||
2734  value == egEnergyCorr::Resolution::MaterialPP0Down ||
2735  value == egEnergyCorr::Resolution::af2Down ||
2736  value == egEnergyCorr::Resolution::OFCDown)
2737  sign = -1.;
2738 
2739  double resolution;
2740  double resolution_error;
2741  double resolution_error_up;
2742  double resolution_error_down;
2743 
2744  getResolution_systematics(eg_resolution_ptype, energy, eta, etaCalo, isys,
2745  resolution, resolution_error, resolution_error_up,
2746  resolution_error_down, resType,
2747  dataType == PATCore::ParticleDataType::Fast);
2748 
2749  // total resolution uncertainty
2750  if (value == egEnergyCorr::Resolution::AllUp ||
2751  value == egEnergyCorr::Resolution::AllDown) {
2752  resolution_error = resolution_error / resolution * sign;
2753  } else {
2754  if (sign == 1)
2755  resolution_error = resolution_error_up / resolution;
2756  else
2757  resolution_error = resolution_error_down / resolution;
2758  }
2759 
2760  return resolution_error;
2761 }

◆ 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 2934 of file egammaEnergyCorrectionTool.cxx.

2939  {
2940 
2941  if (dataType == PATCore::ParticleDataType::Data) {
2942  ATH_MSG_FATAL("Trying to compute smearing correction on data");
2943  }
2944 
2945  if (value == egEnergyCorr::Resolution::None || energy <= 0.)
2946  return 1.0;
2947 
2948  const double energyGeV = energy / GeV;
2949 
2950  // relative resolutions
2951  const double resMC =
2952  resolution(energy, cl_eta, cl_etaCalo, ptype, false, // no additional CT
2953  dataType == PATCore::ParticleDataType::Fast, resType);
2954  double resData =
2955  resolution(energy, cl_eta, cl_etaCalo, ptype, true, // with additional CT
2956  false, resType); // on top of Full simulation
2957 
2958  ATH_MSG_DEBUG("resolution in data: " << resData << " in MC: " << resMC);
2959 
2960  if (m_use_new_resolution_model) {
2961  resData *= 1 + getResolutionError(dataType, energy, cl_eta, cl_etaCalo,
2962  ptype, value, resType);
2963  } else { // OLD model
2964  double errUp, errDown;
2965  resolutionError(energyGeV, cl_eta, errUp, errDown);
2966  if (value == egEnergyCorr::Resolution::AllDown)
2967  resData += errDown;
2968  else if (value == egEnergyCorr::Resolution::AllUp)
2969  resData += errUp;
2970  else if (value != egEnergyCorr::Resolution::Nominal) {
2971  // std::cout << "getSmearingCorrection : wrong value, return 1" <<
2972  // std::endl;
2973  return 1.0;
2974  }
2975  }
2976 
2977  ATH_MSG_DEBUG("resolution in data after systematics: " << resData);
2978 
2979  const double sigma2 =
2980  std::pow(resData * energyGeV, 2) - std::pow(resMC * energyGeV, 2);
2981 
2982  // TODO: for nominal case it can be simplified to:
2983  // const double sigma = dataConstantTerm(m_use_etaCalo_scales ? cl_etaCalo :
2984  // cl_eta) * energyGeV; which is just the additional constant term
2985  if (sigma2 <= 0) {
2986  return 1;
2987  }
2988 
2989  const double sigma = sqrt(sigma2);
2990 
2991  TRandom3 rng(seed);
2992 
2993  const double DeltaE0 = rng.Gaus(0, sigma);
2994  const double cor0 = (energyGeV + DeltaE0) / energyGeV;
2995 
2996  ATH_MSG_DEBUG("sigma|DeltaE0|cor0|seed = " << sigma << "|" << DeltaE0 << "|"
2997  << cor0 << "|" << rng.GetSeed());
2998 
2999  return cor0; // TODO: why not returning DeltaE0 and apply E -> E + DeltaE0 ?
3000 }

◆ getWtots1Uncertainty()

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

Definition at line 3448 of file egammaEnergyCorrectionTool.cxx.

3449  {
3450  double value = 0;
3451 
3452  // Get slopes and wstot values
3453  // deltaE/E (Et, particle type ) = 2*A/mZ * ( wstot(Et,particle type)_data -
3454  // <wstot(40 GeV Et electrons)_data)> ) - 2*B/mZ* (wstot(Et,particle type)_MC
3455  // - <w wstot(40 GeV Et electrons)_MC>) factor 2 to go from slopes in dM/M to
3456  // dE/E
3457 
3458  //|eta|>2.4 => use last eta bin
3459  if (cl_eta < -2.4)
3460  cl_eta = -2.35;
3461  if (cl_eta > 2.4)
3462  cl_eta = 2.35;
3463 
3464  int bin = m_wstot_slope_A_data->FindFixBin(cl_eta);
3465  double A = m_wstot_slope_A_data->GetBinContent(bin);
3466  double B = m_wstot_slope_B_MC->GetBinContent(bin);
3467 
3468  // the wstot=f(pT) depends on the particle type
3469  double ETGeV = energy / cosh(cl_eta) / 1E3;
3470  double wstot_pT_data_p0 = 0.;
3471  double wstot_pT_data_p1 = 0.;
3472  double wstot_pT_MC_p0 = 0.;
3473  double wstot_pT_MC_p1 = 0.;
3474 
3475  double wstot_40_data =
3476  m_wstot_pT_data_p0_electrons->GetBinContent(bin) +
3477  (m_wstot_pT_data_p1_electrons->GetBinContent(bin)) / sqrt(40.);
3478  double wstot_40_MC =
3479  m_wstot_pT_MC_p0_electrons->GetBinContent(bin) +
3480  (m_wstot_pT_MC_p1_electrons->GetBinContent(bin)) / sqrt(40.);
3481 
3482  if (ptype == PATCore::ParticleType::Electron) {
3483  wstot_pT_data_p0 = m_wstot_pT_data_p0_electrons->GetBinContent(bin);
3484  wstot_pT_data_p1 = m_wstot_pT_data_p1_electrons->GetBinContent(bin);
3485  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_electrons->GetBinContent(bin);
3486  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_electrons->GetBinContent(bin);
3487  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3488  wstot_pT_data_p0 =
3489  m_wstot_pT_data_p0_unconverted_photons->GetBinContent(bin);
3490  wstot_pT_data_p1 =
3491  m_wstot_pT_data_p1_unconverted_photons->GetBinContent(bin);
3492  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_unconverted_photons->GetBinContent(bin);
3493  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_unconverted_photons->GetBinContent(bin);
3494  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3495  wstot_pT_data_p0 = m_wstot_pT_data_p0_converted_photons->GetBinContent(bin);
3496  wstot_pT_data_p1 = m_wstot_pT_data_p1_converted_photons->GetBinContent(bin);
3497  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_converted_photons->GetBinContent(bin);
3498  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_converted_photons->GetBinContent(bin);
3499  }
3500 
3501  double wstot_pT_data = 0.;
3502  double wstot_pT_MC = 0.;
3503 
3504  // Initial parametrization: [0]+1*pT
3505  // wstot_pT_data = wstot_pT_data_p0+wstot_pT_data_p1*ETGeV;
3506  // prevent wstot_pT_data from being negative
3507  // if(wstot_pT_data<0) wstot_pT_data = 0.;
3508 
3509  // New parametrization: p0+p1/sqrt(pT)
3510  // flat uncertainty below 25 GeV
3511  if (ETGeV < 25.)
3512  ETGeV = 25.;
3513 
3514  wstot_pT_data = wstot_pT_data_p0 + wstot_pT_data_p1 / sqrt(ETGeV);
3515  wstot_pT_MC = wstot_pT_MC_p0 + wstot_pT_MC_p1 / sqrt(ETGeV);
3516 
3517  value = 2 * A / 91.2 * (wstot_pT_data - wstot_40_data) -
3518  2 * B / 91.2 * (wstot_pT_MC - wstot_40_MC);
3519 
3520  return value;
3521 }

◆ getZeeMeanET()

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

Definition at line 2504 of file egammaEnergyCorrectionTool.cxx.

2504  {
2505  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
2506  return 40000.;
2507  else {
2508  if (std::abs(cl_eta) >= 2.47)
2509  cl_eta = 2.46;
2510  return m_meanZeeProfile->GetBinContent(
2511  m_meanZeeProfile->FindBin(std::abs(cl_eta))) *
2512  1000;
2513  }
2514 }

◆ 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::es2018_R21_v0 or
928  m_esmodel == egEnergyCorr::es2018_R21_v1 or
929  m_esmodel == egEnergyCorr::es2022_R22_PRE or
930  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) { // add release 21
931  // here for now
932  m_use_etaCalo_scales = true;
933  m_use_new_resolution_model = true;
934  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
935  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
936  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
937  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
938  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
939  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
940  m_resolution_tool = std::make_unique<eg_resolution>("run2_R21_v1");
941  } else {
942  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
943  }
944 
945  if (m_esmodel == egEnergyCorr::es2017_summer_final or
946  m_esmodel == egEnergyCorr::es2017_R21_v0 or
947  m_esmodel == egEnergyCorr::es2017_R21_v1 or
948  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
949  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
950  m_esmodel == egEnergyCorr::es2022_R22_PRE) {
951  m_aPSNom.reset(checked_own_cast<TH1*>(
952  rootFile->Get("Scales/es2017_summer_final/alphaPS_uncor")));
953  m_daPSb12.reset(checked_own_cast<TH1*>(
954  rootFile->Get("Scales/es2017_summer_final/dalphaPS_b12")));
955  m_daPSCor.reset(
956  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
957  m_aS12Nom.reset(checked_own_cast<TH1*>(
958  rootFile->Get("Scales/es2017_summer_final/alphaS12_uncor")));
959  m_daS12Cor.reset(checked_own_cast<TH1*>(
960  rootFile->Get("Scales/es2012c/dalphaS12_cor")));
961  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1) {
962  m_aPSNom.reset(checked_own_cast<TH1*>(
963  rootFile->Get("Scales/es2017_summer_final/alphaPS_uncor")));
964  m_daPSb12.reset(checked_own_cast<TH1*>(
965  rootFile->Get("Scales/es2017_summer_final/dalphaPS_b12")));
966  m_daPSCor.reset(
967  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
968  m_aS12Nom.reset(checked_own_cast<TH1*>(
969  rootFile->Get("Scales/es2018_R21_v1/alphaS12_uncor")));
970  m_daS12Cor.reset(checked_own_cast<TH1*>(
971  rootFile->Get("Scales/es2012c/dalphaS12_cor")));
972  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
973  m_aPSNom.reset(checked_own_cast<TH1*>(
974  rootFile->Get("Scales/es2023_R22_Run2_v0/alphaPS_uncor")));
975  m_aS12Nom.reset(checked_own_cast<TH1*>(
976  rootFile->Get("Scales/es2023_R22_Run2_v0/alphaS12_uncor")));
977  } else {
978  m_aPSNom.reset(checked_own_cast<TH1*>(
979  rootFile->Get("Scales/es2012c/alphaPS_uncor")));
980  m_daPSCor.reset(
981  checked_own_cast<TH1*>(rootFile->Get("Scales/es2012c/dalphaPS_cor")));
982  m_aS12Nom.reset(checked_own_cast<TH1*>(
983  rootFile->Get("Scales/es2012c/alphaS12_uncor")));
984  m_daS12Cor.reset(checked_own_cast<TH1*>(
985  rootFile->Get("Scales/es2012c/dalphaS12_cor")));
986  }
987  m_trkSyst.reset(checked_own_cast<TH1*>(
988  rootFile->Get("Scales/es2012c/momentum_errSyst")));
989 
990  if (m_esmodel == egEnergyCorr::es2017) {
991  m_zeeNom.reset(checked_own_cast<TH1*>(
992  rootFile->Get("Scales/es2017/alphaZee_errStat_period_2016")));
993  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
994  rootFile->Get("Scales/es2017/alphaZee_errStat_period_2015")));
995  } else if (m_esmodel == egEnergyCorr::es2017_summer or
996  m_esmodel == egEnergyCorr::es2017_summer_improved) {
997  m_zeeNom.reset(checked_own_cast<TH1*>(
998  rootFile->Get("Scales/es2017_summer/alphaZee_errStat_period_2016")));
999  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1000  rootFile->Get("Scales/es2017_summer/alphaZee_errStat_period_2015")));
1001  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1002  m_zeeNom.reset(checked_own_cast<TH1*>(rootFile->Get(
1003  "Scales/es2017_summer_final/alphaZee_errStat_period_2016")));
1004  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(rootFile->Get(
1005  "Scales/es2017_summer_final/alphaZee_errStat_period_2015")));
1006  } else if (m_esmodel == egEnergyCorr::es2015_5TeV) {
1007  m_zeeNom.reset(checked_own_cast<TH1*>(
1008  rootFile->Get("Scales/es2015_5TeV/alphaZee_errStat_period_2015")));
1009  // Same histogram added twice for simplicity
1010  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1011  rootFile->Get("Scales/es2015_5TeV/alphaZee_errStat_period_2015")));
1012  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1013  m_zeeNom.reset(checked_own_cast<TH1*>(
1014  rootFile->Get("Scales/es2017_R21_v0/alphaZee_errStat_period_2017")));
1015  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1016  rootFile->Get("Scales/es2017_R21_v0/alphaZee_errStat_period_2016")));
1017  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1018  rootFile->Get("Scales/es2017_R21_v0/alphaZee_errStat_period_2015")));
1019  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1020  m_zeeNom.reset(checked_own_cast<TH1*>(
1021  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errStat_period_2017")));
1022  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1023  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errStat_period_2016")));
1024  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1025  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errStat_period_2015")));
1026  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1027  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalk")));
1028  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1029  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalb")));
1030  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1031  m_zeeNom.reset(checked_own_cast<TH1*>(rootFile->Get(
1032  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2017")));
1033  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(rootFile->Get(
1034  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2016")));
1035  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(rootFile->Get(
1036  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2015")));
1037  m_zeeNom_data2018.reset(checked_own_cast<TH1*>(rootFile->Get(
1038  "Scales/es2017_R21_ofc0_v1/alphaZee_errStat_period_2018")));
1039  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1040  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalk")));
1041  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1042  rootFile->Get("Scales/es2017_R21_v1/alphaFwd_Finalb")));
1043  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1044 
1045  m_zeeNom.reset(checked_own_cast<TH1*>(
1046  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2018")));
1047  m_zeeNom_data2017.reset(checked_own_cast<TH1*>(
1048  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2017")));
1049  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1050  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2016")));
1051  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1052  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errStat_period_2015")));
1053  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1054  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1055  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1056  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1057  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1) {
1058  m_zeeNom.reset(checked_own_cast<TH1*>(
1059  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2018")));
1060  m_zeeNom_data2017.reset(checked_own_cast<TH1*>(
1061  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2017")));
1062  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(
1063  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2016")));
1064  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1065  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errStat_period_2015")));
1066  // same as in v0 model
1067  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1068  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1069  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1070  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1071  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1072  m_zeeNom.reset(checked_own_cast<TH1*>(
1073  rootFile->Get("Scales/es2022_R22_PRE/alphaZee_errStat_period_2018")));
1074  // same as in v0 model
1075  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1076  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1077  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1078  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1079  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1080  // TODO: update to latest version from Tao
1081  m_zeeNom.reset(checked_own_cast<TH1*>(rootFile->Get(
1082  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2018")));
1083  m_zeeNom_data2017.reset(checked_own_cast<TH1*>(rootFile->Get(
1084  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2017")));
1085  m_zeeNom_data2016.reset(checked_own_cast<TH1*>(rootFile->Get(
1086  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2016")));
1087  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(rootFile->Get(
1088  "Scales/es2023_R22_Run2_v0/alphaZee_errStat_period_2015")));
1089  // same as in v0 model
1090  m_zeeFwdk.reset(checked_own_cast<TH1*>(
1091  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalk")));
1092  m_zeeFwdb.reset(checked_own_cast<TH1*>(
1093  rootFile->Get("Scales/es2018_R21_v0/alphaFwd_Finalb")));
1094  } else {
1095  m_zeeNom.reset(checked_own_cast<TH1*>(
1096  rootFile->Get("Scales/es2017_R21_PRE/alphaZee_errStat_period_2016")));
1097  // SAME HISTO FOR 2015 FOR NOW
1098  m_zeeNom_data2015.reset(checked_own_cast<TH1*>(
1099  rootFile->Get("Scales/es2017_R21_PRE/alphaZee_errStat_period_2016")));
1100  }
1101  if (m_esmodel == egEnergyCorr::es2017) {
1102  m_zeeSyst.reset(checked_own_cast<TH1*>(
1103  rootFile->Get("Scales/es2017/alphaZee_errSyst")));
1104  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1105  m_zeeSyst.reset(checked_own_cast<TH1*>(
1106  rootFile->Get("Scales/es2017_summer_final/alphaZee_errSyst")));
1107  } else if (m_esmodel == egEnergyCorr::es2015_5TeV) {
1108  m_zeeSyst.reset(checked_own_cast<TH1*>(
1109  rootFile->Get("Scales/es2015_5TeV/alphaZee_errSyst")));
1110  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1111  m_zeeSyst.reset(checked_own_cast<TH1*>(
1112  rootFile->Get("Scales/es2017_summer_final/alphaZee_errSyst")));
1113  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1114  m_zeeSyst.reset(checked_own_cast<TH1*>(
1115  rootFile->Get("Scales/es2017_R21_v1/alphaZee_errSyst")));
1116  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1117  m_zeeSyst.reset(checked_own_cast<TH1*>(
1118  rootFile->Get("Scales/es2017_R21_ofc0_v1/alphaZee_errSyst")));
1119  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1120  m_zeeSyst.reset(checked_own_cast<TH1*>(
1121  rootFile->Get("Scales/es2018_R21_v0/alphaZee_errSyst")));
1122  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1123  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1124  m_zeeSyst.reset(checked_own_cast<TH1*>(
1125  rootFile->Get("Scales/es2018_R21_v1/alphaZee_errSyst")));
1126  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1127  m_zeeSyst.reset(checked_own_cast<TH1*>(
1128  rootFile->Get("Scales/es2022_R22_PRE/alphaZee_errSyst")));
1129  m_zeeSystOFC.reset(checked_own_cast<TH1*>(
1130  rootFile->Get("Scales/es2022_R22_PRE/alphaZee_errOFCSyst")));
1131  } else {
1132  m_zeeSyst.reset(checked_own_cast<TH1*>(
1133  rootFile->Get("Scales/es2017_summer/alphaZee_errSyst")));
1134  }
1135 
1136  m_uA2MeV_2015_first2weeks_correction = nullptr;
1137  if (m_esmodel == egEnergyCorr::es2017) {
1138  m_resNom.reset(checked_own_cast<TH1*>(
1139  rootFile->Get("Resolution/es2017/ctZee_errStat")));
1140  } else if (m_esmodel == egEnergyCorr::es2017_summer or
1141  m_esmodel == egEnergyCorr::es2017_summer_improved or
1142  m_esmodel == egEnergyCorr::es2015_5TeV) {
1143  m_resNom.reset(checked_own_cast<TH1*>(
1144  rootFile->Get("Resolution/es2017_summer/ctZee_errStat")));
1145  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1146  m_resNom.reset(checked_own_cast<TH1*>(
1147  rootFile->Get("Resolution/es2017_summer_final/ctZee_errStat")));
1148  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1149  m_resNom.reset(checked_own_cast<TH1*>(
1150  rootFile->Get("Resolution/es2017_R21_v0/ctZee_errStat")));
1151  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1152  m_resNom.reset(checked_own_cast<TH1*>(
1153  rootFile->Get("Resolution/es2017_R21_v1/ctZee_errStat")));
1154  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1155  m_resNom.reset(checked_own_cast<TH1*>(
1156  rootFile->Get("Resolution/es2017_R21_ofc0_v1/ctZee_errStat")));
1157  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1158  m_resNom.reset(checked_own_cast<TH1*>(
1159  rootFile->Get("Resolution/es2018_R21_v0/ctZee_errStat")));
1160  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1) {
1161  m_resNom.reset(checked_own_cast<TH1*>(
1162  rootFile->Get("Resolution/es2018_R21_v1/ctZee_errStat")));
1163  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1164  m_resNom.reset(checked_own_cast<TH1*>(
1165  rootFile->Get("Resolution/es2022_R22_PRE/ctZee_errStat")));
1166  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1167  m_resNom.reset(checked_own_cast<TH1*>(
1168  rootFile->Get("Resolution/es2023_R22_Run2_v0/ctZee_errStat")));
1169  } else {
1170  m_resNom.reset(checked_own_cast<TH1*>(
1171  rootFile->Get("Resolution/es2017_R21_PRE/ctZee_errStat")));
1172  }
1173 
1174  if (m_esmodel == egEnergyCorr::es2017) {
1175  m_resSyst.reset(checked_own_cast<TH1*>(
1176  rootFile->Get("Resolution/es2017/ctZee_errSyst")));
1177  } else if (m_esmodel == egEnergyCorr::es2017_summer_final) {
1178  m_resSyst.reset(checked_own_cast<TH1*>(
1179  rootFile->Get("Resolution/es2017_summer_final/ctZee_errSyst")));
1180  } else if (m_esmodel == egEnergyCorr::es2015_5TeV) {
1181  m_resSyst.reset(checked_own_cast<TH1*>(
1182  rootFile->Get("Resolution/es2015_5TeV/ctZee_errSyst")));
1183  } else if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1184  m_resSyst.reset(checked_own_cast<TH1*>(
1185  rootFile->Get("Resolution/es2017_summer_final/ctZee_errSyst")));
1186  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1) {
1187  m_resSyst.reset(checked_own_cast<TH1*>(
1188  rootFile->Get("Resolution/es2017_R21_v1/ctZee_errSyst")));
1189  } else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
1190  m_resSyst.reset(checked_own_cast<TH1*>(
1191  rootFile->Get("Resolution/es2017_R21_ofc0_v1/ctZee_errSyst")));
1192  } else if (m_esmodel == egEnergyCorr::es2018_R21_v0) {
1193  m_resSyst.reset(checked_own_cast<TH1*>(
1194  rootFile->Get("Resolution/es2018_R21_v0/ctZee_errSyst")));
1195  } else if (m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1196  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1197  m_resSyst.reset(checked_own_cast<TH1*>(
1198  rootFile->Get("Resolution/es2018_R21_v1/ctZee_errSyst")));
1199  } else if (m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1200  m_resSyst.reset(checked_own_cast<TH1*>(
1201  rootFile->Get("Resolution/es2022_R22_PRE/ctZee_errSyst")));
1202  m_resSystOFC.reset(checked_own_cast<TH1*>(
1203  rootFile->Get("Resolution/es2022_R22_PRE/ctZee_errOFCSyst")));
1204  } else {
1205  m_resSyst.reset(checked_own_cast<TH1*>(
1206  rootFile->Get("Resolution/es2017_summer/ctZee_errSyst")));
1207  }
1208  // else{
1209  // m_resSyst.reset( checked_own_cast< TH1* >(
1210  // rootFile->Get("Resolution/es2017_summer_improved/ctZee_errSyst")));
1211  // }
1212 
1213  m_pedestals_es2017.reset(
1214  checked_own_cast<TH1*>(rootFile->Get("Pedestals/es2017/pedestals")));
1215 
1216  m_dX_ID_Nom.reset(
1217  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA")));
1218 
1219  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(
1220  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errUncor")));
1221  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
1222  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr")));
1223 
1224  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(
1225  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errUncor")));
1226  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(
1227  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errLAr")));
1228  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
1229  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4")));
1230  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(
1231  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errGL1")));
1232 
1233  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(
1234  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errUncor")));
1235  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(
1236  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errLAr")));
1237  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
1238  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4")));
1239 
1240  m_convRadius.reset(checked_own_cast<TH1*>(
1241  rootFile->Get("Conversions/es2012c/convRadiusMigrations")));
1242  if (m_esmodel == egEnergyCorr::es2017) {
1243  m_convFakeRate.reset(checked_own_cast<TH1*>(
1244  rootFile->Get("Conversions/es2012c/convFakeRate")));
1245  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
1246  rootFile->Get("Conversions/es2012c/convRecoEfficiency")));
1247  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1248  m_convFakeRate_2D.reset(checked_own_cast<TH2*>(
1249  rootFile->Get("Conversions/es2023_R22_Run2_v0/convFakeRate")));
1250  m_convRecoEfficiency_2D.reset(checked_own_cast<TH2*>(
1251  rootFile->Get("Conversions/es2023_R22_Run2_v0/convRecoEfficiency")));
1252  } else {
1253  m_convFakeRate.reset(checked_own_cast<TH1*>(
1254  rootFile->Get("Conversions/es2017_summer/convFakeRate")));
1255  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
1256  rootFile->Get("Conversions/es2017_summer/convRecoEfficiency")));
1257  }
1258 
1259  // TODO: change path when moving to calibarea
1260  // TODO: better package this somewhere
1261 
1262  const std::string filename_pp0 = PathResolverFindCalibFile(
1263  "ElectronPhotonFourMomentumCorrection/v8/PP0sys.root");
1264 
1265  TFile file_pp0(filename_pp0.c_str());
1266  m_pp0_elec.reset(checked_own_cast<TH2*>(file_pp0.Get("elec")));
1267  m_pp0_conv.reset(checked_own_cast<TH2*>(file_pp0.Get("conv")));
1268  m_pp0_unconv.reset(checked_own_cast<TH2*>(file_pp0.Get("unco")));
1269 
1270  // similar case for wtots1
1271  const std::string filename_wstot = PathResolverFindCalibFile(
1272  "ElectronPhotonFourMomentumCorrection/v8/wstot_related_syst.root");
1273 
1274  TFile file_wstot(filename_wstot.c_str());
1275  m_wstot_slope_A_data.reset(
1276  checked_own_cast<TH1*>(file_wstot.Get("A_data")));
1277  m_wstot_slope_B_MC.reset(checked_own_cast<TH1*>(file_wstot.Get("B_mc")));
1278  m_wstot_pT_data_p0_electrons.reset(
1279  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_data_p0")));
1280  m_wstot_pT_data_p1_electrons.reset(
1281  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_data_p1")));
1282  m_wstot_pT_data_p0_unconverted_photons.reset(
1283  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_uc_data_p0")));
1284  m_wstot_pT_data_p1_unconverted_photons.reset(
1285  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_uc_data_p1")));
1286  m_wstot_pT_data_p0_converted_photons.reset(
1287  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_c_data_p0")));
1288  m_wstot_pT_data_p1_converted_photons.reset(
1289  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_c_data_p1")));
1290  m_wstot_pT_MC_p0_electrons.reset(
1291  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_mc_p0")));
1292  m_wstot_pT_MC_p1_electrons.reset(
1293  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_el_mc_p1")));
1294  m_wstot_pT_MC_p0_unconverted_photons.reset(
1295  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_uc_mc_p0")));
1296  m_wstot_pT_MC_p1_unconverted_photons.reset(
1297  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_uc_mc_p1")));
1298  m_wstot_pT_MC_p0_converted_photons.reset(
1299  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_c_mc_p0")));
1300  m_wstot_pT_MC_p1_converted_photons.reset(
1301  checked_own_cast<TH1*>(file_wstot.Get("wstot_pT_ph_c_mc_p1")));
1302 
1303  m_begRunNumber = 252604;
1304  m_endRunNumber = 314199;
1305 
1306  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1307  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1308  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1309  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1310  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1311  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1312  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
1313  rootFile->Get("FastSim/es2017_v1/resol_Af2ToG4_elec_rel21")));
1314  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
1315  rootFile->Get("FastSim/es2017_v1/resol_Af2ToG4_unco_rel21")));
1316  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
1317  rootFile->Get("FastSim/es2017_v1/resol_Af2ToG4_conv_rel21")));
1318  } else {
1319  m_G4OverAFII_resolution_electron.reset(checked_own_cast<TH2*>(
1320  rootFile->Get("FastSim/es2017/el_full_fast_resolution")));
1321  m_G4OverAFII_resolution_unconverted.reset(checked_own_cast<TH2*>(
1322  rootFile->Get("FastSim/es2017/ph_unconv_full_fast_resolution")));
1323  m_G4OverAFII_resolution_converted.reset(checked_own_cast<TH2*>(
1324  rootFile->Get("FastSim/es2017/ph_conv_full_fast_resolution")));
1325  }
1326  assert(m_G4OverAFII_resolution_electron);
1327  assert(m_G4OverAFII_resolution_unconverted);
1328  assert(m_G4OverAFII_resolution_converted);
1329 
1330  const std::string gain_filename1 = PathResolverFindCalibFile(
1331  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
1332  const std::string gain_filename2 = PathResolverFindCalibFile(
1333  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
1334  m_gain_tool = nullptr;
1335 
1336  std::string gain_tool_run_2_filename;
1337  if (m_esmodel == egEnergyCorr::es2017 or
1338  m_esmodel == egEnergyCorr::es2017_summer or
1339  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1340  m_esmodel == egEnergyCorr::es2015_5TeV) {
1341  gain_tool_run_2_filename = PathResolverFindCalibFile(
1342  "ElectronPhotonFourMomentumCorrection/v11/"
1343  "gain_uncertainty_specialRun.root");
1344  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1345  gain_tool_run_2_filename = PathResolverFindCalibFile(
1346  "ElectronPhotonFourMomentumCorrection/v29/"
1347  "gain_uncertainty_specialRun.root");
1348  } else {
1349  gain_tool_run_2_filename = PathResolverFindCalibFile(
1350  "ElectronPhotonFourMomentumCorrection/v14/"
1351  "gain_uncertainty_specialRun.root");
1352  }
1353  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1354  m_gain_tool_run2 = std::make_unique<egGain::GainUncertainty>(
1355  gain_tool_run_2_filename, true, "GainUncertainty",
1356  m_useL2GainInterpolation);
1357  } else {
1358  m_gain_tool_run2 =
1359  std::make_unique<egGain::GainUncertainty>(gain_tool_run_2_filename);
1360  }
1361 
1362  m_gain_tool_run2->msg().setLevel(this->msg().level());
1363 
1364  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1365  m_e1hg_tool = std::make_unique<e1hg_systematics>(
1366  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v29/"
1367  "e1hg_systematics_histos.root"));
1368  } else {
1369  m_e1hg_tool = std::make_unique<e1hg_systematics>(
1370  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
1371  "e1hg_systematics_histos.root"));
1372  }
1373 
1374  m_use_temp_correction201215 = false;
1375  m_use_temp_correction201516 = false;
1376  } else if (m_esmodel == egEnergyCorr::es2015_day0_3percent) {
1377  m_use_new_resolution_model = true;
1378  m_resolution_tool = std::make_unique<eg_resolution>("run2_pre");
1379 
1380  m_aPSNom.reset(checked_own_cast<TH1*>(
1381  rootFile->Get("Scales/es2015_day0/alphaPS_uncor"))); // old one
1382  m_daPSCor.reset(checked_own_cast<TH1*>(
1383  rootFile->Get("Scales/es2015_day0/dalphaPS_cor"))); // old one
1384  m_aS12Nom.reset(checked_own_cast<TH1*>(
1385  rootFile->Get("Scales/es2015_day0/alphaS12_uncor"))); // old one
1386  m_daS12Cor.reset(checked_own_cast<TH1*>(
1387  rootFile->Get("Scales/es2015_day0/dalphaS12_cor"))); // old one
1388 
1389  m_trkSyst.reset(checked_own_cast<TH1*>(
1390  rootFile->Get("Scales/es2015_day0/momentum_errSyst"))); // old one
1391 
1392  m_zeeNom.reset(checked_own_cast<TH1*>(
1393  rootFile->Get("Scales/es2015_day0/alphaZee_errStat"))); // old one
1394  m_zeeSyst.reset(checked_own_cast<TH1*>(
1395  rootFile->Get("Scales/es2015_day0/alphaZee_errSyst"))); // old one
1396 
1397  m_resNom.reset(checked_own_cast<TH1*>(
1398  rootFile->Get("Resolution/es2012c/ctZee_errStat"))); // old one
1399  m_resSyst.reset(checked_own_cast<TH1*>(
1400  rootFile->Get("Resolution/es2012c/ctZee_errSyst"))); // old one
1401 
1402  m_pedestalL0.reset(checked_own_cast<TH1*>(
1403  rootFile->Get("Pedestals/es2012c/pedestals_l0"))); // old one
1404  m_pedestalL1.reset(checked_own_cast<TH1*>(
1405  rootFile->Get("Pedestals/es2012c/pedestals_l1"))); // old one
1406  m_pedestalL2.reset(checked_own_cast<TH1*>(
1407  rootFile->Get("Pedestals/es2012c/pedestals_l2"))); // old one
1408  m_pedestalL3.reset(checked_own_cast<TH1*>(
1409  rootFile->Get("Pedestals/es2012c/pedestals_l3"))); // old one
1410 
1411  m_dX_ID_Nom.reset(checked_own_cast<TH1*>(
1412  rootFile->Get("Material/DX0_ConfigA"))); // old one
1413 
1414  m_dX_IPPS_Nom.reset(checked_own_cast<TH1*>(rootFile->Get(
1415  "Material/Measured/DXerr_IPPS_NewG_errUncor"))); // old one
1416  m_dX_IPPS_LAr.reset(checked_own_cast<TH1*>(
1417  rootFile->Get("Material/Measured/DXerr_IPPS_NewG_errLAr"))); // old one
1418 
1419  m_dX_IPAcc_Nom.reset(checked_own_cast<TH1*>(rootFile->Get(
1420  "Material/Measured/DXerr_IPAcc_NewG_errUncor"))); // old one
1421  m_dX_IPAcc_LAr.reset(checked_own_cast<TH1*>(rootFile->Get(
1422  "Material/Measured/DXerr_IPAcc_NewG_errLAr"))); // old one
1423  m_dX_IPAcc_G4.reset(checked_own_cast<TH1*>(
1424  rootFile->Get("Material/Measured/DXerr_IPAcc_NewG_errG4"))); // old one
1425  m_dX_IPAcc_GL1.reset(checked_own_cast<TH1*>(rootFile->Get(
1426  "Material/Measured/DXerr_IPAcc_NewG_errGL1"))); // old one
1427 
1428  m_dX_PSAcc_Nom.reset(checked_own_cast<TH1*>(rootFile->Get(
1429  "Material/Measured/DXerr_PSAcc_NewG_errUncor"))); // old one
1430  m_dX_PSAcc_LAr.reset(checked_own_cast<TH1*>(rootFile->Get(
1431  "Material/Measured/DXerr_PSAcc_NewG_errLAr"))); // old one
1432  m_dX_PSAcc_G4.reset(checked_own_cast<TH1*>(
1433  rootFile->Get("Material/Measured/DXerr_PSAcc_NewG_errG4"))); // old one
1434 
1435  m_convRadius.reset(checked_own_cast<TH1*>(
1436  rootFile->Get("Conversions/es2012c/convRadiusMigrations"))); // old one
1437  m_convFakeRate.reset(checked_own_cast<TH1*>(
1438  rootFile->Get("Conversions/es2012c/convFakeRate"))); // old one
1439  m_convRecoEfficiency.reset(checked_own_cast<TH1*>(
1440  rootFile->Get("Conversions/es2012c/convRecoEfficiency"))); // old one
1441 
1442  m_begRunNumber = 195847;
1443  m_endRunNumber = 219365;
1444 
1445  const std::string gain_filename1 = PathResolverFindCalibFile(
1446  "ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
1447  const std::string gain_filename2 = PathResolverFindCalibFile(
1448  "ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
1449  m_gain_tool =
1450  std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
1451 
1452  m_e1hg_tool = std::make_unique<e1hg_systematics>(
1453  PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/"
1454  "e1hg_systematics_histos.root"));
1455 
1456  // If we are here, fail s :
1457 
1458  } else if (m_esmodel == egEnergyCorr::UNDEFINED) {
1459  ATH_MSG_FATAL("ES model not initialized - Initialization fails");
1460  return 0;
1461  } else {
1462  ATH_MSG_FATAL("ES model not recognized - Initialization fails");
1463  return 0;
1464  }
1465 
1466  if (m_esmodel == egEnergyCorr::es2015cPRE or
1467  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
1468  m_esmodel == egEnergyCorr::es2015c_summer or
1469  m_esmodel == egEnergyCorr::es2016PRE or
1470  m_esmodel == egEnergyCorr::es2017 or
1471  m_esmodel == egEnergyCorr::es2017_summer or
1472  m_esmodel == egEnergyCorr::es2017_summer_improved or
1473  m_esmodel == egEnergyCorr::es2017_summer_final or
1474  m_esmodel == egEnergyCorr::es2017_R21_v0 or
1475  m_esmodel == egEnergyCorr::es2017_R21_v1 or
1476  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
1477  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1478  m_esmodel == egEnergyCorr::es2015_5TeV or
1479  m_esmodel == egEnergyCorr::es2018_R21_v0 or
1480  m_esmodel == egEnergyCorr::es2018_R21_v1 or
1481  m_esmodel == egEnergyCorr::es2022_R22_PRE or
1482  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1483  // E4 systematics
1484  m_E4ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1485  rootFile->Get("E4Recalibration/v4/electron_eta_axis")));
1486  m_E4ElectronGraphs.reset(
1487  checked_own_cast<TList*>(rootFile->Get("E4Recalibration/v4/electron")));
1488  // for photons use the same as electrons
1489  m_E4UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1490  rootFile->Get("E4Recalibration/v4/electron_eta_axis")));
1491  m_E4UnconvertedGraphs.reset(
1492  checked_own_cast<TList*>(rootFile->Get("E4Recalibration/v4/electron")));
1493  m_E4ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1494  rootFile->Get("E4Recalibration/v4/electron_eta_axis")));
1495  m_E4ConvertedGraphs.reset(
1496  checked_own_cast<TList*>(rootFile->Get("E4Recalibration/v4/electron")));
1497  }
1498 
1499  // ... PS and S12 recalibration curves
1500  if (m_esmodel == egEnergyCorr::es2015PRE or
1501  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
1502  m_esmodel == egEnergyCorr::es2015cPRE or
1503  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
1504  m_esmodel == egEnergyCorr::es2015c_summer or
1505  m_esmodel == egEnergyCorr::es2016PRE or
1506  m_esmodel == egEnergyCorr::es2017 or
1507  m_esmodel == egEnergyCorr::es2017_summer or
1508  m_esmodel == egEnergyCorr::es2017_summer_improved or
1509  m_esmodel == egEnergyCorr::es2017_summer_final or
1510  m_esmodel == egEnergyCorr::es2017_R21_v0 or
1511  m_esmodel == egEnergyCorr::es2017_R21_v1 or
1512  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
1513  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1514  m_esmodel == egEnergyCorr::es2015_5TeV or
1515  m_esmodel == egEnergyCorr::es2018_R21_v0 or
1516  m_esmodel == egEnergyCorr::es2018_R21_v1 or
1517  m_esmodel == egEnergyCorr::es2022_R22_PRE) {
1518 
1519  m_psElectronEtaBins.reset(checked_own_cast<TAxis*>(
1520  rootFile->Get("PSRecalibration/es2015PRE/ElectronAxis")));
1521  m_psElectronGraphs.reset(checked_own_cast<TList*>(
1522  rootFile->Get("PSRecalibration/es2015PRE/ElectronBiasPS")));
1523  m_psUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1524  rootFile->Get("PSRecalibration/es2015PRE/UnconvertedAxis")));
1525  m_psUnconvertedGraphs.reset(checked_own_cast<TList*>(
1526  rootFile->Get("PSRecalibration/es2015PRE/UnconvertedBiasPS")));
1527  m_psConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1528  rootFile->Get("PSRecalibration/es2015PRE/ConvertedAxis")));
1529  m_psConvertedGraphs.reset(checked_own_cast<TList*>(
1530  rootFile->Get("PSRecalibration/es2015PRE/ConvertedBiasPS")));
1531 
1532  m_s12ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1533  rootFile->Get("S1Recalibration/es2015PRE/ElectronAxis")));
1534  m_s12ElectronGraphs.reset(checked_own_cast<TList*>(
1535  rootFile->Get("S1Recalibration/es2015PRE/ElectronBiasS1")));
1536  m_s12UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1537  rootFile->Get("S1Recalibration/es2015PRE/UnconvertedAxis")));
1538  m_s12UnconvertedGraphs.reset(checked_own_cast<TList*>(
1539  rootFile->Get("S1Recalibration/es2015PRE/UnconvertedBiasS1")));
1540  m_s12ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1541  rootFile->Get("S1Recalibration/es2015PRE/ConvertedAxis")));
1542  m_s12ConvertedGraphs.reset(checked_own_cast<TList*>(
1543  rootFile->Get("S1Recalibration/es2015PRE/ConvertedBiasS1")));
1544  } else if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1545  m_psElectronEtaBins.reset(checked_own_cast<TAxis*>(
1546  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ElectronAxis")));
1547  m_psElectronGraphs.reset(checked_own_cast<TList*>(
1548  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ElectronBiasPS")));
1549  m_psUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1550  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/UnconvertedAxis")));
1551  m_psUnconvertedGraphs.reset(checked_own_cast<TList*>(
1552  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/UnconvertedBiasPS")));
1553  m_psConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1554  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ConvertedAxis")));
1555  m_psConvertedGraphs.reset(checked_own_cast<TList*>(
1556  rootFile->Get("PSRecalibration/es2023_R22_Run2_v0/ConvertedBiasPS")));
1557 
1558  m_s12ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1559  rootFile->Get("S2Recalibration/ElectronAxis")));
1560  m_s12ElectronGraphs.reset(checked_own_cast<TList*>(
1561  rootFile->Get("S2Recalibration/ElectronBiasS2")));
1562  m_s12UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1563  rootFile->Get("S2Recalibration/UnconvertedAxis")));
1564  m_s12UnconvertedGraphs.reset(checked_own_cast<TList*>(
1565  rootFile->Get("S2Recalibration/UnconvertedBiasS2")));
1566  m_s12ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1567  rootFile->Get("S2Recalibration/ConvertedAxis")));
1568  m_s12ConvertedGraphs.reset(checked_own_cast<TList*>(
1569  rootFile->Get("S2Recalibration/ConvertedBiasS2")));
1570 
1571  m_EaccElectronEtaBins.reset(checked_own_cast<TAxis*>(
1572  rootFile->Get("SaccRecalibration/ElectronAxis")));
1573  m_EaccElectronGraphs.reset(checked_own_cast<TList*>(
1574  rootFile->Get("SaccRecalibration/ElectronBiasSacc")));
1575  m_EaccUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1576  rootFile->Get("SaccRecalibration/UnconvertedAxis")));
1577  m_EaccUnconvertedGraphs.reset(checked_own_cast<TList*>(
1578  rootFile->Get("SaccRecalibration/UnconvertedBiasSacc")));
1579  m_EaccConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1580  rootFile->Get("SaccRecalibration/ConvertedAxis")));
1581  m_EaccConvertedGraphs.reset(checked_own_cast<TList*>(
1582  rootFile->Get("SaccRecalibration/ConvertedBiasSacc")));
1583  } else // run1
1584  {
1585  m_psElectronEtaBins.reset(checked_own_cast<TAxis*>(
1586  rootFile->Get("PSRecalibration/ElectronAxis")));
1587  m_psElectronGraphs.reset(checked_own_cast<TList*>(
1588  rootFile->Get("PSRecalibration/ElectronBiasPS")));
1589  m_psUnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1590  rootFile->Get("PSRecalibration/UnconvertedAxis")));
1591  m_psUnconvertedGraphs.reset(checked_own_cast<TList*>(
1592  rootFile->Get("PSRecalibration/UnconvertedBiasPS")));
1593  m_psConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1594  rootFile->Get("PSRecalibration/ConvertedAxis")));
1595  m_psConvertedGraphs.reset(checked_own_cast<TList*>(
1596  rootFile->Get("PSRecalibration/ConvertedBiasPS")));
1597 
1598  m_s12ElectronEtaBins.reset(checked_own_cast<TAxis*>(
1599  rootFile->Get("S1Recalibration/ElectronAxis")));
1600  m_s12ElectronGraphs.reset(checked_own_cast<TList*>(
1601  rootFile->Get("S1Recalibration/ElectronBiasS1")));
1602  m_s12UnconvertedEtaBins.reset(checked_own_cast<TAxis*>(
1603  rootFile->Get("S1Recalibration/UnconvertedAxis")));
1604  m_s12UnconvertedGraphs.reset(checked_own_cast<TList*>(
1605  rootFile->Get("S1Recalibration/UnconvertedBiasS1")));
1606  m_s12ConvertedEtaBins.reset(checked_own_cast<TAxis*>(
1607  rootFile->Get("S1Recalibration/ConvertedAxis")));
1608  m_s12ConvertedGraphs.reset(checked_own_cast<TList*>(
1609  rootFile->Get("S1Recalibration/ConvertedBiasS1")));
1610  }
1611 
1612  // further inputs do not depend on year
1613 
1614  // ... material distortions
1615  m_matUnconvertedScale.emplace_back(
1616  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1617  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigA"))));
1618  m_matUnconvertedScale.emplace_back(
1619  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1620  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigCpDp"))));
1621  m_matUnconvertedScale.emplace_back(
1622  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1623  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigEpLp"))));
1624  m_matUnconvertedScale.emplace_back(
1625  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1626  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigFpMX"))));
1627  m_matUnconvertedScale.emplace_back(
1628  std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1629  rootFile->Get("Material/unconvertedBiasSubtracted_ConfigGp"))));
1630 
1631  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1632  rootFile->Get("Material/convertedBiasSubtracted_ConfigA"))));
1633  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1634  rootFile->Get("Material/convertedBiasSubtracted_ConfigCpDp"))));
1635  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1636  rootFile->Get("Material/convertedBiasSubtracted_ConfigEpLp"))));
1637  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1638  rootFile->Get("Material/convertedBiasSubtracted_ConfigFpMX"))));
1639  m_matConvertedScale.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1640  rootFile->Get("Material/convertedBiasSubtracted_ConfigGp"))));
1641 
1642  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1643  rootFile->Get("Material/electronCstTerm_ConfigA"))));
1644  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1645  rootFile->Get("Material/electronCstTerm_ConfigCpDp"))));
1646  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1647  rootFile->Get("Material/electronCstTerm_ConfigEpLp"))));
1648  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1649  rootFile->Get("Material/electronCstTerm_ConfigFpMX"))));
1650  m_matElectronCstTerm.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1651  rootFile->Get("Material/electronCstTerm_ConfigGp"))));
1652 
1653  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1654  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1655  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1656  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1657  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1658  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1659  // update dX0 plots for distorted geometry for case A, EL, FMX and N
1660  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1661  checked_own_cast<TH1*>(rootFile->Get("Material_rel21/DX0_ConfigA"))));
1662  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1663  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigCpDp"))));
1664  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1665  rootFile->Get("Material_rel21/DX0_ConfigEpLp"))));
1666  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(checked_own_cast<TH1*>(
1667  rootFile->Get("Material_rel21/DX0_ConfigFpMX"))));
1668  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1669  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigGp"))));
1670  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1671  checked_own_cast<TH1*>(rootFile->Get("Material_rel21/DX0_ConfigN"))));
1672  } else {
1673  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1674  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigA"))));
1675  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1676  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigCpDp"))));
1677  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1678  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigEpLp"))));
1679  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1680  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigFpMX"))));
1681  m_matX0Additions.emplace_back(std::unique_ptr<TH1>(
1682  checked_own_cast<TH1*>(rootFile->Get("Material/DX0_ConfigGp"))));
1683  }
1684 
1685  m_matElectronEtaBins.reset(
1686  checked_own_cast<TAxis*>(rootFile->Get("Material/LinearityEtaBins")));
1687  m_matElectronGraphs.emplace_back(
1688  std::unique_ptr<TList>(checked_own_cast<TList*>(
1689  rootFile->Get("Material/Linearity_Cluster_ConfigA"))));
1690  m_matElectronGraphs.emplace_back(
1691  std::unique_ptr<TList>(checked_own_cast<TList*>(
1692  rootFile->Get("Material/Linearity_Cluster_ConfigCpDp"))));
1693  m_matElectronGraphs.emplace_back(
1694  std::unique_ptr<TList>(checked_own_cast<TList*>(
1695  rootFile->Get("Material/Linearity_Cluster_ConfigEpLp"))));
1696  m_matElectronGraphs.emplace_back(
1697  std::unique_ptr<TList>(checked_own_cast<TList*>(
1698  rootFile->Get("Material/Linearity_Cluster_ConfigFpMX"))));
1699  m_matElectronGraphs.emplace_back(
1700  std::unique_ptr<TList>(checked_own_cast<TList*>(
1701  rootFile->Get("Material/Linearity_Cluster_ConfigGp"))));
1702  // ... new material distortions from release 21 parameterizations
1703  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1704  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1705  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1706  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1707  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1708  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1709  m_electronBias_ConfigA.reset(checked_own_cast<TH2*>(
1710  rootFile->Get("Material_rel21/electronBias_ConfigA")));
1711  m_electronBias_ConfigEpLp.reset(checked_own_cast<TH2*>(
1712  rootFile->Get("Material_rel21/electronBias_ConfigEpLp")));
1713  m_electronBias_ConfigFpMX.reset(checked_own_cast<TH2*>(
1714  rootFile->Get("Material_rel21/electronBias_ConfigFpMX")));
1715  m_electronBias_ConfigN.reset(checked_own_cast<TH2*>(
1716  rootFile->Get("Material_rel21/electronBias_ConfigN")));
1717  m_electronBias_ConfigIBL.reset(checked_own_cast<TH2*>(
1718  rootFile->Get("Material_rel21/electronBias_ConfigIBL")));
1719  m_electronBias_ConfigPP0.reset(checked_own_cast<TH2*>(
1720  rootFile->Get("Material_rel21/electronBias_ConfigPP0")));
1721  m_unconvertedBias_ConfigA.reset(checked_own_cast<TH2*>(
1722  rootFile->Get("Material_rel21/unconvertedBias_ConfigA")));
1723  m_unconvertedBias_ConfigEpLp.reset(checked_own_cast<TH2*>(
1724  rootFile->Get("Material_rel21/unconvertedBias_ConfigEpLp")));
1725  m_unconvertedBias_ConfigFpMX.reset(checked_own_cast<TH2*>(
1726  rootFile->Get("Material_rel21/unconvertedBias_ConfigFpMX")));
1727  m_unconvertedBias_ConfigN.reset(checked_own_cast<TH2*>(
1728  rootFile->Get("Material_rel21/unconvertedBias_ConfigN")));
1729  m_unconvertedBias_ConfigIBL.reset(checked_own_cast<TH2*>(
1730  rootFile->Get("Material_rel21/unconvertedBias_ConfigIBL")));
1731  m_unconvertedBias_ConfigPP0.reset(checked_own_cast<TH2*>(
1732  rootFile->Get("Material_rel21/unconvertedBias_ConfigPP0")));
1733  m_convertedBias_ConfigA.reset(checked_own_cast<TH2*>(
1734  rootFile->Get("Material_rel21/convertedBias_ConfigA")));
1735  m_convertedBias_ConfigEpLp.reset(checked_own_cast<TH2*>(
1736  rootFile->Get("Material_rel21/convertedBias_ConfigEpLp")));
1737  m_convertedBias_ConfigFpMX.reset(checked_own_cast<TH2*>(
1738  rootFile->Get("Material_rel21/convertedBias_ConfigFpMX")));
1739  m_convertedBias_ConfigN.reset(checked_own_cast<TH2*>(
1740  rootFile->Get("Material_rel21/convertedBias_ConfigN")));
1741  m_convertedBias_ConfigIBL.reset(checked_own_cast<TH2*>(
1742  rootFile->Get("Material_rel21/convertedBias_ConfigIBL")));
1743  m_convertedBias_ConfigPP0.reset(checked_own_cast<TH2*>(
1744  rootFile->Get("Material_rel21/convertedBias_ConfigPP0")));
1745  }
1746 
1747  // ... Fastsim to Fullsim corrections
1748 
1749  if (m_esmodel == egEnergyCorr::es2015PRE or
1750  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
1751  m_esmodel == egEnergyCorr::es2015cPRE or
1752  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
1753  m_esmodel == egEnergyCorr::es2015c_summer or
1754  m_esmodel == egEnergyCorr::es2016PRE) {
1755 
1756  m_G4OverAFII_electron.reset(checked_own_cast<TH1*>(
1757  rootFile->Get("FastSim/es2015/el_scale_full_fast_peak_gaussian")));
1758  m_G4OverAFII_unconverted.reset(checked_own_cast<TH1*>(rootFile->Get(
1759  "FastSim/es2015/ph_unconv_scale_full_fast_peak_gaussian")));
1760  m_G4OverAFII_converted.reset(checked_own_cast<TH1*>(
1761  rootFile->Get("FastSim/es2015/ph_conv_scale_full_fast_peak_gaussian")));
1762  } else if (m_esmodel == egEnergyCorr::es2017 or
1763  m_esmodel == egEnergyCorr::es2017_summer or
1764  m_esmodel == egEnergyCorr::es2017_summer_improved or
1765  m_esmodel == egEnergyCorr::es2017_summer_final or
1766  m_esmodel == egEnergyCorr::es2017_R21_PRE or
1767  m_esmodel == egEnergyCorr::es2015_5TeV or
1768  m_esmodel == egEnergyCorr::es2017_R21_v0) {
1769  m_G4OverAFII_electron.reset(checked_own_cast<TH1*>(
1770  rootFile->Get("FastSim/es2017/el_scale_full_fast_peak_gaussian")));
1771  m_G4OverAFII_unconverted.reset(checked_own_cast<TH1*>(rootFile->Get(
1772  "FastSim/es2017/ph_unconv_scale_full_fast_peak_gaussian")));
1773  m_G4OverAFII_converted.reset(checked_own_cast<TH1*>(
1774  rootFile->Get("FastSim/es2017/ph_conv_scale_full_fast_peak_gaussian")));
1775  } else if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1776  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1777  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1778  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1779  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1780  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1781  m_G4OverAFII_electron_2D.reset(checked_own_cast<TH2*>(
1782  rootFile->Get("FastSim/es2017_v1/scale_Af2ToG4_elec_rel21")));
1783  m_G4OverAFII_electron_2D->SetDirectory(nullptr);
1784  m_G4OverAFII_unconverted_2D.reset(checked_own_cast<TH2*>(
1785  rootFile->Get("FastSim/es2017_v1/scale_Af2ToG4_unco_rel21")));
1786  m_G4OverAFII_converted_2D.reset(checked_own_cast<TH2*>(
1787  rootFile->Get("FastSim/es2017_v1/scale_Af2ToG4_conv_rel21")));
1788  } else { // run 1
1789  m_G4OverAFII_electron.reset(
1790  checked_own_cast<TH1*>(rootFile->Get("FastSim/hG4OverAF")));
1791  }
1792  m_G4OverFrSh.reset(
1793  checked_own_cast<TH1*>(rootFile->Get("FastSim/hG4OverFS")));
1794  // ... Leakage systematics
1795 
1796  if (m_esmodel != egEnergyCorr::es2017_summer and
1797  m_esmodel != egEnergyCorr::es2017_summer_improved and
1798  m_esmodel != egEnergyCorr::es2017_summer_final and
1799  m_esmodel != egEnergyCorr::es2017_R21_PRE and
1800  m_esmodel != egEnergyCorr::es2015_5TeV and
1801  m_esmodel != egEnergyCorr::es2017_R21_v0 and
1802  m_esmodel != egEnergyCorr::es2017_R21_v1 and
1803  m_esmodel != egEnergyCorr::es2017_R21_ofc0_v1 and
1804  m_esmodel != egEnergyCorr::es2018_R21_v0 and
1805  m_esmodel != egEnergyCorr::es2018_R21_v1 and
1806  m_esmodel != egEnergyCorr::es2022_R22_PRE and
1807  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
1808  m_leakageConverted.reset(
1809  checked_own_cast<TH1*>(rootFile->Get("Leakage/LeakageDiffConverted")));
1810  m_leakageUnconverted.reset(checked_own_cast<TH1*>(
1811  rootFile->Get("Leakage/LeakageDiffUnconverted")));
1812  } else if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
1813  m_leakageConverted.reset(checked_own_cast<TH1*>(
1814  rootFile->Get("Leakage/es2017_summer/LeakageDiffConverted")));
1815  m_leakageUnconverted.reset(checked_own_cast<TH1*>(
1816  rootFile->Get("Leakage/es2017_summer/LeakageDiffUnconverted")));
1817  } else {
1818  m_leakageConverted.reset(checked_own_cast<TH1*>(
1819  rootFile->Get("Leakage/es2023_R22_Run2_v0/LeakageDiffConverted")));
1820  m_leakageUnconverted.reset(checked_own_cast<TH1*>(
1821  rootFile->Get("Leakage/es2023_R22_Run2_v0/LeakageDiffUnconverted")));
1822  m_leakageElectron.reset(checked_own_cast<TH1*>(
1823  rootFile->Get("Leakage/es2023_R22_Run2_v0/LeakageDiffElectron")));
1824  m_leakageElectron->SetDirectory(nullptr);
1825  }
1826  if (m_leakageConverted.get() && m_leakageUnconverted.get()) {
1827  m_leakageConverted->SetDirectory(nullptr);
1828  m_leakageUnconverted->SetDirectory(nullptr);
1829  } else {
1830  ATH_MSG_INFO("No leakage systematic uncertainty for ES model "
1831  << m_esmodel);
1832  }
1833 
1834  // ... Zee S2 profile (needed for gain switch syst).
1835  m_zeeES2Profile.reset(
1836  checked_own_cast<TH1*>(rootFile->Get("ZeeEnergyProfiles/p2MC")));
1837  // mean Zee energy as function of eta
1838  m_meanZeeProfile.reset(checked_own_cast<TProfile*>(
1839  rootFile->Get("ZeeMeanET/MC_eta_vs_et_profiled")));
1840  // OK, now we are all initialized and everything went fine
1841  m_initialized = true;
1842  return 1;
1843 }

◆ 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 4562 of file egammaEnergyCorrectionTool.cxx.

4562  {
4563 
4564  return std::abs(cl_eta) >= 1.35 && std::abs(cl_eta) <= 1.55;
4565 }

◆ mcConstantTerm()

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

Definition at line 2575 of file egammaEnergyCorrectionTool.cxx.

2575  {
2576 
2577  double aeta = std::abs(cl_eta);
2578  double cst = 0.;
2579 
2580  if (aeta < 0.6)
2581  cst = 0.005;
2582 
2583  else if (aeta < 1.75)
2584  cst = 0.003;
2585 
2586  else if (aeta < 2.5)
2587  cst = 0.0055 * (2.69 - aeta);
2588 
2589  // cst = 0.005;
2590 
2591  return cst;
2592 }

◆ mcNoiseTerm()

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

Definition at line 2556 of file egammaEnergyCorrectionTool.cxx.

2556  {
2557 
2558  double aeta = std::abs(cl_eta);
2559  double noise = 0.;
2560 
2561  double noise37[25] = {0.27, 0.27, 0.27, 0.27, 0.27, 0.26, 0.25, 0.23, 0.21,
2562  0.19, 0.17, 0.16, 0.15, 0.14, 0.27, 0.23, 0.17, 0.15,
2563  0.13, 0.10, 0.07, 0.06, 0.05, 0.04, 0.03};
2564 
2565  int ieta = (int)(aeta / 0.1);
2566 
2567  if (ieta >= 0 && ieta < 25)
2568  noise = noise37[ieta] * cosh(cl_eta); // the above parametrization is vs ET
2569 
2570  return noise;
2571 }

◆ mcSamplingTerm()

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

Definition at line 2520 of file egammaEnergyCorrectionTool.cxx.

2520  {
2521 
2522  double aeta = std::abs(cl_eta);
2523  double sampling = 0.;
2524 
2525  if (aeta < 0.8)
2526  sampling = 0.091;
2527 
2528  else if (aeta < 1.37)
2529  sampling = 0.036 + 0.130 * aeta;
2530 
2531  else if (aeta < 1.52)
2532  sampling = 0.27;
2533 
2534  else if (aeta < 2.0)
2535  sampling = 0.85 - 0.36 * aeta;
2536 
2537  else if (aeta < 2.3)
2538  sampling = 0.16;
2539 
2540  else if (aeta < 2.5)
2541  sampling = -1.05 + 0.52 * aeta;
2542 
2543  return sampling;
2544 }

◆ mcSamplingTermRelError()

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

Definition at line 2548 of file egammaEnergyCorrectionTool.cxx.

2548  {
2549 
2550  (void)cl_eta; // not used
2551  return 0.1; // when will this be improved?
2552 }

◆ mcZPeakResolution()

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

Definition at line 2618 of file egammaEnergyCorrectionTool.cxx.

2618  {
2619 
2620  return m_peakResMC->GetBinContent(
2621  std::as_const(*m_peakResMC).GetXaxis()->FindBin(cl_eta));
2622 }

◆ 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 4567 of file egammaEnergyCorrectionTool.cxx.

4567  {
4568 
4569  double newEta = cl_eta;
4570 
4571  if (!isInCrack(newEta))
4572  return newEta;
4573 
4574  if (newEta >= 1.35 && newEta <= 1.45)
4575  newEta = 1.349;
4576  if (newEta >= 1.45 && newEta <= 1.55)
4577  newEta = 1.551;
4578 
4579  if (newEta >= -1.55 && newEta <= -1.45)
4580  newEta = -1.551;
4581  if (newEta >= -1.45 && newEta <= -1.35)
4582  newEta = -1.349;
4583 
4584  return newEta;
4585 }

◆ pileUpTerm()

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

Definition at line 4587 of file egammaEnergyCorrectionTool.cxx.

4588  {
4589 
4590  double pileupNoise;
4591 
4592  // release 21 for <mu> =32 (combined 2015-2016-2017 dataset), pileup noise =
4593  // f(Et) for superclusters
4594  if (m_esmodel == egEnergyCorr::es2017_R21_v0 or
4595  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4596  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4597  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4598  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4599  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4600  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4601  double avgmu = 32;
4602  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4603  avgmu = 34.;
4604 
4605  double et = energy / cosh(eta);
4606  if (et < 5000.)
4607  et = 5000.;
4608  if (et > 50000.)
4609  et = 50000.;
4610  pileupNoise = sqrt(avgmu) * (60. + 40. * log(et / 10000.) / log(5.));
4611  } else {
4612  // approximate pileup noise addition to the total noise in MeV for
4613  // <mu_data> (2012) = 20 converted photons and electrons
4614  pileupNoise = 240.;
4615  // unconverted photons, different values in barrel and end-cap
4616  if (particle_type == 1) {
4617  if (std::abs(eta) < 1.4)
4618  pileupNoise = 200.;
4619  }
4620  }
4621  return pileupNoise;
4622 }

◆ 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 2804 of file egammaEnergyCorrectionTool.cxx.

2807  {
2808  int eg_resolution_ptype;
2809  if (ptype == PATCore::ParticleType::Electron)
2810  eg_resolution_ptype = 0;
2811  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2812  eg_resolution_ptype = 1;
2813  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2814  eg_resolution_ptype = 2;
2815  else {
2816  ATH_MSG_FATAL("cannot understand particle type");
2817  return -1;
2818  }
2819 
2820  double sig2 = 0.;
2821 
2822  if (m_use_new_resolution_model) {
2823  sig2 = pow(m_resolution_tool->getResolution(eg_resolution_ptype, energy,
2824  cl_eta, resType),
2825  2);
2826  const double et = energy / cosh(cl_eta);
2827  sig2 += pow(pileUpTerm(energy, cl_eta, eg_resolution_ptype) / et,
2828  2); // TODO: why et and not E?
2829  } else { // OLD model
2830 
2831  double energyGeV = energy / GeV;
2832  double a = mcSamplingTerm(cl_eta);
2833  double b = mcNoiseTerm(cl_eta);
2834  double c = mcConstantTerm(cl_eta);
2835  sig2 = a * a / energyGeV + b * b / energyGeV / energyGeV + c * c;
2836  }
2837 
2838  if (withCT and fast) {
2839  throw std::runtime_error(
2840  "It doesn't make sense to ask resolution fast sim + additional CT."
2841  " The resolution on data is FULL sim resolution + CT");
2842  }
2843 
2844  if (fast and std::abs(cl_eta) < 2.5) {
2845  if (m_esmodel == egEnergyCorr::es2017 or
2846  m_esmodel == egEnergyCorr::es2017_summer or
2847  m_esmodel == egEnergyCorr::es2017_summer_improved or
2848  m_esmodel == egEnergyCorr::es2017_summer_final or
2849  m_esmodel == egEnergyCorr::es2017_R21_PRE or
2850  m_esmodel == egEnergyCorr::es2015_5TeV or
2851  m_esmodel == egEnergyCorr::es2015PRE or
2852  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
2853  m_esmodel == egEnergyCorr::es2015cPRE or
2854  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
2855  m_esmodel == egEnergyCorr::es2015c_summer or
2856  m_esmodel == egEnergyCorr::es2016PRE or
2857  m_esmodel == egEnergyCorr::es2017_R21_v0 or
2858  m_esmodel == egEnergyCorr::es2017_R21_v1 or
2859  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
2860  m_esmodel == egEnergyCorr::es2018_R21_v0 or
2861  m_esmodel == egEnergyCorr::es2018_R21_v1 or
2862  m_esmodel == egEnergyCorr::es2022_R22_PRE or
2863  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2864 
2865  double ratio_IQR_full_fast = 1.;
2866  const double ptGeV = energy / cosh(cl_eta) / 1E3;
2867 
2868  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
2869  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2870  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
2871  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
2872  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
2873  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2874  //
2875  // for es2017_R21_v1, histograms contain directly values of
2876  // deltaSigma**2 of relative energy resolution (FastSIm-FulSim) so need
2877  // to subtract this value to get the sigma**2 of FastSim
2878 
2879  if (ptype == PATCore::ParticleType::Electron)
2880  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_electron, cl_eta,
2881  ptGeV, true, true, true, true);
2882  if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2883  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_unconverted, cl_eta,
2884  ptGeV, true, true, true, true);
2885  if (ptype == PATCore::ParticleType::ConvertedPhoton)
2886  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_converted, cl_eta,
2887  ptGeV, true, true, true, true);
2888  if (sig2 < 0.)
2889  sig2 = 0.;
2890  } else {
2891  if (ptype == PATCore::ParticleType::Electron) {
2892  ratio_IQR_full_fast = getValueHistAt(
2893  *m_G4OverAFII_resolution_electron, ptGeV, cl_eta, true, false);
2894  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
2895  ratio_IQR_full_fast = getValueHistAt(
2896  *m_G4OverAFII_resolution_unconverted, ptGeV, cl_eta, true, false);
2897  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
2898  ratio_IQR_full_fast = getValueHistAt(
2899  *m_G4OverAFII_resolution_converted, ptGeV, cl_eta, true, false);
2900  }
2901 
2902  sig2 /= ratio_IQR_full_fast * ratio_IQR_full_fast;
2903  }
2904  }
2905  }
2906 
2907  // add the additional constant term from the Zee data/MC measurement
2908  if (withCT)
2909  sig2 += pow(
2910  dataConstantTerm(m_use_etaCalo_scales ? cl_etaCalo : cl_eta),
2911  2); // TODO: is it correct? Or should be += -c**2 + (c + deltac) ** 2 ?
2912 
2913  return sqrt(sig2);
2914 }

◆ resolutionError()

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

Definition at line 2765 of file egammaEnergyCorrectionTool.cxx.

2767  {
2768 
2769  double Cdata = dataConstantTerm(cl_eta);
2770  double Cdata_cor = dataConstantTermCorError(cl_eta);
2771  double Cdata_err = dataConstantTermError(cl_eta);
2772 
2773  double Cdata_unc = 0.;
2774  if (Cdata_err > Cdata_cor)
2775  Cdata_unc = sqrt(Cdata_err * Cdata_err - Cdata_cor * Cdata_cor);
2776  if (Cdata_unc < 0.001)
2777  Cdata_unc = 0.001; // preserve at least the stat error
2778 
2779  double Smc = mcSamplingTerm(cl_eta);
2780  double Smc_err = mcSamplingTermRelError(cl_eta);
2781 
2782  double central = fcn_sigma(energy, Cdata, 0., Smc, 0.);
2783 
2784  double err1 = fcn_sigma(energy, Cdata, Cdata_unc, Smc, 0.) - central;
2785  double err2 = fcn_sigma(energy, Cdata, -Cdata_unc, Smc, 0.) - central;
2786  double err3 = fcn_sigma(energy, Cdata, -Cdata_cor, Smc, Smc_err) - central;
2787  double err4 = -err3;
2788 
2789  errUp = 0;
2790  if (err1 > 0)
2791  errUp = sqrt(errUp * errUp + err1 * err1);
2792  if (err2 > 0)
2793  errUp = sqrt(errUp * errUp + err2 * err2);
2794  if (err3 > 0)
2795  errUp = sqrt(errUp * errUp + err3 * err3);
2796  if (err4 > 0)
2797  errUp = sqrt(errUp * errUp + err4 * err4);
2798 
2799  errDown = -errUp;
2800 }

◆ setADCTool()

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

Definition at line 454 of file egammaEnergyCorrectionTool.h.

454 { m_ADCLinearity_tool = t; }

◆ setApplyL2GainCorrection()

void AtlasRoot::egammaEnergyCorrectionTool::setApplyL2GainCorrection ( )
inline

Definition at line 445 of file egammaEnergyCorrectionTool.h.

445 { m_useL2GainCorrection = true; }

◆ setApplyL2GainInterpolation()

void AtlasRoot::egammaEnergyCorrectionTool::setApplyL2GainInterpolation ( )
inline

Definition at line 446 of file egammaEnergyCorrectionTool.h.

446 { m_useL2GainInterpolation = true; }

◆ setApplyLeakageCorrection()

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

Definition at line 449 of file egammaEnergyCorrectionTool.h.

449  {
450  m_useLeakageCorrection = true;
451  m_usepTInterpolationForLeakage = interpt;
452  }

◆ setESModel()

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

Definition at line 373 of file egammaEnergyCorrectionTool.h.

373 { m_esmodel = val; }

◆ setFileName()

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

Definition at line 383 of file egammaEnergyCorrectionTool.h.

383 { 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 386 of file egammaEnergyCorrectionTool.h.

386 { m_RunNumber = runn; }

◆ use_temp_correction201215()

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

Definition at line 390 of file egammaEnergyCorrectionTool.h.

390  {
391  m_use_temp_correction201215 = flag;
392  }

◆ use_temp_correction201516()

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

Definition at line 393 of file egammaEnergyCorrectionTool.h.

393  {
394  m_use_temp_correction201516 = flag;
395  }

◆ use_uA2MeV_2015_first2weeks_correction()

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

Definition at line 396 of file egammaEnergyCorrectionTool.h.

396  {
397  m_use_uA2MeV_2015_first2weeks_correction = flag;
398  }

◆ useStatErrorScaling()

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

Definition at line 388 of file egammaEnergyCorrectionTool.h.

388 { m_use_stat_error_scaling = flag; }

◆ variationName() [1/2]

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

Definition at line 5116 of file egammaEnergyCorrectionTool.cxx.

5117  {
5118  switch (var) {
5119  case egEnergyCorr::Resolution::None:
5120  return "Resolution::None";
5121  case egEnergyCorr::Resolution::Nominal:
5122  return "Resolution::Nominal";
5123  case egEnergyCorr::Resolution::AllDown:
5124  return "Resolution::AllDown";
5125  case egEnergyCorr::Resolution::AllUp:
5126  return "Resolution::AllUp";
5127  case egEnergyCorr::Resolution::ZSmearingUp:
5128  return "Resolution::ZSmearingUp";
5129  case egEnergyCorr::Resolution::ZSmearingDown:
5130  return "Resolution::ZSmearingDown";
5131  case egEnergyCorr::Resolution::SamplingTermUp:
5132  return "Resolution::SamplingTermUp";
5133  case egEnergyCorr::Resolution::SamplingTermDown:
5134  return "Resolution::SamplingTermDown";
5135  case egEnergyCorr::Resolution::MaterialIDUp:
5136  return "Resolution::MaterialUp";
5137  case egEnergyCorr::Resolution::MaterialIDDown:
5138  return "Resolution::MaterialDown";
5139  case egEnergyCorr::Resolution::MaterialCaloUp:
5140  return "Resolution::MaterialUp";
5141  case egEnergyCorr::Resolution::MaterialCaloDown:
5142  return "Resolution::MaterialDown";
5143  case egEnergyCorr::Resolution::MaterialCryoUp:
5144  return "Resolution::MaterialUp";
5145  case egEnergyCorr::Resolution::MaterialCryoDown:
5146  return "Resolution::MaterialDown";
5147  case egEnergyCorr::Resolution::MaterialGapUp:
5148  return "Resolution::MaterialUp";
5149  case egEnergyCorr::Resolution::MaterialGapDown:
5150  return "Resolution::MaterialDown";
5151  case egEnergyCorr::Resolution::PileUpUp:
5152  return "Resolution::PileUpUp";
5153  case egEnergyCorr::Resolution::PileUpDown:
5154  return "Resolution::PileUpDown";
5155  case egEnergyCorr::Resolution::MaterialPP0Up:
5156  return "Resolution::MaterialPP0Up";
5157  case egEnergyCorr::Resolution::MaterialPP0Down:
5158  return "Resolution::MaterialPP0Down";
5159  case egEnergyCorr::Resolution::MaterialIBLUp:
5160  return "Resolution::MaterialIBLUp";
5161  case egEnergyCorr::Resolution::MaterialIBLDown:
5162  return "Resolution::MaterialIBLDown";
5163  case egEnergyCorr::Resolution::af2Up:
5164  return "Resolution::af2Up";
5165  case egEnergyCorr::Resolution::af2Down:
5166  return "Resolution::af2Down";
5167  case egEnergyCorr::Resolution::OFCUp:
5168  return "Resolution::OFCUp";
5169  case egEnergyCorr::Resolution::OFCDown:
5170  return "Resolution::OFCDown";
5171  case egEnergyCorr::Resolution::LastResolutionVariation:
5172  return "LastResolutionVariation";
5173  default:
5174  return "Resolution::Unknown";
5175  }
5176 }

◆ variationName() [2/2]

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

Definition at line 4934 of file egammaEnergyCorrectionTool.cxx.

4935  {
4936  switch (var) {
4937  case egEnergyCorr::Scale::None:
4938  return "None";
4939  case egEnergyCorr::Scale::Nominal:
4940  return "Nominal";
4941  case egEnergyCorr::Scale::topoClusterThresUp:
4942  return "topoClusterThresUp";
4943  case egEnergyCorr::Scale::topoClusterThresDown:
4944  return "topoClusterThresDown";
4945  case egEnergyCorr::Scale::MomentumUp:
4946  return "MomentumUp";
4947  case egEnergyCorr::Scale::MomentumDown:
4948  return "MomentumDown";
4949  case egEnergyCorr::Scale::ZeeStatUp:
4950  return "ZeeStatUp";
4951  case egEnergyCorr::Scale::ZeeStatDown:
4952  return "ZeeStatDown";
4953  case egEnergyCorr::Scale::ZeeSystUp:
4954  return "ZeeSystUp";
4955  case egEnergyCorr::Scale::ZeeSystDown:
4956  return "ZeeSystDown";
4957  case egEnergyCorr::Scale::ZeePhysUp:
4958  return "ZeePhysUp";
4959  case egEnergyCorr::Scale::ZeePhysDown:
4960  return "ZeePhysDown";
4961  case egEnergyCorr::Scale::ZeeAllUp:
4962  return "ZeeAllUp";
4963  case egEnergyCorr::Scale::ZeeAllDown:
4964  return "ZeeAllDown";
4965  case egEnergyCorr::Scale::LArCalibUp:
4966  return "LArCalibUp";
4967  case egEnergyCorr::Scale::LArCalibDown:
4968  return "LArCalibDown";
4969  case egEnergyCorr::Scale::LArUnconvCalibUp:
4970  return "LArUnconvCalibUp";
4971  case egEnergyCorr::Scale::LArUnconvCalibDown:
4972  return "LArUnconvCalibDown";
4973  case egEnergyCorr::Scale::LArElecCalibUp:
4974  return "LArElecCalibUp";
4975  case egEnergyCorr::Scale::LArElecCalibDown:
4976  return "LArElecCalibDown";
4977  case egEnergyCorr::Scale::LArCalibExtra2015PreUp:
4978  return "LArCalibExtra2015PreUp";
4979  case egEnergyCorr::Scale::LArCalibExtra2015PreDown:
4980  return "LArCalibExtra2015PreDown";
4981  case egEnergyCorr::Scale::LArElecUnconvUp:
4982  return "LArElecUnconvUp";
4983  case egEnergyCorr::Scale::LArElecUnconvDown:
4984  return "LArElecUnconvDown";
4985  case egEnergyCorr::Scale::G4Up:
4986  return "G4Up";
4987  case egEnergyCorr::Scale::G4Down:
4988  return "G4Down";
4989  case egEnergyCorr::Scale::PSUp:
4990  return "PSUp";
4991  case egEnergyCorr::Scale::PSDown:
4992  return "PSDown";
4993  case egEnergyCorr::Scale::PSb12Up:
4994  return "PSb12Up";
4995  case egEnergyCorr::Scale::PSb12Down:
4996  return "PSb12Down";
4997  case egEnergyCorr::Scale::S12Up:
4998  return "S12Up";
4999  case egEnergyCorr::Scale::S12Down:
5000  return "S12Down";
5001  case egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up:
5002  return "S12ExtraLastEtaBinRun2Up";
5003  case egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down:
5004  return "S12ExtraLastEtaBinRun2Down";
5005  case egEnergyCorr::Scale::MatIDUp:
5006  return "MatIDUp";
5007  case egEnergyCorr::Scale::MatIDDown:
5008  return "MatIDDown";
5009  case egEnergyCorr::Scale::MatCryoUp:
5010  return "MatCryoUp";
5011  case egEnergyCorr::Scale::MatCryoDown:
5012  return "MatCryoDown";
5013  case egEnergyCorr::Scale::MatCaloUp:
5014  return "MatCaloUp";
5015  case egEnergyCorr::Scale::MatCaloDown:
5016  return "MatCaloDown";
5017  case egEnergyCorr::Scale::L1GainUp:
5018  return "L1GainUp";
5019  case egEnergyCorr::Scale::L1GainDown:
5020  return "L1GainDown";
5021  case egEnergyCorr::Scale::L2GainUp:
5022  return "L2GainUp";
5023  case egEnergyCorr::Scale::L2GainDown:
5024  return "L2GainDown";
5025  case egEnergyCorr::Scale::L2LowGainDown:
5026  return "L2LowGainDown";
5027  case egEnergyCorr::Scale::L2LowGainUp:
5028  return "L2LowGainUp";
5029  case egEnergyCorr::Scale::L2MediumGainDown:
5030  return "L2MediumGainDown";
5031  case egEnergyCorr::Scale::L2MediumGainUp:
5032  return "L2MediumGainUp";
5033  case egEnergyCorr::Scale::ADCLinUp:
5034  return "ADCLinUp";
5035  case egEnergyCorr::Scale::ADCLinDown:
5036  return "ADCLinDown";
5037  case egEnergyCorr::Scale::LeakageElecUp:
5038  return "LeakageElecUp";
5039  case egEnergyCorr::Scale::LeakageElecDown:
5040  return "LeakageElecDown";
5041  case egEnergyCorr::Scale::ConvRecoUp:
5042  return "ConvRecoUp";
5043  case egEnergyCorr::Scale::ConvRecoDown:
5044  return "ConvRecoDown";
5045  case egEnergyCorr::Scale::af2Up:
5046  return "af2Up";
5047  case egEnergyCorr::Scale::af2Down:
5048  return "af2Down";
5049  case egEnergyCorr::Scale::LeakageUnconvUp:
5050  return "LeakageUnconvUp";
5051  case egEnergyCorr::Scale::LeakageUnconvDown:
5052  return "LeakageUnconvDown";
5053  case egEnergyCorr::Scale::LeakageConvUp:
5054  return "LeakageConvUp";
5055  case egEnergyCorr::Scale::LeakageConvDown:
5056  return "LeakageConvDown";
5057  case egEnergyCorr::Scale::ConvEfficiencyUp:
5058  return "ConvEfficiencyUp";
5059  case egEnergyCorr::Scale::ConvEfficiencyDown:
5060  return "ConvEfficiencyDown";
5061  case egEnergyCorr::Scale::ConvFakeRateUp:
5062  return "ConvFakeRateUp";
5063  case egEnergyCorr::Scale::ConvFakeRateDown:
5064  return "ConvFakeRateDown";
5065  case egEnergyCorr::Scale::ConvRadiusUp:
5066  return "ConvRadiusUp";
5067  case egEnergyCorr::Scale::ConvRadiusDown:
5068  return "ConvRadiusDown";
5069  case egEnergyCorr::Scale::PedestalUp:
5070  return "PedestalUp";
5071  case egEnergyCorr::Scale::PedestalDown:
5072  return "PedestalDown";
5073  case egEnergyCorr::Scale::AllUp:
5074  return "AllUp";
5075  case egEnergyCorr::Scale::AllDown:
5076  return "AllDown";
5077  case egEnergyCorr::Scale::AllCorrelatedUp:
5078  return "AllCorrelatedUp";
5079  case egEnergyCorr::Scale::AllCorrelatedDown:
5080  return "AllCorrelatedDown";
5081  case egEnergyCorr::Scale::LArTemperature2015PreUp:
5082  return "LArTemperature2015PreUp";
5083  case egEnergyCorr::Scale::LArTemperature2015PreDown:
5084  return "LArTemperature2015PreDown";
5085  case egEnergyCorr::Scale::LArTemperature2016PreUp:
5086  return "LArTemperature2016PreUp";
5087  case egEnergyCorr::Scale::LArTemperature2016PreDown:
5088  return "LArTemperature2016PreDown";
5089  case egEnergyCorr::Scale::E4ScintillatorUp:
5090  return "E4ScintillatorUp";
5091  case egEnergyCorr::Scale::E4ScintillatorDown:
5092  return "E4ScintillatorDown";
5093  case egEnergyCorr::Scale::MatPP0Up:
5094  return "MatPP0Up";
5095  case egEnergyCorr::Scale::MatPP0Down:
5096  return "MatPP0Down";
5097  case egEnergyCorr::Scale::Wtots1Up:
5098  return "Wtots1Up";
5099  case egEnergyCorr::Scale::Wtots1Down:
5100  return "Wtots1Down";
5101  case egEnergyCorr::Scale::LastScaleVariation:
5102  return "LastScaleVariation";
5103  case egEnergyCorr::Scale::OFCUp:
5104  return "OFCUp";
5105  case egEnergyCorr::Scale::OFCDown:
5106  return "OFCDown";
5107  case egEnergyCorr::Scale::EXTRARUN3PREUp:
5108  return "EXTRARUN3PREUp";
5109  case egEnergyCorr::Scale::EXTRARUN3PREDown:
5110  return "EXTRARUN3PREDown";
5111  default:
5112  return "Unknown";
5113  }
5114 }

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 463 of file egammaEnergyCorrectionTool.h.

◆ m_applyPSCorrection

bool AtlasRoot::egammaEnergyCorrectionTool::m_applyPSCorrection
private

Definition at line 798 of file egammaEnergyCorrectionTool.h.

◆ m_applyS12Correction

bool AtlasRoot::egammaEnergyCorrectionTool::m_applyS12Correction
private

Definition at line 799 of file egammaEnergyCorrectionTool.h.

◆ m_aPSNom

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

Definition at line 635 of file egammaEnergyCorrectionTool.h.

◆ m_aS12Nom

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

Definition at line 638 of file egammaEnergyCorrectionTool.h.

◆ m_begRunNumber

unsigned int AtlasRoot::egammaEnergyCorrectionTool::m_begRunNumber
private

Definition at line 629 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigA

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

Definition at line 768 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigEpLp

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

Definition at line 769 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigFpMX

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

Definition at line 770 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigIBL

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

Definition at line 772 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigN

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

Definition at line 771 of file egammaEnergyCorrectionTool.h.

◆ m_convertedBias_ConfigPP0

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

Definition at line 773 of file egammaEnergyCorrectionTool.h.

◆ m_convFakeRate

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

Definition at line 711 of file egammaEnergyCorrectionTool.h.

◆ m_convFakeRate_2D

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

Definition at line 713 of file egammaEnergyCorrectionTool.h.

◆ m_convRadius

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

Definition at line 710 of file egammaEnergyCorrectionTool.h.

◆ m_convRecoEfficiency

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

Definition at line 712 of file egammaEnergyCorrectionTool.h.

◆ m_convRecoEfficiency_2D

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

Definition at line 714 of file egammaEnergyCorrectionTool.h.

◆ m_daPSb12

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

Definition at line 637 of file egammaEnergyCorrectionTool.h.

◆ m_daPSCor

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

Definition at line 636 of file egammaEnergyCorrectionTool.h.

◆ m_daS12Cor

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

Definition at line 639 of file egammaEnergyCorrectionTool.h.

◆ m_dX_ID_Nom

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

Definition at line 661 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_G4

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

Definition at line 667 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_GL1

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

Definition at line 669 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_LAr

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

Definition at line 668 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPAcc_Nom

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

Definition at line 666 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPPS_LAr

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

Definition at line 664 of file egammaEnergyCorrectionTool.h.

◆ m_dX_IPPS_Nom

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

Definition at line 663 of file egammaEnergyCorrectionTool.h.

◆ m_dX_PSAcc_G4

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

Definition at line 672 of file egammaEnergyCorrectionTool.h.

◆ m_dX_PSAcc_LAr

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

Definition at line 673 of file egammaEnergyCorrectionTool.h.

◆ m_dX_PSAcc_Nom

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

Definition at line 671 of file egammaEnergyCorrectionTool.h.

◆ m_e1hg_tool

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

Definition at line 466 of file egammaEnergyCorrectionTool.h.

◆ m_E4ConvertedEtaBins

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

Definition at line 686 of file egammaEnergyCorrectionTool.h.

◆ m_E4ConvertedGraphs

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

Definition at line 687 of file egammaEnergyCorrectionTool.h.

◆ m_E4ElectronEtaBins

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

Definition at line 682 of file egammaEnergyCorrectionTool.h.

◆ m_E4ElectronGraphs

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

Definition at line 683 of file egammaEnergyCorrectionTool.h.

◆ m_E4UnconvertedEtaBins

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

Definition at line 684 of file egammaEnergyCorrectionTool.h.

◆ m_E4UnconvertedGraphs

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

Definition at line 685 of file egammaEnergyCorrectionTool.h.

◆ m_EaccConvertedEtaBins

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

Definition at line 700 of file egammaEnergyCorrectionTool.h.

◆ m_EaccConvertedGraphs

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

Definition at line 701 of file egammaEnergyCorrectionTool.h.

◆ m_EaccElectronEtaBins

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

Definition at line 696 of file egammaEnergyCorrectionTool.h.

◆ m_EaccElectronGraphs

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

Definition at line 697 of file egammaEnergyCorrectionTool.h.

◆ m_EaccUnconvertedEtaBins

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

Definition at line 698 of file egammaEnergyCorrectionTool.h.

◆ m_EaccUnconvertedGraphs

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

Definition at line 699 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigA

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

Definition at line 756 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigEpLp

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

Definition at line 757 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigFpMX

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

Definition at line 758 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigIBL

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

Definition at line 760 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigN

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

Definition at line 759 of file egammaEnergyCorrectionTool.h.

◆ m_electronBias_ConfigPP0

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

Definition at line 761 of file egammaEnergyCorrectionTool.h.

◆ m_endRunNumber

unsigned int AtlasRoot::egammaEnergyCorrectionTool::m_endRunNumber
private

Definition at line 630 of file egammaEnergyCorrectionTool.h.

◆ m_esmodel

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

Definition at line 791 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_converted

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

Definition at line 778 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_converted_2D

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

Definition at line 781 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_electron

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

Definition at line 777 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_electron_2D

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

Definition at line 780 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_resolution_converted

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

Definition at line 787 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_resolution_electron

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

Definition at line 785 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_resolution_unconverted

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

Definition at line 786 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_unconverted

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

Definition at line 779 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverAFII_unconverted_2D

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

Definition at line 782 of file egammaEnergyCorrectionTool.h.

◆ m_G4OverFrSh

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

Definition at line 783 of file egammaEnergyCorrectionTool.h.

◆ m_gain_tool

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

Definition at line 460 of file egammaEnergyCorrectionTool.h.

◆ m_gain_tool_run2

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

Definition at line 462 of file egammaEnergyCorrectionTool.h.

◆ m_getMaterialDelta

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

Definition at line 465 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 801 of file egammaEnergyCorrectionTool.h.

◆ m_leakageConverted

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

Definition at line 716 of file egammaEnergyCorrectionTool.h.

◆ m_leakageElectron

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

Definition at line 718 of file egammaEnergyCorrectionTool.h.

◆ m_leakageUnconverted

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

Definition at line 717 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 745 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronCstTerm

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

Definition at line 746 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronEtaBins

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

Definition at line 751 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronGraphs

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

Definition at line 752 of file egammaEnergyCorrectionTool.h.

◆ m_matElectronScale

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

Definition at line 743 of file egammaEnergyCorrectionTool.h.

◆ m_matUnconvertedScale

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

Definition at line 744 of file egammaEnergyCorrectionTool.h.

◆ m_matX0Additions

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

Definition at line 747 of file egammaEnergyCorrectionTool.h.

◆ m_meanZeeProfile

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

Definition at line 653 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 658 of file egammaEnergyCorrectionTool.h.

◆ m_peakResMC

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

Definition at line 659 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL0

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

Definition at line 703 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL1

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

Definition at line 704 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL2

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

Definition at line 705 of file egammaEnergyCorrectionTool.h.

◆ m_pedestalL3

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

Definition at line 706 of file egammaEnergyCorrectionTool.h.

◆ m_pedestals_es2017

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

Definition at line 708 of file egammaEnergyCorrectionTool.h.

◆ m_pp0_conv

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

Definition at line 724 of file egammaEnergyCorrectionTool.h.

◆ m_pp0_elec

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

Definition at line 722 of file egammaEnergyCorrectionTool.h.

◆ m_pp0_unconv

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

Definition at line 723 of file egammaEnergyCorrectionTool.h.

◆ m_psConvertedEtaBins

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

Definition at line 679 of file egammaEnergyCorrectionTool.h.

◆ m_psConvertedGraphs

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

Definition at line 680 of file egammaEnergyCorrectionTool.h.

◆ m_psElectronEtaBins

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

Definition at line 675 of file egammaEnergyCorrectionTool.h.

◆ m_psElectronGraphs

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

Definition at line 676 of file egammaEnergyCorrectionTool.h.

◆ m_psUnconvertedEtaBins

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

Definition at line 677 of file egammaEnergyCorrectionTool.h.

◆ m_psUnconvertedGraphs

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

Definition at line 678 of file egammaEnergyCorrectionTool.h.

◆ m_resNom

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

Definition at line 655 of file egammaEnergyCorrectionTool.h.

◆ m_resolution_tool

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

Definition at line 464 of file egammaEnergyCorrectionTool.h.

◆ m_resSyst

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

Definition at line 656 of file egammaEnergyCorrectionTool.h.

◆ m_resSystOFC

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

Definition at line 657 of file egammaEnergyCorrectionTool.h.

◆ m_rootFileName

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

Definition at line 627 of file egammaEnergyCorrectionTool.h.

◆ m_RunNumber

unsigned int AtlasRoot::egammaEnergyCorrectionTool::m_RunNumber
private

Definition at line 631 of file egammaEnergyCorrectionTool.h.

◆ m_s12ConvertedEtaBins

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

Definition at line 693 of file egammaEnergyCorrectionTool.h.

◆ m_s12ConvertedGraphs

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

Definition at line 694 of file egammaEnergyCorrectionTool.h.

◆ m_s12ElectronEtaBins

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

Definition at line 689 of file egammaEnergyCorrectionTool.h.

◆ m_s12ElectronGraphs

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

Definition at line 690 of file egammaEnergyCorrectionTool.h.

◆ m_s12UnconvertedEtaBins

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

Definition at line 691 of file egammaEnergyCorrectionTool.h.

◆ m_s12UnconvertedGraphs

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

Definition at line 692 of file egammaEnergyCorrectionTool.h.

◆ m_trkSyst

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

Definition at line 633 of file egammaEnergyCorrectionTool.h.

◆ m_uA2MeV_2015_first2weeks_correction

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

Definition at line 652 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigA

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

Definition at line 762 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigEpLp

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

Definition at line 763 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigFpMX

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

Definition at line 764 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigIBL

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

Definition at line 766 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigN

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

Definition at line 765 of file egammaEnergyCorrectionTool.h.

◆ m_unconvertedBias_ConfigPP0

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

Definition at line 767 of file egammaEnergyCorrectionTool.h.

◆ m_use_etaCalo_scales

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_etaCalo_scales
private

Definition at line 795 of file egammaEnergyCorrectionTool.h.

◆ m_use_new_resolution_model

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_new_resolution_model
private

Definition at line 802 of file egammaEnergyCorrectionTool.h.

◆ m_use_stat_error_scaling

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_stat_error_scaling
private

Definition at line 803 of file egammaEnergyCorrectionTool.h.

◆ m_use_temp_correction201215

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201215
private

Definition at line 810 of file egammaEnergyCorrectionTool.h.

◆ m_use_temp_correction201516

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201516
private

Definition at line 811 of file egammaEnergyCorrectionTool.h.

◆ m_use_uA2MeV_2015_first2weeks_correction

bool AtlasRoot::egammaEnergyCorrectionTool::m_use_uA2MeV_2015_first2weeks_correction
private

Definition at line 812 of file egammaEnergyCorrectionTool.h.

◆ m_useL2GainCorrection

bool AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainCorrection
private

Definition at line 805 of file egammaEnergyCorrectionTool.h.

◆ m_useL2GainInterpolation

bool AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainInterpolation
private

Definition at line 806 of file egammaEnergyCorrectionTool.h.

◆ m_useLeakageCorrection

bool AtlasRoot::egammaEnergyCorrectionTool::m_useLeakageCorrection
private

Definition at line 807 of file egammaEnergyCorrectionTool.h.

◆ m_usepTInterpolationForLeakage

bool AtlasRoot::egammaEnergyCorrectionTool::m_usepTInterpolationForLeakage
private

Definition at line 808 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 732 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 728 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 730 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 733 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 729 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 731 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 738 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 734 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 736 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 739 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 735 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 737 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_slope_A_data

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

Definition at line 726 of file egammaEnergyCorrectionTool.h.

◆ m_wstot_slope_B_MC

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

Definition at line 727 of file egammaEnergyCorrectionTool.h.

◆ m_zeeES2Profile

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

Definition at line 720 of file egammaEnergyCorrectionTool.h.

◆ m_zeeFwdb

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

Definition at line 647 of file egammaEnergyCorrectionTool.h.

◆ m_zeeFwdk

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

Definition at line 646 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom

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

Definition at line 641 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2015

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

Definition at line 642 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2016

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

Definition at line 643 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2017

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

Definition at line 644 of file egammaEnergyCorrectionTool.h.

◆ m_zeeNom_data2018

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

Definition at line 645 of file egammaEnergyCorrectionTool.h.

◆ m_zeePhys

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

Definition at line 651 of file egammaEnergyCorrectionTool.h.

◆ m_zeeSyst

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

Definition at line 649 of file egammaEnergyCorrectionTool.h.

◆ m_zeeSystOFC

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

Definition at line 650 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:664
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:656
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
AtlasRoot::egammaEnergyCorrectionTool::m_rootFileName
std::string m_rootFileName
Definition: egammaEnergyCorrectionTool.h:627
egEnergyCorr::Scale::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:266
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2015
std::unique_ptr< TH1 > m_zeeNom_data2015
Definition: egammaEnergyCorrectionTool.h:642
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:736
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:728
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronCstTerm
std::vector< std::unique_ptr< TH1 > > m_matElectronCstTerm
Definition: egammaEnergyCorrectionTool.h:746
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:343
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:2548
AtlasRoot::egammaEnergyCorrectionTool::m_initialized
bool m_initialized
Definition: egammaEnergyCorrectionTool.h:801
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigN
std::unique_ptr< TH2 > m_unconvertedBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:765
egEnergyCorr::es2011d
@ es2011d
Definition: egammaEnergyCorrectionTool.h:291
max
#define max(a, b)
Definition: cfImp.cxx:41
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:768
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigPP0
std::unique_ptr< TH2 > m_unconvertedBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:767
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:655
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:699
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:676
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:630
AtlasRoot::egammaEnergyCorrectionTool::m_leakageElectron
std::unique_ptr< TH1 > m_leakageElectron
Definition: egammaEnergyCorrectionTool.h:718
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:3040
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
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:799
AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedEtaBins
std::unique_ptr< TAxis > m_s12ConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:693
AtlasRoot::egammaEnergyCorrectionTool::m_zeeES2Profile
std::unique_ptr< TH1 > m_zeeES2Profile
Definition: egammaEnergyCorrectionTool.h:720
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_B_MC
std::unique_ptr< TH1 > m_wstot_slope_B_MC
Definition: egammaEnergyCorrectionTool.h:727
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:2655
AtlasRoot::egammaEnergyCorrectionTool::getE4NonLinearity
double getE4NonLinearity(double cl_eta, double meanE, PATCore::ParticleType::Type) const
Definition: egammaEnergyCorrectionTool.cxx:3659
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_elec
std::unique_ptr< TH2 > m_pp0_elec
Definition: egammaEnergyCorrectionTool.h:722
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:1992
egEnergyCorr::Scale::LArTemperature2015PreDown
@ LArTemperature2015PreDown
Definition: egammaEnergyCorrectionTool.h:168
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigEpLp
std::unique_ptr< TH2 > m_unconvertedBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:763
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:4624
AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedGraphs
std::unique_ptr< TList > m_psConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:680
AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedGraphs
std::unique_ptr< TList > m_s12ConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:694
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:3802
egEnergyCorr::Scale::LArElecCalibUp
@ LArElecCalibUp
Definition: egammaEnergyCorrectionTool.h:159
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
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:686
AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool
std::unique_ptr< egGain::GainTool > m_gain_tool
Definition: egammaEnergyCorrectionTool.h:460
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:638
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:661
AtlasRoot::egammaEnergyCorrectionTool::get_ZeeSyst
double get_ZeeSyst(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:5178
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:744
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:2618
egEnergyCorr::Scale::EXTRARUN3PREDown
@ EXTRARUN3PREDown
Definition: egammaEnergyCorrectionTool.h:270
AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedGraphs
std::unique_ptr< TList > m_s12UnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:692
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:639
egEnergyCorr::Scale::L2LowGainDown
@ L2LowGainDown
Definition: egammaEnergyCorrectionTool.h:229
AtlasRoot::egammaEnergyCorrectionTool::m_e1hg_tool
std::unique_ptr< e1hg_systematics > m_e1hg_tool
Definition: egammaEnergyCorrectionTool.h:466
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:2596
egEnergyCorr::es2011dMedium
@ es2011dMedium
Definition: egammaEnergyCorrectionTool.h:292
AtlasRoot::egammaEnergyCorrectionTool::m_meanZeeProfile
std::unique_ptr< TProfile > m_meanZeeProfile
Definition: egammaEnergyCorrectionTool.h:653
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:4480
AtlasRoot::egammaEnergyCorrectionTool::mcNoiseTerm
static double mcNoiseTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2556
AtlasRoot::egammaEnergyCorrectionTool::m_uA2MeV_2015_first2weeks_correction
std::unique_ptr< TH1 > m_uA2MeV_2015_first2weeks_correction
Definition: egammaEnergyCorrectionTool.h:652
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL1
std::unique_ptr< TH1 > m_pedestalL1
Definition: egammaEnergyCorrectionTool.h:704
AtlasRoot::egammaEnergyCorrectionTool::variationName
static std::string variationName(egEnergyCorr::Scale::Variation &var)
Definition: egammaEnergyCorrectionTool.cxx:4934
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:658
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigFpMX
std::unique_ptr< TH2 > m_unconvertedBias_ConfigFpMX
Definition: egammaEnergyCorrectionTool.h:764
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:713
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:690
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
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
AtlasRoot::egammaEnergyCorrectionTool::m_begRunNumber
unsigned int m_begRunNumber
Definition: egammaEnergyCorrectionTool.h:629
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_electrons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_electrons
Definition: egammaEnergyCorrectionTool.h:735
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:4440
AtlasRoot::egammaEnergyCorrectionTool::m_leakageUnconverted
std::unique_ptr< TH1 > m_leakageUnconverted
Definition: egammaEnergyCorrectionTool.h:717
egEnergyCorr::ConfigN
@ ConfigN
Definition: egammaEnergyCorrectionTool.h:342
egEnergyCorr::Scale::L2GainUp
@ L2GainUp
Definition: egammaEnergyCorrectionTool.h:225
AtlasRoot::egammaEnergyCorrectionTool::m_EaccConvertedEtaBins
std::unique_ptr< TAxis > m_EaccConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:700
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:2575
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_unconverted
std::unique_ptr< TH2 > m_G4OverAFII_resolution_unconverted
Definition: egammaEnergyCorrectionTool.h:786
egEnergyCorr::Scale::LeakageElecDown
@ LeakageElecDown
Definition: egammaEnergyCorrectionTool.h:198
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigIBL
std::unique_ptr< TH2 > m_unconvertedBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:766
AtlasRoot::egammaEnergyCorrectionTool::m_zeeFwdk
std::unique_ptr< const TH1 > m_zeeFwdk
Definition: egammaEnergyCorrectionTool.h:646
AtlasRoot::egammaEnergyCorrectionTool::getLayerNonLinearity
double getLayerNonLinearity(int iLayer, double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
Definition: egammaEnergyCorrectionTool.cxx:3691
AtlasRoot::egammaEnergyCorrectionTool::m_E4ConvertedGraphs
std::unique_ptr< TList > m_E4ConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:687
egEnergyCorr::Scale::L2LowGainUp
@ L2LowGainUp
Definition: egammaEnergyCorrectionTool.h:230
egEnergyCorr::ConfigPP0
@ ConfigPP0
Definition: egammaEnergyCorrectionTool.h:344
AtlasRoot::egammaEnergyCorrectionTool::m_use_stat_error_scaling
bool m_use_stat_error_scaling
Definition: egammaEnergyCorrectionTool.h:803
AtlasRoot::egammaEnergyCorrectionTool::m_usepTInterpolationForLeakage
bool m_usepTInterpolationForLeakage
Definition: egammaEnergyCorrectionTool.h:808
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:4265
AtlasRoot::egammaEnergyCorrectionTool::m_psUnconvertedEtaBins
std::unique_ptr< TAxis > m_psUnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:677
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPPS_Nom
std::unique_ptr< TH1 > m_dX_IPPS_Nom
Definition: egammaEnergyCorrectionTool.h:663
egEnergyCorr::Scale::MomentumUp
@ MomentumUp
Definition: egammaEnergyCorrectionTool.h:137
AtlasRoot::egammaEnergyCorrectionTool::m_RunNumber
unsigned int m_RunNumber
Definition: egammaEnergyCorrectionTool.h:631
PATCore::ParticleType::ConvertedPhoton
@ ConvertedPhoton
Definition: PATCoreEnums.h:39
AtlasRoot::egammaEnergyCorrectionTool::m_use_etaCalo_scales
bool m_use_etaCalo_scales
Definition: egammaEnergyCorrectionTool.h:795
egEnergyCorr::es2015cPRE
@ es2015cPRE
Definition: egammaEnergyCorrectionTool.h:305
AtlasRoot::egammaEnergyCorrectionTool::m_s12ElectronEtaBins
std::unique_ptr< TAxis > m_s12ElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:689
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:3907
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_converted_photons
Definition: egammaEnergyCorrectionTool.h:739
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:4587
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_LAr
std::unique_ptr< TH1 > m_dX_PSAcc_LAr
Definition: egammaEnergyCorrectionTool.h:673
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_electrons
std::unique_ptr< TH1 > m_wstot_pT_data_p1_electrons
Definition: egammaEnergyCorrectionTool.h:729
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:711
AtlasRoot::egammaEnergyCorrectionTool::m_matX0Additions
std::vector< std::unique_ptr< TH1 > > m_matX0Additions
Definition: egammaEnergyCorrectionTool.h:747
AtlasRoot::egammaEnergyCorrectionTool::m_resolution_tool
std::unique_ptr< eg_resolution > m_resolution_tool
Definition: egammaEnergyCorrectionTool.h:464
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:336
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:352
AtlasRoot::egammaEnergyCorrectionTool::m_EaccConvertedGraphs
std::unique_ptr< TList > m_EaccConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:701
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:671
AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedEtaBins
std::unique_ptr< TAxis > m_psConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:679
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:738
AtlasRoot::egammaEnergyCorrectionTool::getAlphaZee
double getAlphaZee(long int runnumber, double eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3119
egEnergyCorr::Scale::LArElecUnconvDown
@ LArElecUnconvDown
Definition: egammaEnergyCorrectionTool.h:162
AtlasRoot::egammaEnergyCorrectionTool::m_use_new_resolution_model
bool m_use_new_resolution_model
Definition: egammaEnergyCorrectionTool.h:802
AtlasRoot::egammaEnergyCorrectionTool::m_psElectronEtaBins
std::unique_ptr< TAxis > m_psElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:675
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:723
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p1_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:731
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p0_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:730
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:651
AtlasRoot::egammaEnergyCorrectionTool::getWtots1Uncertainty
double getWtots1Uncertainty(double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
Definition: egammaEnergyCorrectionTool.cxx:3448
AtlasRoot::egammaEnergyCorrectionTool::m_use_uA2MeV_2015_first2weeks_correction
bool m_use_uA2MeV_2015_first2weeks_correction
Definition: egammaEnergyCorrectionTool.h:812
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:4562
AtlasRoot::egammaEnergyCorrectionTool::fcn_sigma
static double fcn_sigma(double energy, double Cdata, double Cdata_er, double S, double S_er)
Definition: egammaEnergyCorrectionTool.cxx:2918
AtlasRoot::egammaEnergyCorrectionTool::m_esmodel
egEnergyCorr::ESModel m_esmodel
Definition: egammaEnergyCorrectionTool.h:791
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_Nom
std::unique_ptr< TH1 > m_dX_IPAcc_Nom
Definition: egammaEnergyCorrectionTool.h:666
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:798
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:107
AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201516
bool m_use_temp_correction201516
Definition: egammaEnergyCorrectionTool.h:811
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2016
std::unique_ptr< TH1 > m_zeeNom_data2016
Definition: egammaEnergyCorrectionTool.h:643
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigEpLp
std::unique_ptr< TH2 > m_convertedBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:769
AtlasRoot::egammaEnergyCorrectionTool::m_aPSNom
std::unique_ptr< TH1 > m_aPSNom
Definition: egammaEnergyCorrectionTool.h:635
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:4230
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:647
egEnergyCorr::Scale::G4Up
@ G4Up
Definition: egammaEnergyCorrectionTool.h:175
AtlasRoot::egammaEnergyCorrectionTool::nearestEtaBEC
static double nearestEtaBEC(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:4567
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronEtaBins
std::unique_ptr< TAxis > m_matElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:751
AtlasRoot::egammaEnergyCorrectionTool::m_leakageConverted
std::unique_ptr< TH1 > m_leakageConverted
Definition: egammaEnergyCorrectionTool.h:716
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:781
AtlasRoot::egammaEnergyCorrectionTool::m_convRadius
std::unique_ptr< TH1 > m_convRadius
Definition: egammaEnergyCorrectionTool.h:710
egEnergyCorr::Resolution::MaterialCryoDown
@ MaterialCryoDown
Definition: egammaEnergyCorrectionTool.h:83
egEnergyCorr::UNDEFINED
@ UNDEFINED
Definition: egammaEnergyCorrectionTool.h:330
egEnergyCorr::Scale::MatCaloUp
@ MatCaloUp
Definition: egammaEnergyCorrectionTool.h:219
egEnergyCorr::MatCryo
@ MatCryo
Definition: egammaEnergyCorrectionTool.h:351
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL3
std::unique_ptr< TH1 > m_pedestalL3
Definition: egammaEnergyCorrectionTool.h:706
egEnergyCorr::ConfigGp
@ ConfigGp
Definition: egammaEnergyCorrectionTool.h:341
egEnergyCorr::Scale::ZeeStatDown
@ ZeeStatDown
Definition: egammaEnergyCorrectionTool.h:145
AtlasRoot::egammaEnergyCorrectionTool::m_zeeSystOFC
std::unique_ptr< TH1 > m_zeeSystOFC
Definition: egammaEnergyCorrectionTool.h:650
AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronGraphs
std::unique_ptr< TList > m_EaccElectronGraphs
Definition: egammaEnergyCorrectionTool.h:697
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigA
std::unique_ptr< TH2 > m_electronBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:756
AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool_run2
std::unique_ptr< egGain::GainUncertainty > m_gain_tool_run2
Definition: egammaEnergyCorrectionTool.h:462
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:4094
egEnergyCorr::Resolution::None
@ None
Definition: egammaEnergyCorrectionTool.h:59
AtlasRoot::egammaEnergyCorrectionTool::m_E4UnconvertedEtaBins
std::unique_ptr< TAxis > m_E4UnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:684
egEnergyCorr::Resolution::PileUpDown
@ PileUpDown
Definition: egammaEnergyCorrectionTool.h:87
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigFpMX
std::unique_ptr< TH2 > m_convertedBias_ConfigFpMX
Definition: egammaEnergyCorrectionTool.h:770
egEnergyCorr::Scale::E4ScintillatorUp
@ E4ScintillatorUp
Definition: egammaEnergyCorrectionTool.h:179
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_converted
std::unique_ptr< TH1 > m_G4OverAFII_converted
Definition: egammaEnergyCorrectionTool.h:778
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:2765
AtlasRoot::egammaEnergyCorrectionTool::m_convRecoEfficiency_2D
std::unique_ptr< TH2 > m_convRecoEfficiency_2D
Definition: egammaEnergyCorrectionTool.h:714
egEnergyCorr::ConfigEL
@ ConfigEL
Definition: egammaEnergyCorrectionTool.h:339
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigN
std::unique_ptr< TH2 > m_electronBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:759
AtlasRoot::egammaEnergyCorrectionTool::m_EaccUnconvertedEtaBins
std::unique_ptr< TAxis > m_EaccUnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:698
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:2804
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL0
std::unique_ptr< TH1 > m_pedestalL0
Definition: egammaEnergyCorrectionTool.h:703
AtlasRoot::egammaEnergyCorrectionTool::m_daPSCor
std::unique_ptr< TH1 > m_daPSCor
Definition: egammaEnergyCorrectionTool.h:636
egEnergyCorr::Scale::LArCalibExtra2015PreUp
@ LArCalibExtra2015PreUp
Definition: egammaEnergyCorrectionTool.h:165
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigIBL
std::unique_ptr< TH2 > m_convertedBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:772
AtlasRoot::egammaEnergyCorrectionTool::m_useLeakageCorrection
bool m_useLeakageCorrection
Definition: egammaEnergyCorrectionTool.h:807
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:4383
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:678
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
egEnergyCorr::es2016PRE
@ es2016PRE
Definition: egammaEnergyCorrectionTool.h:308
egEnergyCorr::MatID
@ MatID
Definition: egammaEnergyCorrectionTool.h:350
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL2
std::unique_ptr< TH1 > m_pedestalL2
Definition: egammaEnergyCorrectionTool.h:705
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:3999
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
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down
@ S12ExtraLastEtaBinRun2Down
Definition: egammaEnergyCorrectionTool.h:212
egEnergyCorr::ConfigFMX
@ ConfigFMX
Definition: egammaEnergyCorrectionTool.h:340
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:657
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:2934
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_conv
std::unique_ptr< TH2 > m_pp0_conv
Definition: egammaEnergyCorrectionTool.h:724
AtlasRoot::egammaEnergyCorrectionTool::m_matConvertedScale
std::vector< std::unique_ptr< TH1 > > m_matConvertedScale
Definition: egammaEnergyCorrectionTool.h:745
AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainInterpolation
bool m_useL2GainInterpolation
Definition: egammaEnergyCorrectionTool.h:806
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
AtlasRoot::egammaEnergyCorrectionTool::mcSamplingTerm
static double mcSamplingTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2520
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:785
AtlasRoot::egammaEnergyCorrectionTool::m_getMaterialDelta
std::unique_ptr< get_MaterialResolutionEffect > m_getMaterialDelta
Definition: egammaEnergyCorrectionTool.h:465
egEnergyCorr::Scale::E4ScintillatorDown
@ E4ScintillatorDown
Definition: egammaEnergyCorrectionTool.h:180
AtlasRoot::egammaEnergyCorrectionTool::m_pedestals_es2017
std::unique_ptr< TH1 > m_pedestals_es2017
Definition: egammaEnergyCorrectionTool.h:708
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:712
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:733
AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronEtaBins
std::unique_ptr< TAxis > m_EaccElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:696
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:659
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverFrSh
std::unique_ptr< TH1 > m_G4OverFrSh
Definition: egammaEnergyCorrectionTool.h:783
egEnergyCorr::es2017_summer_improved
@ es2017_summer_improved
Definition: egammaEnergyCorrectionTool.h:311
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermCorError
double dataConstantTermCorError(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2626
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:641
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:685
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:463
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_electrons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_electrons
Definition: egammaEnergyCorrectionTool.h:734
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_unconverted
std::unique_ptr< TH1 > m_G4OverAFII_unconverted
Definition: egammaEnergyCorrectionTool.h:779
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::Resolution::MaterialCaloUp
@ MaterialCaloUp
Definition: egammaEnergyCorrectionTool.h:80
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigPP0
std::unique_ptr< TH2 > m_electronBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:761
AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncAlpha
std::pair< double, double > getAlphaUncAlpha(const TH1 &hh, double cl_eta, double et, bool useInterp) const
Definition: egammaEnergyCorrectionTool.cxx:4341
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:732
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_A_data
std::unique_ptr< TH1 > m_wstot_slope_A_data
Definition: egammaEnergyCorrectionTool.h:726
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_electron
std::unique_ptr< TH1 > m_G4OverAFII_electron
Definition: egammaEnergyCorrectionTool.h:777
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:780
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermError
double dataConstantTermError(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2600
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_G4
std::unique_ptr< TH1 > m_dX_IPAcc_G4
Definition: egammaEnergyCorrectionTool.h:667
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:737
egEnergyCorr::Scale::L2MediumGainDown
@ L2MediumGainDown
Definition: egammaEnergyCorrectionTool.h:227
AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainCorrection
bool m_useL2GainCorrection
Definition: egammaEnergyCorrectionTool.h:805
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:2604
egEnergyCorr::Scale::ZeePhysUp
@ ZeePhysUp
Definition: egammaEnergyCorrectionTool.h:148
AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedEtaBins
std::unique_ptr< TAxis > m_s12UnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:691
egEnergyCorr::ConfigA
@ ConfigA
Definition: egammaEnergyCorrectionTool.h:337
egEnergyCorr::Scale::EXTRARUN3PREUp
@ EXTRARUN3PREUp
Definition: egammaEnergyCorrectionTool.h:269
AtlasRoot::egammaEnergyCorrectionTool::applyFStoG4
double applyFStoG4(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:3107
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:633
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:758
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2017
std::unique_ptr< TH1 > m_zeeNom_data2017
Definition: egammaEnergyCorrectionTool.h:644
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigN
std::unique_ptr< TH2 > m_convertedBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:771
AtlasRoot::egammaEnergyCorrectionTool::getZeeMeanET
double getZeeMeanET(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2504
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_LAr
std::unique_ptr< TH1 > m_dX_IPAcc_LAr
Definition: egammaEnergyCorrectionTool.h:668
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigEpLp
std::unique_ptr< TH2 > m_electronBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:757
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigIBL
std::unique_ptr< TH2 > m_electronBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:760
plotBeamSpotCompare.histo
histo
Definition: plotBeamSpotCompare.py:415
AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201215
bool m_use_temp_correction201215
Definition: egammaEnergyCorrectionTool.h:810
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigA
std::unique_ptr< TH2 > m_unconvertedBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:762
egEnergyCorr::Scale::MatCryoUp
@ MatCryoUp
Definition: egammaEnergyCorrectionTool.h:217
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronGraphs
std::vector< std::unique_ptr< TList > > m_matElectronGraphs
Definition: egammaEnergyCorrectionTool.h:752
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:782
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:787
AtlasRoot::egammaEnergyCorrectionTool::getLayerUncertainty
double getLayerUncertainty(int iLayer, double cl_eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3526
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up
@ S12ExtraLastEtaBinRun2Up
Definition: egammaEnergyCorrectionTool.h:211
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigPP0
std::unique_ptr< TH2 > m_convertedBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:773
AtlasRoot::egammaEnergyCorrectionTool::m_daPSb12
std::unique_ptr< TH1 > m_daPSb12
Definition: egammaEnergyCorrectionTool.h:637
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:4529
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:649
AtlasRoot::egammaEnergyCorrectionTool::dataZPeakResolution
double dataZPeakResolution(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2610
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:2420
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
AtlasRoot::egammaEnergyCorrectionTool::getE4Uncertainty
static double getE4Uncertainty(double eta)
Definition: egammaEnergyCorrectionTool.cxx:3421
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_G4
std::unique_ptr< TH1 > m_dX_PSAcc_G4
Definition: egammaEnergyCorrectionTool.h:672
AtlasRoot::egammaEnergyCorrectionTool::get_OFCSyst
double get_OFCSyst(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:5185
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:682
egEnergyCorr::Scale::LArUnconvCalibUp
@ LArUnconvCalibUp
Definition: egammaEnergyCorrectionTool.h:157
AtlasRoot::egammaEnergyCorrectionTool::m_E4ElectronGraphs
std::unique_ptr< TList > m_E4ElectronGraphs
Definition: egammaEnergyCorrectionTool.h:683
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2018
std::unique_ptr< TH1 > m_zeeNom_data2018
Definition: egammaEnergyCorrectionTool.h:645
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:669
Generated on Thu Nov 7 2024 22:10:24 for ATLAS Offline Software by   doxygen 1.8.18