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_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_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_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 3044 of file egammaEnergyCorrectionTool.cxx.

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

◆ applyFStoG4()

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

Definition at line 3111 of file egammaEnergyCorrectionTool.cxx.

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

◆ applyMCCalibration()

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

Definition at line 3009 of file egammaEnergyCorrectionTool.cxx.

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

◆ dataConstantTerm()

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

Definition at line 2600 of file egammaEnergyCorrectionTool.cxx.

2600  {
2601  return std::max(0., m_resNom->GetBinContent(m_resNom->FindFixBin(eta)));
2602 }

◆ dataConstantTermCorError()

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

Definition at line 2630 of file egammaEnergyCorrectionTool.cxx.

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

◆ dataConstantTermError()

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

Definition at line 2604 of file egammaEnergyCorrectionTool.cxx.

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

◆ dataConstantTermOFCError()

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

Definition at line 2608 of file egammaEnergyCorrectionTool.cxx.

2608  {
2609  return m_resSystOFC->GetBinContent(m_resSystOFC->FindFixBin(eta));
2610 }

◆ dataZPeakResolution()

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

Definition at line 2614 of file egammaEnergyCorrectionTool.cxx.

2614  {
2615 
2616  return m_peakResData->GetBinContent(
2617  std::as_const(*m_peakResData).GetXaxis()->FindBin(cl_eta));
2618 }

◆ fcn_sigma()

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

Definition at line 2922 of file egammaEnergyCorrectionTool.cxx.

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

◆ get_OFCSyst()

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

Definition at line 5201 of file egammaEnergyCorrectionTool.cxx.

5201  {
5202  const auto ieta = std::as_const(*m_zeeSystOFC).GetXaxis()->FindFixBin(eta);
5203  auto value_histo = m_zeeSystOFC->GetBinContent(ieta);
5204 
5205  return value_histo;
5206 }

◆ get_ZeeStat_eta_axis()

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

Definition at line 5208 of file egammaEnergyCorrectionTool.cxx.

5208  {
5209  return *std::as_const(*m_zeeNom).GetXaxis();
5210 }

◆ get_ZeeSyst()

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

Definition at line 5194 of file egammaEnergyCorrectionTool.cxx.

5194  {
5195  const auto ieta = std::as_const(*m_zeeSyst).GetXaxis()->FindFixBin(eta);
5196  auto value_histo = m_zeeSyst->GetBinContent(ieta);
5197 
5198  return value_histo;
5199 }

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

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

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

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

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

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

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

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

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

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

◆ getAlphaUncAlpha()

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

Definition at line 4345 of file egammaEnergyCorrectionTool.cxx.

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

◆ getAlphaUncertainty()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncertainty ( long int  runnumber,
double  cl_eta,
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 2424 of file egammaEnergyCorrectionTool.cxx.

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

◆ getAlphaValue()

double AtlasRoot::egammaEnergyCorrectionTool::getAlphaValue ( long int  runnumber,
double  cl_eta,
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 1996 of file egammaEnergyCorrectionTool.cxx.

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

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

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

◆ getCorrectedEnergy()

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

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

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

◆ getE4NonLinearity()

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

Definition at line 3663 of file egammaEnergyCorrectionTool.cxx.

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

◆ getE4Uncertainty()

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

Definition at line 3425 of file egammaEnergyCorrectionTool.cxx.

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

◆ getInterpolateConvSyst2D()

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

Definition at line 4444 of file egammaEnergyCorrectionTool.cxx.

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

◆ getLayerNonLinearity()

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

Definition at line 3695 of file egammaEnergyCorrectionTool.cxx.

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

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

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

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

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

◆ getMaterialEffect()

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

Definition at line 4003 of file egammaEnergyCorrectionTool.cxx.

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

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

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

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

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

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

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

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

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

◆ getWtots1Uncertainty()

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

Definition at line 3452 of file egammaEnergyCorrectionTool.cxx.

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

◆ getZeeMeanET()

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

Definition at line 2508 of file egammaEnergyCorrectionTool.cxx.

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

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

4566  {
4567 
4568  return std::abs(cl_eta) >= 1.35 && std::abs(cl_eta) <= 1.55;
4569 }

◆ mcConstantTerm()

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

Definition at line 2579 of file egammaEnergyCorrectionTool.cxx.

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

◆ mcNoiseTerm()

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

Definition at line 2560 of file egammaEnergyCorrectionTool.cxx.

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

◆ mcSamplingTerm()

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

Definition at line 2524 of file egammaEnergyCorrectionTool.cxx.

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

◆ mcSamplingTermRelError()

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

Definition at line 2552 of file egammaEnergyCorrectionTool.cxx.

2552  {
2553 
2554  (void)cl_eta; // not used
2555  return 0.1; // when will this be improved?
2556 }

◆ mcZPeakResolution()

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

Definition at line 2622 of file egammaEnergyCorrectionTool.cxx.

2622  {
2623 
2624  return m_peakResMC->GetBinContent(
2625  std::as_const(*m_peakResMC).GetXaxis()->FindBin(cl_eta));
2626 }

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

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

◆ pileUpTerm()

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

Definition at line 4591 of file egammaEnergyCorrectionTool.cxx.

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

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

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

◆ resolutionError()

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

Definition at line 2769 of file egammaEnergyCorrectionTool.cxx.

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

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

5133  {
5134  switch (var) {
5135  case egEnergyCorr::Resolution::None:
5136  return "Resolution::None";
5137  case egEnergyCorr::Resolution::Nominal:
5138  return "Resolution::Nominal";
5139  case egEnergyCorr::Resolution::AllDown:
5140  return "Resolution::AllDown";
5141  case egEnergyCorr::Resolution::AllUp:
5142  return "Resolution::AllUp";
5143  case egEnergyCorr::Resolution::ZSmearingUp:
5144  return "Resolution::ZSmearingUp";
5145  case egEnergyCorr::Resolution::ZSmearingDown:
5146  return "Resolution::ZSmearingDown";
5147  case egEnergyCorr::Resolution::SamplingTermUp:
5148  return "Resolution::SamplingTermUp";
5149  case egEnergyCorr::Resolution::SamplingTermDown:
5150  return "Resolution::SamplingTermDown";
5151  case egEnergyCorr::Resolution::MaterialIDUp:
5152  return "Resolution::MaterialUp";
5153  case egEnergyCorr::Resolution::MaterialIDDown:
5154  return "Resolution::MaterialDown";
5155  case egEnergyCorr::Resolution::MaterialCaloUp:
5156  return "Resolution::MaterialUp";
5157  case egEnergyCorr::Resolution::MaterialCaloDown:
5158  return "Resolution::MaterialDown";
5159  case egEnergyCorr::Resolution::MaterialCryoUp:
5160  return "Resolution::MaterialUp";
5161  case egEnergyCorr::Resolution::MaterialCryoDown:
5162  return "Resolution::MaterialDown";
5163  case egEnergyCorr::Resolution::MaterialGapUp:
5164  return "Resolution::MaterialUp";
5165  case egEnergyCorr::Resolution::MaterialGapDown:
5166  return "Resolution::MaterialDown";
5167  case egEnergyCorr::Resolution::PileUpUp:
5168  return "Resolution::PileUpUp";
5169  case egEnergyCorr::Resolution::PileUpDown:
5170  return "Resolution::PileUpDown";
5171  case egEnergyCorr::Resolution::MaterialPP0Up:
5172  return "Resolution::MaterialPP0Up";
5173  case egEnergyCorr::Resolution::MaterialPP0Down:
5174  return "Resolution::MaterialPP0Down";
5175  case egEnergyCorr::Resolution::MaterialIBLUp:
5176  return "Resolution::MaterialIBLUp";
5177  case egEnergyCorr::Resolution::MaterialIBLDown:
5178  return "Resolution::MaterialIBLDown";
5179  case egEnergyCorr::Resolution::af2Up:
5180  return "Resolution::af2Up";
5181  case egEnergyCorr::Resolution::af2Down:
5182  return "Resolution::af2Down";
5183  case egEnergyCorr::Resolution::OFCUp:
5184  return "Resolution::OFCUp";
5185  case egEnergyCorr::Resolution::OFCDown:
5186  return "Resolution::OFCDown";
5187  case egEnergyCorr::Resolution::LastResolutionVariation:
5188  return "LastResolutionVariation";
5189  default:
5190  return "Resolution::Unknown";
5191  }
5192 }

◆ variationName() [2/2]

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

Definition at line 4950 of file egammaEnergyCorrectionTool.cxx.

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

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
egEnergyCorr::Resolution::MaterialPP0Up
@ MaterialPP0Up
Definition: egammaEnergyCorrectionTool.h:93
TH2D::GetBinContent
double GetBinContent(int) const
Definition: rootspy.cxx:435
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
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
AtlasRoot::egammaEnergyCorrectionTool::getAlphaValue
double getAlphaValue(long int runnumber, double cl_eta, 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:1996
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:2552
AtlasRoot::egammaEnergyCorrectionTool::m_initialized
bool m_initialized
Definition: egammaEnergyCorrectionTool.h:801
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
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:49
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:79
AtlasRoot::egammaEnergyCorrectionTool::applyAFtoG4
double applyAFtoG4(double eta, double ptGeV, PATCore::ParticleType::Type ptype) const
MC calibration corrections.
Definition: egammaEnergyCorrectionTool.cxx:3044
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:2659
AtlasRoot::egammaEnergyCorrectionTool::getE4NonLinearity
double getE4NonLinearity(double cl_eta, double meanE, PATCore::ParticleType::Type) const
Definition: egammaEnergyCorrectionTool.cxx:3663
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_elec
std::unique_ptr< TH2 > m_pp0_elec
Definition: egammaEnergyCorrectionTool.h:722
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:4628
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:3806
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:5194
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:2622
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:122
egEnergyCorr::Scale::ZeeStatUp
@ ZeeStatUp
Definition: egammaEnergyCorrectionTool.h:144
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTerm
double dataConstantTerm(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2600
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:4484
AtlasRoot::egammaEnergyCorrectionTool::mcNoiseTerm
static double mcNoiseTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2560
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:4950
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
AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncertainty
double getAlphaUncertainty(long int runnumber, double cl_eta, 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:2424
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
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:4444
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:2579
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:3695
dqt_zlumi_alleff_HIST.A
A
Definition: dqt_zlumi_alleff_HIST.py:110
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:4269
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
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
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:3911
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:4591
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
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
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:92
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:3123
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:3452
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:4566
AtlasRoot::egammaEnergyCorrectionTool::fcn_sigma
static double fcn_sigma(double energy, double Cdata, double Cdata_er, double S, double S_er)
Definition: egammaEnergyCorrectionTool.cxx:2922
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:127
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:4234
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:4571
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
TH2D
Definition: rootspy.cxx:430
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
TH2
Definition: rootspy.cxx:373
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:4098
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:2769
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:2808
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:4387
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:4003
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:2938
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:2524
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:157
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
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
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:2630
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
TH1
Definition: rootspy.cxx:268
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:4345
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:2604
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:2608
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:3111
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:2508
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
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
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:3530
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:4533
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:2614
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
AtlasRoot::egammaEnergyCorrectionTool::getE4Uncertainty
static double getE4Uncertainty(double eta)
Definition: egammaEnergyCorrectionTool.cxx:3425
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:5201
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 Fri Jul 5 2024 22:12:15 for ATLAS Offline Software by   doxygen 1.8.18