ATLAS Offline Software
egammaEnergyCorrectionTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
8 #include "ElectronPhotonFourMomentumCorrection/egammaEnergyCorrectionTool.h"
9 
10 
11 
12 #include "ElectronPhotonFourMomentumCorrection/GainTool.h"
13 #include "ElectronPhotonFourMomentumCorrection/GainUncertainty.h"
14 #include "ElectronPhotonFourMomentumCorrection/LinearityADC.h"
15 #include "ElectronPhotonFourMomentumCorrection/e1hg_systematics.h"
16 #include "ElectronPhotonFourMomentumCorrection/get_MaterialResolutionEffect.h"
17 #include "PathResolver/PathResolver.h"
18 #include "TF1.h"
19 #include "TFile.h"
20 #include "TGraphErrors.h"
21 #include "TH1.h"
22 #include "TH2.h"
23 #include "TList.h"
24 #include "TSystem.h"
25 #include "TRandom3.h"
26 #include "egammaUtils/eg_resolution.h"
27 
28 #include <format>
29 #include <cassert>
30 #include <exception>
31 #include <iomanip>
32 #include <ios>
33 #include <iostream>
34 #include <utility>
35 #include <type_traits> //std::is_pointer
36 #include <cmath> //hypot
37 
38 
39 namespace {
40 double qsum(double x, double y) {
41  return std::hypot(x, y);
42 }
43 
44 template <typename TargetPtr, typename SourcePtr>
45 TargetPtr checked_own_cast(SourcePtr ptr) {
46  // Do we have ptr types
47  static_assert(std::is_pointer<TargetPtr>::value,
48  "attempt to cast to no ptr object");
49  static_assert(std::is_pointer<SourcePtr>::value,
50  "attempt to cast from no ptr object");
51 
52  // nullptr input
53  if (!ptr) {
54  throw std::runtime_error(
55  "Attempt to cast from nullptr in egammaEnergyCorrectionTool");
56  }
57 
58  // dynamic_cast and check
59  TargetPtr obj = dynamic_cast<TargetPtr>(ptr);
60  if (not obj) {
61  throw std::runtime_error("failed dynamic cast for " +
62  std::string(ptr->GetName()) +
63  " in egammaEnergyCorrectionTool");
64  }
65 
66  // For most ROOT types we want onwership
67  // TAxis nothing
68  if constexpr (std::is_same_v<TAxis, std::remove_pointer_t<TargetPtr>>) {
69  }
70  // TList SetOwner
71  else if constexpr (std::is_same_v<TList, std::remove_pointer_t<TargetPtr>>) {
72  obj->SetOwner();
73  // mainly TH1,TH2
74  } else {
75  obj->SetDirectory(nullptr);
76  }
77 
78  return obj;
79 }
80 
81 double getValueHistoAt(const TH1& histo, double xvalue,
82  bool use_lastbin_overflow = false,
83  bool use_firstbin_underflow = false) {
84  int bin = histo.FindFixBin(xvalue);
85  if (use_lastbin_overflow and histo.IsBinOverflow(bin)) {
86  bin = histo.GetNbinsX();
87  }
88  if (use_firstbin_underflow and histo.IsBinUnderflow(bin)) {
89  bin = 1;
90  }
91  return histo.GetBinContent(bin);
92 }
93 
94 double getValueHistAt(const TH2& histo, double xvalue, double yvalue,
95  bool use_lastbin_x_overflow = false,
96  bool use_lastbin_y_overflow = false,
97  bool use_fistbin_x_underflow = false,
98  bool use_firstbin_y_underflow = false) {
99  int xbin = histo.GetXaxis()->FindFixBin(xvalue);
100  if (use_lastbin_x_overflow and xbin == histo.GetXaxis()->GetNbins() + 1) {
101  xbin = histo.GetXaxis()->GetNbins();
102  }
103  if (use_fistbin_x_underflow and xbin == 0) {
104  xbin = 1;
105  }
106  int ybin = histo.GetYaxis()->FindFixBin(yvalue);
107  if (use_lastbin_y_overflow and ybin == histo.GetYaxis()->GetNbins() + 1) {
108  ybin = histo.GetYaxis()->GetNbins();
109  }
110  if (use_firstbin_y_underflow and ybin == 0) {
111  ybin = 1;
112  }
113  return histo.GetBinContent(xbin, ybin);
114 }
115 } // end anonymous namespace
116 
117 namespace AtlasRoot {
118 
119 using std::string;
120 
121 egammaEnergyCorrectionTool::egammaEnergyCorrectionTool()
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 }
172 
173 egammaEnergyCorrectionTool::~egammaEnergyCorrectionTool() {
174 
175  // Clean up
176 }
177 
178 int egammaEnergyCorrectionTool::initialize() {
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 }
1844 
1845 // User interface
1846 // universal compact interface to getCorrectedEnergy(...)
1847 double egammaEnergyCorrectionTool::getCorrectedMomentum(
1848  PATCore::ParticleDataType::DataType dataType,
1849  PATCore::ParticleType::Type ptype, double momentum, double trk_eta,
1850  egEnergyCorr::Scale::Variation scaleVar, double varSF) const {
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 }
1869 
1870 // This method handles the main switches between data and the various MC
1871 // flavours. Called internally by getCorrectedEnergy(...)
1872 double egammaEnergyCorrectionTool::getCorrectedEnergy(
1873  unsigned int runnumber, PATCore::ParticleDataType::DataType dataType,
1874  PATCore::ParticleType::Type ptype, double cl_eta, double cl_etaS2, double cl_etaCalo,
1875  double energy, double energyS2, double eraw, RandomNumber random_seed,
1876  egEnergyCorr::Scale::Variation scaleVar,
1877  egEnergyCorr::Resolution::Variation resVar,
1878  egEnergyCorr::Resolution::resolutionType resType, double varSF) const {
1879  double fullyCorrectedEnergy = energy;
1880 
1881  // Correct fast sim flavours
1882 
1883  if (dataType == PATCore::ParticleDataType::FastShower) // Frozen shower sim
1884  fullyCorrectedEnergy = energy * this->applyFStoG4(cl_eta);
1885  else if (dataType == PATCore::ParticleDataType::Fast) // AtlFast2 sim
1886  {
1887  fullyCorrectedEnergy =
1888  energy *
1889  this->applyAFtoG4(cl_eta, 0.001 * energy / cosh(cl_eta), ptype);
1890  }
1891 
1892  // If nothing is to be done
1893 
1894  if (scaleVar == egEnergyCorr::Scale::None &&
1895  resVar == egEnergyCorr::Resolution::None)
1896  return fullyCorrectedEnergy;
1897 
1898  ATH_MSG_DEBUG(std::format("after sim fl = {:.2f}", fullyCorrectedEnergy));
1899 
1900  // main E-scale corrections
1901 
1902  if (dataType == PATCore::ParticleDataType::Data) { // ... Data
1903 
1904  if (scaleVar == egEnergyCorr::Scale::Nominal) {
1905  double alpha =
1906  getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, fullyCorrectedEnergy,
1907  energyS2, eraw, ptype, scaleVar, varSF);
1908  fullyCorrectedEnergy /= (1 + alpha);
1909  // apply additional k.E+b corrections if histograms exist (like in
1910  // es2017_R21_v1)
1911  if (m_zeeFwdk && m_zeeFwdb && std::abs(cl_eta) > 2.5) { // calo eta?
1912  int ieta_k = m_zeeFwdk->GetXaxis()->FindFixBin(cl_eta);
1913  double value_k = m_zeeFwdk->GetBinContent(ieta_k);
1914  int ieta_b = m_zeeFwdb->GetXaxis()->FindFixBin(cl_eta);
1915  double value_b = m_zeeFwdb->GetBinContent(ieta_b);
1916  fullyCorrectedEnergy =
1917  value_k * fullyCorrectedEnergy +
1918  value_b * GeV; // value is stored in GeV in the histogram file
1919  }
1920  ATH_MSG_DEBUG(std::format("after alpha = {:.2f}", fullyCorrectedEnergy));
1921  }
1922 
1923  } else { // ... MC
1924 
1925  // Do the energy scale correction (for systematic variations)
1926 
1927  if (scaleVar != egEnergyCorr::Scale::None &&
1928  scaleVar != egEnergyCorr::Scale::Nominal) {
1929  double deltaAlpha = getAlphaUncertainty(runnumber, cl_eta, cl_etaS2, cl_etaCalo,
1930  fullyCorrectedEnergy, energyS2,
1931  eraw, ptype, scaleVar, varSF);
1932  ATH_MSG_DEBUG("alpha sys " << variationName(scaleVar) << " = "
1933  << deltaAlpha);
1934  fullyCorrectedEnergy *= (1 + deltaAlpha);
1935  ATH_MSG_DEBUG(std::format("after mc alpha = {:.2f}", fullyCorrectedEnergy));
1936  }
1937 
1938  // AF2 systematics (this will not be in the sum of all other NP in the 1 NP
1939  // model)
1940  if (dataType == PATCore::ParticleDataType::Fast &&
1941  (m_esmodel == egEnergyCorr::es2017_R21_v0 ||
1942  m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1943  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1944  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1945  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1946  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1947  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
1948  if (scaleVar == egEnergyCorr::Scale::af2Up or
1949  scaleVar == egEnergyCorr::Scale::af2Down) {
1950  double daAF2 = 0.;
1951  if (m_esmodel == egEnergyCorr::es2017_R21_v0) {
1952  if (scaleVar == egEnergyCorr::Scale::af2Up)
1953  daAF2 = 0.005;
1954  if (scaleVar == egEnergyCorr::Scale::af2Down)
1955  daAF2 = -0.005;
1956  }
1957  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
1958  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
1959  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
1960  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
1961  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
1962  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
1963  if (scaleVar == egEnergyCorr::Scale::af2Up)
1964  daAF2 = 0.001;
1965  if (scaleVar == egEnergyCorr::Scale::af2Down)
1966  daAF2 = -0.001;
1967  }
1968  fullyCorrectedEnergy *= (1 + daAF2);
1969  }
1970  }
1971 
1972  // Do the resolution correction
1973  if (resVar != egEnergyCorr::Resolution::None)
1974  fullyCorrectedEnergy *=
1975  getSmearingCorrection(cl_eta, cl_etaCalo, fullyCorrectedEnergy,
1976  random_seed, ptype, dataType, resVar, resType);
1977 
1978  ATH_MSG_DEBUG(std::format("after resolution correction = {:.2f}", fullyCorrectedEnergy));
1979  }
1980 
1981  return fullyCorrectedEnergy;
1982 }
1983 
1984 // This method applied the overall energy corrections and systematic variations.
1985 // Called internally by getCorrectedEnergy(...).
1986 // convention is Edata = (1+alpha)*Emc, hence Edata -> Edata/(1+alpha) to match
1987 // the MC note : all energies in MeV
1988 
1989 // returns alpha_var. var = egEnergyCorr::Scale::Nominal or any systematic
1990 // variation
1991 
1992 double egammaEnergyCorrectionTool::getAlphaValue(
1993  long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo,
1994  double energy, // input energy (not ET!!)
1995  double energyS2, // raw energy in S2
1996  double eraw, PATCore::ParticleType::Type ptype,
1997  egEnergyCorr::Scale::Variation var, double varSF) const {
1998 
1999  double meanET = getZeeMeanET(m_use_etaCalo_scales ? cl_etaCalo : cl_eta);
2000  ATH_MSG_DEBUG("getZeeMeanET() output " << meanET);
2001  ATH_MSG_DEBUG("getZeeMeanET() eta: "
2002  << double(m_use_etaCalo_scales ? cl_etaCalo : cl_eta));
2003  double meanE = meanET * std::cosh(cl_eta);
2004  double Et = energy / std::cosh(cl_eta);
2005 
2006  // Main Scale factor
2007 
2008  double alphaZee = getAlphaZee(
2009  runnumber, m_use_etaCalo_scales ? cl_etaCalo : cl_eta, var, varSF);
2010 
2011  // Sampling recalibration
2012 
2013  double daPS, daS12, linPS, linS12, linEacc, linPS_40_elec, linEacc_40_elec,
2014  linS12_40_elec;
2015  daPS = daS12 = linPS = linS12 = linEacc = linPS_40_elec = linEacc_40_elec =
2016  linS12_40_elec = 0.;
2017 
2018  double daE4 = 0., linE4 = 0.;
2019  // E4 contribution
2020  if ((m_esmodel == egEnergyCorr::es2015c_summer or
2021  m_esmodel == egEnergyCorr::es2016PRE or
2022  m_esmodel == egEnergyCorr::es2017 or
2023  m_esmodel == egEnergyCorr::es2017_summer or
2024  m_esmodel == egEnergyCorr::es2017_summer_improved or
2025  m_esmodel == egEnergyCorr::es2017_summer_final or
2026  m_esmodel == egEnergyCorr::es2017_R21_PRE or
2027  m_esmodel == egEnergyCorr::es2015_5TeV or
2028  m_esmodel == egEnergyCorr::es2017_R21_v0 or
2029  m_esmodel == egEnergyCorr::es2017_R21_v1 or
2030  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
2031  m_esmodel == egEnergyCorr::es2018_R21_v0 or
2032  m_esmodel == egEnergyCorr::es2018_R21_v1 or
2033  m_esmodel == egEnergyCorr::es2022_R22_PRE or
2034  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) and
2035  (var == egEnergyCorr::Scale::E4ScintillatorUp or
2036  var == egEnergyCorr::Scale::E4ScintillatorDown)) {
2037  daE4 = getE4Uncertainty(cl_eta);
2038  if (var == egEnergyCorr::Scale::E4ScintillatorDown)
2039  daE4 *= -1;
2040  linE4 = getE4NonLinearity(cl_eta, energy, ptype) -
2041  getE4NonLinearity(cl_eta, meanE, PATCore::ParticleType::Electron);
2042  }
2043 
2044  // wtots1 contribution
2045  double daWtots1 = 0.;
2046  if ((m_esmodel == egEnergyCorr::es2017 or
2047  m_esmodel == egEnergyCorr::es2017_summer or
2048  m_esmodel == egEnergyCorr::es2017_summer_improved or
2049  m_esmodel == egEnergyCorr::es2017_summer_final or
2050  m_esmodel == egEnergyCorr::es2017_R21_PRE or
2051  m_esmodel == egEnergyCorr::es2015_5TeV or
2052  m_esmodel == egEnergyCorr::es2017_R21_v0 or
2053  m_esmodel == egEnergyCorr::es2017_R21_v1 or
2054  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
2055  m_esmodel == egEnergyCorr::es2018_R21_v0 or
2056  m_esmodel == egEnergyCorr::es2018_R21_v1 or
2057  m_esmodel == egEnergyCorr::es2022_R22_PRE or
2058  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) and
2059  (var == egEnergyCorr::Scale::Wtots1Up or
2060  var == egEnergyCorr::Scale::Wtots1Down)) {
2061  daWtots1 = getWtots1Uncertainty(cl_eta, energy, ptype);
2062  if (var == egEnergyCorr::Scale::Wtots1Down)
2063  daWtots1 = -daWtots1;
2064  }
2065 
2066  // ... Presampler contribution
2067 
2068  if (var == egEnergyCorr::Scale::PSUp || var == egEnergyCorr::Scale::PSDown ||
2069  var == egEnergyCorr::Scale::PSb12Up ||
2070  var == egEnergyCorr::Scale::PSb12Down ||
2071  var == egEnergyCorr::Scale::LArElecUnconvUp ||
2072  var == egEnergyCorr::Scale::LArElecUnconvDown) {
2073 
2074  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
2075  daPS = getLayerUncertainty(0, cl_eta, var, varSF);
2076  linPS = getLayerNonLinearity(0, cl_eta, energy, ptype) -
2077  getLayerNonLinearity(0, cl_eta, meanE,
2078  PATCore::ParticleType::Electron);
2079  } else {
2080  daPS = getLayerUncertainty(0, cl_eta, var, varSF);
2081  linPS = getLayerNonLinearity(0, cl_eta, energy, ptype);
2082  linEacc = getLayerNonLinearity(
2083  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta, energy, ptype);
2084  linPS_40_elec = getLayerNonLinearity(0, cl_eta, meanE,
2085  PATCore::ParticleType::Electron);
2086  linEacc_40_elec = getLayerNonLinearity(
2087  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta,
2088  meanET * std::cosh(m_use_etaCalo_scales ? cl_etaCalo : cl_eta),
2089  PATCore::ParticleType::Electron);
2090  ATH_MSG_DEBUG(
2091  "es2023_R22_Run2_v0 PS non-linearity before Acc correction: "
2092  << linPS);
2093  linPS = linPS - linEacc * linPS_40_elec / linEacc_40_elec;
2094  ATH_MSG_DEBUG("es2023_R22_Run2_v0 PS non-linearity after Acc correction: "
2095  << linPS);
2096  }
2097  }
2098 
2099  // ... S1 / S2 contribution
2100 
2101  if (var == egEnergyCorr::Scale::S12Up or
2102  var == egEnergyCorr::Scale::S12Down or
2103  var == egEnergyCorr::Scale::LArCalibUp or
2104  var == egEnergyCorr::Scale::LArCalibDown or
2105  var == egEnergyCorr::Scale::LArCalibExtra2015PreUp or
2106  var == egEnergyCorr::Scale::LArCalibExtra2015PreDown or
2107  var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up or
2108  var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down) {
2109  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
2110  daS12 = getLayerUncertainty(1, cl_eta, var, varSF);
2111  linS12 = getLayerNonLinearity(1, cl_eta, energy, ptype) -
2112  getLayerNonLinearity(1, cl_eta, meanE,
2113  PATCore::ParticleType::Electron);
2114  } else {
2115  daS12 = getLayerUncertainty(1, cl_eta, var, varSF) *
2116  -1.; // uncertainty applied to E2 is equal to -delta E1/E2 scale
2117  linS12 = getLayerNonLinearity(1, cl_eta, energy, ptype);
2118  linEacc = getLayerNonLinearity(
2119  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta, energy, ptype);
2120  linS12_40_elec = getLayerNonLinearity(1, cl_eta, meanE,
2121  PATCore::ParticleType::Electron);
2122  linEacc_40_elec = getLayerNonLinearity(
2123  6, m_use_etaCalo_scales ? cl_etaCalo : cl_eta,
2124  meanET * std::cosh(m_use_etaCalo_scales ? cl_etaCalo : cl_eta),
2125  PATCore::ParticleType::Electron);
2126  ATH_MSG_DEBUG(
2127  "es2023_R22_Run2_v0 S12 non-linearity before Acc correction: "
2128  << linS12);
2129  linS12 = linS12 - linEacc * linS12_40_elec / linEacc_40_elec;
2130  ATH_MSG_DEBUG(
2131  "es2023_R22_Run2_v0 S12 non-linearity after Acc correction: "
2132  << linS12);
2133  }
2134  }
2135 
2136  // Material contribution
2137 
2138  double daMatID, daMatCryo, daMatCalo;
2139  daMatID = daMatCryo = daMatCalo = 0;
2140 
2141  // for release 21 sensitivity use the same getMaterialNonLinearity for all
2142  // particles while in sensitivities derived from run 1 this is only used for
2143  // electrons
2144 
2145  if (ptype != PATCore::ParticleType::Electron &&
2146  (m_esmodel != egEnergyCorr::es2017_R21_v1 &&
2147  m_esmodel != egEnergyCorr::es2017_R21_ofc0_v1 &&
2148  m_esmodel != egEnergyCorr::es2018_R21_v0 &&
2149  m_esmodel != egEnergyCorr::es2018_R21_v1 &&
2150  m_esmodel != egEnergyCorr::es2022_R22_PRE &&
2151  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)) {
2152 
2153  daMatID = getAlphaMaterial(cl_eta, egEnergyCorr::MatID, ptype, var, varSF);
2154  daMatCryo =
2155  getAlphaMaterial(cl_eta, egEnergyCorr::MatCryo, ptype, var, varSF);
2156  daMatCalo =
2157  getAlphaMaterial(cl_eta, egEnergyCorr::MatCalo, ptype, var, varSF);
2158 
2159  } else {
2160 
2161  daMatID =
2162  getMaterialNonLinearity(cl_eta, energy, egEnergyCorr::MatID, ptype, var,
2163  varSF) -
2164  getMaterialNonLinearity(cl_eta, meanE, egEnergyCorr::MatID,
2165  PATCore::ParticleType::Electron, var, varSF);
2166  daMatCryo =
2167  getMaterialNonLinearity(cl_eta, energy, egEnergyCorr::MatCryo, ptype,
2168  var, varSF) -
2169  getMaterialNonLinearity(cl_eta, meanE, egEnergyCorr::MatCryo,
2170  PATCore::ParticleType::Electron, var, varSF);
2171  daMatCalo =
2172  getMaterialNonLinearity(cl_eta, energy, egEnergyCorr::MatCalo, ptype,
2173  var, varSF) -
2174  getMaterialNonLinearity(cl_eta, meanE, egEnergyCorr::MatCalo,
2175  PATCore::ParticleType::Electron, var, varSF);
2176  }
2177 
2178  // Pedestal subtraction
2179 
2180  double daPedestal =
2181  getAlphaPedestal(cl_eta, energy, eraw, ptype, false, var, varSF) -
2182  getAlphaPedestal(cl_eta, meanE, eraw, PATCore::ParticleType::Electron,
2183  true, var, varSF);
2184 
2185  // double pedestal systematics for 2016, Guillaume 12/05/16
2186  if (m_esmodel == egEnergyCorr::es2016PRE) {
2187  daPedestal *= 2;
2188  }
2189 
2190  // Leakage contribution (electron-photon difference)
2191  double daLeakage = getAlphaLeakage2D(cl_etaS2, Et, ptype, var, varSF);
2192 
2193  // L1 Gain switch contribution
2194 
2195  double daL1GainSwitch = 0.;
2196 
2197  if (var == egEnergyCorr::Scale::L1GainUp ||
2198  var == egEnergyCorr::Scale::L1GainDown) {
2199 
2200  int eg_e1hg_ptype;
2201  if (ptype == PATCore::ParticleType::Electron)
2202  eg_e1hg_ptype = 0;
2203  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2204  eg_e1hg_ptype = 1;
2205  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2206  eg_e1hg_ptype = 2;
2207  else
2208  return -1;
2209 
2210  daL1GainSwitch = m_e1hg_tool->getAlpha(eg_e1hg_ptype, energy, cl_eta, true);
2211  if (var == egEnergyCorr::Scale::L1GainDown)
2212  daL1GainSwitch = -daL1GainSwitch;
2213  }
2214 
2215  // L2 Gain switch contribution
2216 
2217  double daL2GainSwitch = 0.;
2218  double daL2MediumGainSwitch = 0.;
2219  double daL2LowGainSwitch = 0.;
2220 
2221  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0 &&
2222  (var == egEnergyCorr::Scale::L2GainUp ||
2223  var == egEnergyCorr::Scale::L2GainDown)) {
2224  if (m_gain_tool) { // recipe for run1
2225  if (!(std::abs(cl_eta) < 1.52 && std::abs(cl_eta) > 1.37) &&
2226  std::abs(cl_eta) < 2.4) {
2227  double evar = m_gain_tool->CorrectionGainTool(cl_eta, energy / GeV,
2228  energyS2 / GeV, ptype);
2229  double meanES2 = m_zeeES2Profile->GetBinContent(
2230  m_zeeES2Profile->FindFixBin(cl_eta)); // in GeV already
2231  double eref = m_gain_tool->CorrectionGainTool(
2232  cl_eta, meanE / GeV, meanES2, PATCore::ParticleType::Electron);
2233  daL2GainSwitch = evar / energy - eref / meanE;
2234  if (var == egEnergyCorr::Scale::L2GainDown)
2235  daL2GainSwitch = -daL2GainSwitch;
2236  }
2237  } else if (m_gain_tool_run2) { // recipe for run 2, see ATLASEG-44
2238  daL2GainSwitch = m_gain_tool_run2->getUncertainty(cl_etaCalo, Et, ptype,
2239  m_useL2GainCorrection);
2240  if (var == egEnergyCorr::Scale::L2GainDown)
2241  daL2GainSwitch *= -1;
2242  ATH_MSG_DEBUG("L2 gain uncertainty: " << daL2GainSwitch);
2243  } else {
2244  ATH_MSG_ERROR(
2245  "trying to compute gain systematic, but no tool for doing it has "
2246  "been instantiated, setting sys to 0");
2247  daL2GainSwitch = 0.;
2248  }
2249  }
2250 
2251  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0 &&
2252  (var == egEnergyCorr::Scale::L2MediumGainUp ||
2253  var == egEnergyCorr::Scale::L2MediumGainDown)) {
2254  if (m_gain_tool_run2) { // recipe for run 2, see ATLASEG-44
2255  daL2MediumGainSwitch = m_gain_tool_run2->getUncertainty(
2256  cl_etaCalo, Et, ptype, m_useL2GainCorrection,
2257  egGain::GainUncertainty::GainType::MEDIUM);
2258  if (var == egEnergyCorr::Scale::L2MediumGainDown)
2259  daL2MediumGainSwitch *= -1;
2260  ATH_MSG_DEBUG("L2 gain Medium uncertainty: " << daL2MediumGainSwitch);
2261  } else {
2262  ATH_MSG_ERROR(
2263  "trying to compute gain systematic, but no tool for doing it has "
2264  "been instantiated, setting sys to 0");
2265  daL2MediumGainSwitch = 0.;
2266  }
2267  }
2268 
2269  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0 &&
2270  (var == egEnergyCorr::Scale::L2LowGainUp ||
2271  var == egEnergyCorr::Scale::L2LowGainDown)) {
2272  if (m_gain_tool_run2) { // recipe for run 2, see ATLASEG-44
2273  daL2LowGainSwitch = m_gain_tool_run2->getUncertainty(
2274  cl_etaCalo, Et, ptype, m_useL2GainCorrection,
2275  egGain::GainUncertainty::GainType::LOW);
2276  if (var == egEnergyCorr::Scale::L2LowGainDown)
2277  daL2LowGainSwitch *= -1;
2278  ATH_MSG_DEBUG("L2 gain Low uncertainty: " << daL2LowGainSwitch);
2279  } else {
2280  ATH_MSG_ERROR(
2281  "trying to compute Low gain systematic, but no tool for doing it has "
2282  "been instantiated, setting sys to 0");
2283  daL2LowGainSwitch = 0.;
2284  }
2285  }
2286 
2287  // pp0 (and IBL)
2288  double dapp0 = 0.;
2289  // values from the histogram already are 0 for the Z->ee electrons
2290  if (var == egEnergyCorr::Scale::MatPP0Up or
2291  var == egEnergyCorr::Scale::MatPP0Down) {
2292 
2293  // new parameterization for release 21 reconstruction with mc16 geometries +
2294  // distortions
2295  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
2296  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2297  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
2298  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
2299  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
2300  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2301 
2302  if (std::abs(cl_eta) < 1.5)
2303  dapp0 = getMaterialEffect(egEnergyCorr::ConfigIBL, ptype, cl_eta,
2304  energy / GeV / cosh(cl_eta)) -
2305  getMaterialEffect(egEnergyCorr::ConfigIBL,
2306  PATCore::ParticleType::Electron, cl_eta,
2307  getZeeMeanET(cl_eta) / GeV);
2308  else
2309  dapp0 = getMaterialEffect(egEnergyCorr::ConfigPP0, ptype, cl_eta,
2310  energy / GeV / cosh(cl_eta)) -
2311  getMaterialEffect(egEnergyCorr::ConfigPP0,
2312  PATCore::ParticleType::Electron, cl_eta,
2313  getZeeMeanET(cl_eta) / GeV);
2314 
2315  if (var == egEnergyCorr::Scale::MatPP0Down) {
2316  dapp0 = -dapp0;
2317  }
2318  }
2319 
2320  // release 20 run 2 systematics for mc15 like geometries
2321  else {
2322  // Just pick the owned one from a unique_ptr per case
2323  const TH2* histo = nullptr;
2324  if (ptype == PATCore::ParticleType::Electron && m_pp0_elec)
2325  histo = m_pp0_elec.get();
2326  else if (ptype == PATCore::ParticleType::ConvertedPhoton && m_pp0_conv)
2327  histo = m_pp0_conv.get();
2328  else if (ptype == PATCore::ParticleType::UnconvertedPhoton &&
2329  m_pp0_unconv)
2330  histo = m_pp0_unconv.get();
2331 
2332  if (histo) {
2333  const double aeta = std::abs(cl_eta);
2334  dapp0 = getValueHistAt(*histo, aeta, energy / GeV / cosh(cl_eta), false,
2335  true, false, true);
2336  if (var == egEnergyCorr::Scale::MatPP0Down) {
2337  dapp0 = -dapp0;
2338  }
2339 
2340  // normalize to pp0 systematics
2341  if (aeta > 1.5 and aeta < 2.0) {
2342  dapp0 *= 2.6;
2343  } else if (aeta >= 2.0 and aeta <= 2.5) {
2344  dapp0 *= 2.3;
2345  }
2346  }
2347  }
2348  }
2349 
2350  // Conversion systematics
2351 
2352  double daConvSyst = getAlphaConvSyst(cl_eta, energy, ptype, var, varSF);
2353 
2354  // topo cluster threshold systematics for release 21
2355  double daTopoCluster = 0;
2356  if ((var == egEnergyCorr::Scale::topoClusterThresUp ||
2357  var == egEnergyCorr::Scale::topoClusterThresDown) &&
2358  (m_esmodel == egEnergyCorr::es2017_R21_v0 ||
2359  m_esmodel == egEnergyCorr::es2017_R21_v1 ||
2360  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2361  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
2362  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
2363  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
2364  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
2365  double Et = energy / cosh(cl_eta);
2366  double Et0 = 10000.;
2367  // Effect taken as 10**-3/(Et/10GeV) - order of magniture from
2368  // https://indico.cern.ch/event/669895/contributions/2745266/attachments/1535612/2405452/slides.pdf
2369  if (var == egEnergyCorr::Scale::topoClusterThresUp)
2370  daTopoCluster = 1e-3 * (1. / (Et / Et0) - 1. / (meanET / Et0));
2371  if (var == egEnergyCorr::Scale::topoClusterThresDown)
2372  daTopoCluster = -1e-3 * (1. / (Et / Et0) - 1. / (meanET / Et0));
2373  }
2374 
2375  // ADC non linearity correction. 30% of the effect from
2376  // https://indico.cern.ch/event/1001455/contributions/4205636/attachments/2179584/3681315/ADC-linearity-28jan2021.pdf
2377  // ?
2378  double daADCLin = 0;
2379  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0 &&
2380  (var == egEnergyCorr::Scale::ADCLinUp ||
2381  var == egEnergyCorr::Scale::ADCLinDown)) {
2382  if (m_ADCLinearity_tool) {
2383  double corr = m_ADCLinearity_tool->getCorr(cl_etaCalo, Et, ptype) - 1.;
2384  daADCLin = 0.3 * corr;
2385  } else {
2386  ATH_MSG_WARNING(
2387  "trying to compute ADC correction systematic, but no tool for doing "
2388  "it has been instantiated, setting sys to 0");
2389  daADCLin = 0.;
2390  }
2391  if (var == egEnergyCorr::Scale::ADCLinDown)
2392  daADCLin *= -1;
2393  }
2394 
2395  // Total
2396  double alphaTot = alphaZee;
2397  alphaTot += daE4 * linE4;
2398  alphaTot += daPS * linPS;
2399  alphaTot += daS12 * linS12;
2400  alphaTot += daMatID + daMatCryo + daMatCalo;
2401  alphaTot += daLeakage;
2402  alphaTot += daL1GainSwitch;
2403  alphaTot += daL2GainSwitch;
2404  alphaTot += daL2MediumGainSwitch;
2405  alphaTot += daL2LowGainSwitch;
2406  alphaTot += daConvSyst;
2407  alphaTot += daPedestal;
2408  alphaTot += daWtots1;
2409  alphaTot += dapp0;
2410  alphaTot += daTopoCluster;
2411  alphaTot += daADCLin;
2412 
2413  ATH_MSG_DEBUG("alpha value for " << variationName(var) << " = " << alphaTot);
2414 
2415  return alphaTot;
2416 }
2417 
2418 // returns alpha_var - alpha_nom, for systematic variations.
2419 
2420 double egammaEnergyCorrectionTool::getAlphaUncertainty(
2421  long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy,
2422  double energyS2, double eraw, PATCore::ParticleType::Type ptype,
2423  egEnergyCorr::Scale::Variation var, double varSF) const {
2424 
2425  double alphaNom =
2426  getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy, energyS2, eraw,
2427  ptype, egEnergyCorr::Scale::Nominal);
2428  double alphaVar = 0.;
2429 
2430  if (var != egEnergyCorr::Scale::AllUp &&
2431  var != egEnergyCorr::Scale::AllDown and
2432  var != egEnergyCorr::Scale::AllCorrelatedUp and
2433  var != egEnergyCorr::Scale::AllCorrelatedDown) {
2434  // not an ALLUP
2435  alphaVar = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy, energyS2,
2436  eraw, ptype, var, varSF) -
2437  alphaNom;
2438  } else if (var == egEnergyCorr::Scale::AllUp) {
2439  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatUp;
2440  ivar < egEnergyCorr::Scale::AllUp;
2441  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2442  if (ivar == egEnergyCorr::Scale::ZeeAllUp)
2443  continue;
2444  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2445  energyS2, eraw, ptype, ivar, varSF) -
2446  alphaNom;
2447  ATH_MSG_DEBUG("computing ALLUP, adding " << variationName(ivar) << ": "
2448  << v);
2449  alphaVar += pow(v, 2);
2450  }
2451  alphaVar = sqrt(alphaVar);
2452  } else if (var == egEnergyCorr::Scale::AllDown) {
2453  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatDown;
2454  ivar < egEnergyCorr::Scale::AllDown;
2455  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2456  if (ivar == egEnergyCorr::Scale::ZeeAllDown)
2457  continue;
2458  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2459  energyS2, eraw, ptype, ivar, varSF) -
2460  alphaNom;
2461  ATH_MSG_DEBUG("computing ALLDOWN, adding " << variationName(ivar) << ": "
2462  << v);
2463  alphaVar += pow(v, 2);
2464  }
2465  alphaVar = -sqrt(alphaVar);
2466  } else if (var == egEnergyCorr::Scale::AllCorrelatedUp) {
2467  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatUp;
2468  ivar < egEnergyCorr::Scale::AllUp;
2469  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2470  if (ivar == egEnergyCorr::Scale::ZeeAllUp or
2471  ivar == egEnergyCorr::Scale::LArCalibExtra2015PreUp or
2472  ivar == egEnergyCorr::Scale::LArTemperature2015PreUp or
2473  ivar == egEnergyCorr::Scale::LArTemperature2016PreUp or
2474  ivar == egEnergyCorr::Scale::E4ScintillatorUp)
2475  continue;
2476  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2477  energyS2, eraw, ptype, ivar, varSF) -
2478  alphaNom;
2479  alphaVar += pow(v, 2);
2480  }
2481  alphaVar = sqrt(alphaVar);
2482  } else if (var == egEnergyCorr::Scale::AllCorrelatedDown) {
2483  for (egEnergyCorr::Scale::Variation ivar = egEnergyCorr::Scale::ZeeStatDown;
2484  ivar < egEnergyCorr::Scale::AllDown;
2485  ivar = egEnergyCorr::Scale::Variation(ivar + 2)) {
2486  if (ivar == egEnergyCorr::Scale::ZeeAllDown or
2487  ivar == egEnergyCorr::Scale::LArCalibExtra2015PreDown or
2488  ivar == egEnergyCorr::Scale::LArTemperature2015PreDown or
2489  ivar == egEnergyCorr::Scale::LArTemperature2016PreDown or
2490  ivar == egEnergyCorr::Scale::E4ScintillatorDown)
2491  continue;
2492  const double v = getAlphaValue(runnumber, cl_eta, cl_etaS2, cl_etaCalo, energy,
2493  energyS2, eraw, ptype, ivar, varSF) -
2494  alphaNom;
2495  alphaVar += pow(v, 2);
2496  }
2497  alphaVar = -sqrt(alphaVar);
2498  }
2499 
2500  return alphaVar;
2501 }
2502 
2503 // returns mean electron ET at given eta
2504 double egammaEnergyCorrectionTool::getZeeMeanET(double cl_eta) const {
2505  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
2506  return 40000.;
2507  else {
2508  if (std::abs(cl_eta) >= 2.47)
2509  cl_eta = 2.46;
2510  return m_meanZeeProfile->GetBinContent(
2511  m_meanZeeProfile->FindBin(std::abs(cl_eta))) *
2512  1000;
2513  }
2514 }
2515 
2516 // RESOLUTION FUNCTIONS START HERE (MB)
2517 
2518 // sampling term inMC, parametrization from Iro Koletsou
2519 
2520 double egammaEnergyCorrectionTool::mcSamplingTerm(double cl_eta) {
2521 
2522  double aeta = std::abs(cl_eta);
2523  double sampling = 0.;
2524 
2525  if (aeta < 0.8)
2526  sampling = 0.091;
2527 
2528  else if (aeta < 1.37)
2529  sampling = 0.036 + 0.130 * aeta;
2530 
2531  else if (aeta < 1.52)
2532  sampling = 0.27;
2533 
2534  else if (aeta < 2.0)
2535  sampling = 0.85 - 0.36 * aeta;
2536 
2537  else if (aeta < 2.3)
2538  sampling = 0.16;
2539 
2540  else if (aeta < 2.5)
2541  sampling = -1.05 + 0.52 * aeta;
2542 
2543  return sampling;
2544 }
2545 
2546 // sampling term uncertainty
2547 
2548 double egammaEnergyCorrectionTool::mcSamplingTermRelError(double cl_eta) {
2549 
2550  (void)cl_eta; // not used
2551  return 0.1; // when will this be improved?
2552 }
2553 
2554 // noise term in MC (from Iro)
2555 
2556 double egammaEnergyCorrectionTool::mcNoiseTerm(double cl_eta) {
2557 
2558  double aeta = std::abs(cl_eta);
2559  double noise = 0.;
2560 
2561  double noise37[25] = {0.27, 0.27, 0.27, 0.27, 0.27, 0.26, 0.25, 0.23, 0.21,
2562  0.19, 0.17, 0.16, 0.15, 0.14, 0.27, 0.23, 0.17, 0.15,
2563  0.13, 0.10, 0.07, 0.06, 0.05, 0.04, 0.03};
2564 
2565  int ieta = (int)(aeta / 0.1);
2566 
2567  if (ieta >= 0 && ieta < 25)
2568  noise = noise37[ieta] * cosh(cl_eta); // the above parametrization is vs ET
2569 
2570  return noise;
2571 }
2572 
2573 // constant term in MC (local)
2574 
2575 double egammaEnergyCorrectionTool::mcConstantTerm(double cl_eta) {
2576 
2577  double aeta = std::abs(cl_eta);
2578  double cst = 0.;
2579 
2580  if (aeta < 0.6)
2581  cst = 0.005;
2582 
2583  else if (aeta < 1.75)
2584  cst = 0.003;
2585 
2586  else if (aeta < 2.5)
2587  cst = 0.0055 * (2.69 - aeta);
2588 
2589  // cst = 0.005;
2590 
2591  return cst;
2592 }
2593 
2594 // constant term fitted in data (long range)
2595 
2596 double egammaEnergyCorrectionTool::dataConstantTerm(double eta) const {
2597  return std::max(0., m_resNom->GetBinContent(m_resNom->FindFixBin(eta)));
2598 }
2599 
2600 double egammaEnergyCorrectionTool::dataConstantTermError(double eta) const {
2601  return m_resSyst->GetBinContent(m_resSyst->FindFixBin(eta));
2602 }
2603 
2604 double egammaEnergyCorrectionTool::dataConstantTermOFCError(double eta) const {
2605  return m_resSystOFC->GetBinContent(m_resSystOFC->FindFixBin(eta));
2606 }
2607 
2608 // fitted Z peak resolution, data, in GeV
2609 
2610 double egammaEnergyCorrectionTool::dataZPeakResolution(double cl_eta) const {
2611 
2612  return m_peakResData->GetBinContent(
2613  std::as_const(*m_peakResData).GetXaxis()->FindBin(cl_eta));
2614 }
2615 
2616 // fitted Z peak resolution, MC, in GeV
2617 
2618 double egammaEnergyCorrectionTool::mcZPeakResolution(double cl_eta) const {
2619 
2620  return m_peakResMC->GetBinContent(
2621  std::as_const(*m_peakResMC).GetXaxis()->FindBin(cl_eta));
2622 }
2623 
2624 // correlated part of constant term uncertainty, in data (approx.)
2625 
2626 double egammaEnergyCorrectionTool::dataConstantTermCorError(
2627  double cl_eta) const {
2628 
2629  double mz = 91.2;
2630 
2631  double resData = dataZPeakResolution(cl_eta);
2632  double resMC = mcZPeakResolution(cl_eta);
2633  double cmc = mcConstantTerm(cl_eta);
2634 
2635  double smpup = 1. + mcSamplingTermRelError(cl_eta);
2636  double smpdo = 1. - mcSamplingTermRelError(cl_eta);
2637 
2638  double central =
2639  sqrt(2 * (resData * resData - resMC * resMC) / mz / mz + cmc * cmc);
2640  double vardown =
2641  sqrt(2 * (resData * resData - resMC * resMC * smpup * smpup) / mz / mz +
2642  cmc * cmc);
2643  double varup =
2644  sqrt(2 * (resData * resData - resMC * resMC * smpdo * smpdo) / mz / mz +
2645  cmc * cmc);
2646 
2647  double errdown = std::abs(central - vardown);
2648  double errup = std::abs(central - varup);
2649 
2650  return .5 * (errup + errdown);
2651 }
2652 
2653 // get fractional uncertainty on resolution
2654 
2655 double egammaEnergyCorrectionTool::getResolutionError(
2656  PATCore::ParticleDataType::DataType dataType, double energy, double eta,
2657  double etaCalo, PATCore::ParticleType::Type ptype,
2658  egEnergyCorr::Resolution::Variation value,
2659  egEnergyCorr::Resolution::resolutionType resType) const
2660 
2661 {
2662 
2663  int eg_resolution_ptype;
2664  if (ptype == PATCore::ParticleType::Electron)
2665  eg_resolution_ptype = 0;
2666  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2667  eg_resolution_ptype = 1;
2668  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2669  eg_resolution_ptype = 2;
2670  else
2671  return -1;
2672 
2673  int isys = 0;
2674  if (value == egEnergyCorr::Resolution::AllUp ||
2675  value == egEnergyCorr::Resolution::AllDown) {
2676  isys = 0xFFFF;
2677  }
2678  if (value == egEnergyCorr::Resolution::ZSmearingUp ||
2679  value == egEnergyCorr::Resolution::ZSmearingDown) {
2680  isys = 0x1;
2681  }
2682  if (value == egEnergyCorr::Resolution::SamplingTermUp ||
2683  value == egEnergyCorr::Resolution::SamplingTermDown) {
2684  isys = 0x2;
2685  }
2686  if (value == egEnergyCorr::Resolution::MaterialIDUp ||
2687  value == egEnergyCorr::Resolution::MaterialIDDown) {
2688  isys = 0x4;
2689  }
2690  if (value == egEnergyCorr::Resolution::MaterialCaloUp ||
2691  value == egEnergyCorr::Resolution::MaterialCaloDown) {
2692  isys = 0x8;
2693  }
2694  if (value == egEnergyCorr::Resolution::MaterialGapUp ||
2695  value == egEnergyCorr::Resolution::MaterialGapDown) {
2696  isys = 0x10;
2697  }
2698  if (value == egEnergyCorr::Resolution::MaterialCryoUp ||
2699  value == egEnergyCorr::Resolution::MaterialCryoDown) {
2700  isys = 0x20;
2701  }
2702  if (value == egEnergyCorr::Resolution::PileUpUp ||
2703  value == egEnergyCorr::Resolution::PileUpDown) {
2704  isys = 0x40;
2705  }
2706 
2707  if (value == egEnergyCorr::Resolution::MaterialIBLUp ||
2708  value == egEnergyCorr::Resolution::MaterialIBLDown) {
2709  isys = 0x80;
2710  }
2711  if (value == egEnergyCorr::Resolution::MaterialPP0Up ||
2712  value == egEnergyCorr::Resolution::MaterialPP0Down) {
2713  isys = 0x100;
2714  }
2715  if (value == egEnergyCorr::Resolution::af2Up ||
2716  value == egEnergyCorr::Resolution::af2Down) {
2717  isys = 0x200;
2718  }
2719  if (value == egEnergyCorr::Resolution::OFCUp ||
2720  value == egEnergyCorr::Resolution::OFCDown) {
2721  isys = 0x400;
2722  }
2723 
2724  double sign = 1.;
2725  if (value == egEnergyCorr::Resolution::AllDown ||
2726  value == egEnergyCorr::Resolution::ZSmearingDown ||
2727  value == egEnergyCorr::Resolution::SamplingTermDown ||
2728  value == egEnergyCorr::Resolution::MaterialIDDown ||
2729  value == egEnergyCorr::Resolution::MaterialGapDown ||
2730  value == egEnergyCorr::Resolution::MaterialCaloDown ||
2731  value == egEnergyCorr::Resolution::MaterialCryoDown ||
2732  value == egEnergyCorr::Resolution::PileUpDown ||
2733  value == egEnergyCorr::Resolution::MaterialIBLDown ||
2734  value == egEnergyCorr::Resolution::MaterialPP0Down ||
2735  value == egEnergyCorr::Resolution::af2Down ||
2736  value == egEnergyCorr::Resolution::OFCDown)
2737  sign = -1.;
2738 
2739  double resolution;
2740  double resolution_error;
2741  double resolution_error_up;
2742  double resolution_error_down;
2743 
2744  getResolution_systematics(eg_resolution_ptype, energy, eta, etaCalo, isys,
2745  resolution, resolution_error, resolution_error_up,
2746  resolution_error_down, resType,
2747  dataType == PATCore::ParticleDataType::Fast);
2748 
2749  // total resolution uncertainty
2750  if (value == egEnergyCorr::Resolution::AllUp ||
2751  value == egEnergyCorr::Resolution::AllDown) {
2752  resolution_error = resolution_error / resolution * sign;
2753  } else {
2754  if (sign == 1)
2755  resolution_error = resolution_error_up / resolution;
2756  else
2757  resolution_error = resolution_error_down / resolution;
2758  }
2759 
2760  return resolution_error;
2761 }
2762 
2763 // total resolution uncertainty (fractional) (OLD model)
2764 
2765 void egammaEnergyCorrectionTool::resolutionError(double energy /* GeV! */,
2766  double cl_eta, double& errUp,
2767  double& errDown) const {
2768 
2769  double Cdata = dataConstantTerm(cl_eta);
2770  double Cdata_cor = dataConstantTermCorError(cl_eta);
2771  double Cdata_err = dataConstantTermError(cl_eta);
2772 
2773  double Cdata_unc = 0.;
2774  if (Cdata_err > Cdata_cor)
2775  Cdata_unc = sqrt(Cdata_err * Cdata_err - Cdata_cor * Cdata_cor);
2776  if (Cdata_unc < 0.001)
2777  Cdata_unc = 0.001; // preserve at least the stat error
2778 
2779  double Smc = mcSamplingTerm(cl_eta);
2780  double Smc_err = mcSamplingTermRelError(cl_eta);
2781 
2782  double central = fcn_sigma(energy, Cdata, 0., Smc, 0.);
2783 
2784  double err1 = fcn_sigma(energy, Cdata, Cdata_unc, Smc, 0.) - central;
2785  double err2 = fcn_sigma(energy, Cdata, -Cdata_unc, Smc, 0.) - central;
2786  double err3 = fcn_sigma(energy, Cdata, -Cdata_cor, Smc, Smc_err) - central;
2787  double err4 = -err3;
2788 
2789  errUp = 0;
2790  if (err1 > 0)
2791  errUp = sqrt(errUp * errUp + err1 * err1);
2792  if (err2 > 0)
2793  errUp = sqrt(errUp * errUp + err2 * err2);
2794  if (err3 > 0)
2795  errUp = sqrt(errUp * errUp + err3 * err3);
2796  if (err4 > 0)
2797  errUp = sqrt(errUp * errUp + err4 * err4);
2798 
2799  errDown = -errUp;
2800 }
2801 
2802 // total resolution (fractional)
2803 
2804 double egammaEnergyCorrectionTool::resolution(
2805  double energy, double cl_eta, double cl_etaCalo,
2806  PATCore::ParticleType::Type ptype, bool withCT, bool fast,
2807  egEnergyCorr::Resolution::resolutionType resType) const {
2808  int eg_resolution_ptype;
2809  if (ptype == PATCore::ParticleType::Electron)
2810  eg_resolution_ptype = 0;
2811  else if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2812  eg_resolution_ptype = 1;
2813  else if (ptype == PATCore::ParticleType::ConvertedPhoton)
2814  eg_resolution_ptype = 2;
2815  else {
2816  ATH_MSG_FATAL("cannot understand particle type");
2817  return -1;
2818  }
2819 
2820  double sig2 = 0.;
2821 
2822  if (m_use_new_resolution_model) {
2823  sig2 = pow(m_resolution_tool->getResolution(eg_resolution_ptype, energy,
2824  cl_eta, resType),
2825  2);
2826  const double et = energy / cosh(cl_eta);
2827  sig2 += pow(pileUpTerm(energy, cl_eta, eg_resolution_ptype) / et,
2828  2); // TODO: why et and not E?
2829  } else { // OLD model
2830 
2831  double energyGeV = energy / GeV;
2832  double a = mcSamplingTerm(cl_eta);
2833  double b = mcNoiseTerm(cl_eta);
2834  double c = mcConstantTerm(cl_eta);
2835  sig2 = a * a / energyGeV + b * b / energyGeV / energyGeV + c * c;
2836  }
2837 
2838  if (withCT and fast) {
2839  throw std::runtime_error(
2840  "It doesn't make sense to ask resolution fast sim + additional CT."
2841  " The resolution on data is FULL sim resolution + CT");
2842  }
2843 
2844  if (fast and std::abs(cl_eta) < 2.5) {
2845  if (m_esmodel == egEnergyCorr::es2017 or
2846  m_esmodel == egEnergyCorr::es2017_summer or
2847  m_esmodel == egEnergyCorr::es2017_summer_improved or
2848  m_esmodel == egEnergyCorr::es2017_summer_final or
2849  m_esmodel == egEnergyCorr::es2017_R21_PRE or
2850  m_esmodel == egEnergyCorr::es2015_5TeV or
2851  m_esmodel == egEnergyCorr::es2015PRE or
2852  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
2853  m_esmodel == egEnergyCorr::es2015cPRE or
2854  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
2855  m_esmodel == egEnergyCorr::es2015c_summer or
2856  m_esmodel == egEnergyCorr::es2016PRE or
2857  m_esmodel == egEnergyCorr::es2017_R21_v0 or
2858  m_esmodel == egEnergyCorr::es2017_R21_v1 or
2859  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
2860  m_esmodel == egEnergyCorr::es2018_R21_v0 or
2861  m_esmodel == egEnergyCorr::es2018_R21_v1 or
2862  m_esmodel == egEnergyCorr::es2022_R22_PRE or
2863  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2864 
2865  double ratio_IQR_full_fast = 1.;
2866  const double ptGeV = energy / cosh(cl_eta) / 1E3;
2867 
2868  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
2869  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
2870  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
2871  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
2872  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
2873  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
2874  //
2875  // for es2017_R21_v1, histograms contain directly values of
2876  // deltaSigma**2 of relative energy resolution (FastSIm-FulSim) so need
2877  // to subtract this value to get the sigma**2 of FastSim
2878 
2879  if (ptype == PATCore::ParticleType::Electron)
2880  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_electron, cl_eta,
2881  ptGeV, true, true, true, true);
2882  if (ptype == PATCore::ParticleType::UnconvertedPhoton)
2883  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_unconverted, cl_eta,
2884  ptGeV, true, true, true, true);
2885  if (ptype == PATCore::ParticleType::ConvertedPhoton)
2886  sig2 -= getValueHistAt(*m_G4OverAFII_resolution_converted, cl_eta,
2887  ptGeV, true, true, true, true);
2888  if (sig2 < 0.)
2889  sig2 = 0.;
2890  } else {
2891  if (ptype == PATCore::ParticleType::Electron) {
2892  ratio_IQR_full_fast = getValueHistAt(
2893  *m_G4OverAFII_resolution_electron, ptGeV, cl_eta, true, false);
2894  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
2895  ratio_IQR_full_fast = getValueHistAt(
2896  *m_G4OverAFII_resolution_unconverted, ptGeV, cl_eta, true, false);
2897  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
2898  ratio_IQR_full_fast = getValueHistAt(
2899  *m_G4OverAFII_resolution_converted, ptGeV, cl_eta, true, false);
2900  }
2901 
2902  sig2 /= ratio_IQR_full_fast * ratio_IQR_full_fast;
2903  }
2904  }
2905  }
2906 
2907  // add the additional constant term from the Zee data/MC measurement
2908  if (withCT)
2909  sig2 += pow(
2910  dataConstantTerm(m_use_etaCalo_scales ? cl_etaCalo : cl_eta),
2911  2); // TODO: is it correct? Or should be += -c**2 + (c + deltac) ** 2 ?
2912 
2913  return sqrt(sig2);
2914 }
2915 
2916 // internal use only
2917 
2918 double egammaEnergyCorrectionTool::fcn_sigma(double energy, double Cdata,
2919  double Cdata_er, double S,
2920  double S_er) {
2921 
2922  double sigma2 = std::pow((Cdata + Cdata_er) * energy, 2) +
2923  std::pow(S * (1 + S_er) * std::sqrt(energy), 2);
2924 
2925  double sigma = 0;
2926  if (sigma2 > 0)
2927  sigma = sqrt(sigma2);
2928 
2929  return sigma / energy;
2930 }
2931 
2932 // derive smearing correction
2933 
2934 double egammaEnergyCorrectionTool::getSmearingCorrection(
2935  double cl_eta, double cl_etaCalo, double energy, RandomNumber seed,
2936  PATCore::ParticleType::Type ptype,
2937  PATCore::ParticleDataType::DataType dataType,
2938  egEnergyCorr::Resolution::Variation value,
2939  egEnergyCorr::Resolution::resolutionType resType) const {
2940 
2941  if (dataType == PATCore::ParticleDataType::Data) {
2942  ATH_MSG_FATAL("Trying to compute smearing correction on data");
2943  }
2944 
2945  if (value == egEnergyCorr::Resolution::None || energy <= 0.)
2946  return 1.0;
2947 
2948  const double energyGeV = energy / GeV;
2949 
2950  // relative resolutions
2951  const double resMC =
2952  resolution(energy, cl_eta, cl_etaCalo, ptype, false, // no additional CT
2953  dataType == PATCore::ParticleDataType::Fast, resType);
2954  double resData =
2955  resolution(energy, cl_eta, cl_etaCalo, ptype, true, // with additional CT
2956  false, resType); // on top of Full simulation
2957 
2958  ATH_MSG_DEBUG("resolution in data: " << resData << " in MC: " << resMC);
2959 
2960  if (m_use_new_resolution_model) {
2961  resData *= 1 + getResolutionError(dataType, energy, cl_eta, cl_etaCalo,
2962  ptype, value, resType);
2963  } else { // OLD model
2964  double errUp, errDown;
2965  resolutionError(energyGeV, cl_eta, errUp, errDown);
2966  if (value == egEnergyCorr::Resolution::AllDown)
2967  resData += errDown;
2968  else if (value == egEnergyCorr::Resolution::AllUp)
2969  resData += errUp;
2970  else if (value != egEnergyCorr::Resolution::Nominal) {
2971  // std::cout << "getSmearingCorrection : wrong value, return 1" <<
2972  // std::endl;
2973  return 1.0;
2974  }
2975  }
2976 
2977  ATH_MSG_DEBUG("resolution in data after systematics: " << resData);
2978 
2979  const double sigma2 =
2980  std::pow(resData * energyGeV, 2) - std::pow(resMC * energyGeV, 2);
2981 
2982  // TODO: for nominal case it can be simplified to:
2983  // const double sigma = dataConstantTerm(m_use_etaCalo_scales ? cl_etaCalo :
2984  // cl_eta) * energyGeV; which is just the additional constant term
2985  if (sigma2 <= 0) {
2986  return 1;
2987  }
2988 
2989  const double sigma = sqrt(sigma2);
2990 
2991  TRandom3 rng(seed);
2992 
2993  const double DeltaE0 = rng.Gaus(0, sigma);
2994  const double cor0 = (energyGeV + DeltaE0) / energyGeV;
2995 
2996  ATH_MSG_DEBUG("sigma|DeltaE0|cor0|seed = " << sigma << "|" << DeltaE0 << "|"
2997  << cor0 << "|" << rng.GetSeed());
2998 
2999  return cor0; // TODO: why not returning DeltaE0 and apply E -> E + DeltaE0 ?
3000 }
3001 
3002 // a calibration correction for crack electrons, to be applied to both data11
3003 // and MC11 not to be used in data12 / MC12
3004 
3005 double egammaEnergyCorrectionTool::applyMCCalibration(
3006  double eta, double ET, PATCore::ParticleType::Type ptype) const {
3007 
3008  if (ptype != PATCore::ParticleType::Electron ||
3009  m_esmodel != egEnergyCorr::es2011c)
3010  return 1.;
3011 
3012  double aeta = std::abs(eta);
3013 
3014  if (aeta < 1.42 || aeta > 1.55)
3015  return 1.;
3016 
3017  const int nBoundaries = 18;
3018  double ETBoundaries[nBoundaries] = {0., 5.4, 8.5, 12.9, 16., 20.,
3019  25., 30., 35., 40., 45., 50.,
3020  55., 60., 65., 70., 75., 99999.};
3021 
3022  double CalibFactors[nBoundaries - 1] = {
3023  0.884845, 0.898526, 0.902439, 0.91899, 0.925868, 0.929440,
3024  0.948080, 0.943788, 0.96026, 0.955709, 0.964285, 0.95762,
3025  0.970385, 0.963489, 0.968149, 0.970799, 0.961617};
3026 
3027  int i0 = -1;
3028  for (int i = 0; i < nBoundaries - 1; i++)
3029  if (ET / GeV > ETBoundaries[i] && ET / GeV <= ETBoundaries[i + 1])
3030  i0 = i;
3031 
3032  if (i0 >= 0 && i0 < nBoundaries - 1)
3033  return 1. / CalibFactors[i0];
3034 
3035  return 1.;
3036 }
3037 
3038 // AF -> G4 correction
3039 
3040 double egammaEnergyCorrectionTool::applyAFtoG4(
3041  double eta, double ptGeV, PATCore::ParticleType::Type ptype) const {
3042  const double aeta = std::abs(eta);
3043  if (aeta > 2.47)
3044  return 1.;
3045 
3046  if (m_esmodel == egEnergyCorr::es2015PRE or
3047  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3048  m_esmodel == egEnergyCorr::es2015cPRE or
3049  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3050  m_esmodel == egEnergyCorr::es2015c_summer or
3051  m_esmodel == egEnergyCorr::es2016PRE or
3052  m_esmodel == egEnergyCorr::es2017 or
3053  m_esmodel == egEnergyCorr::es2017_summer or
3054  m_esmodel == egEnergyCorr::es2017_summer_improved or
3055  m_esmodel == egEnergyCorr::es2017_summer_final or
3056  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3057  m_esmodel == egEnergyCorr::es2017_R21_v0 or
3058  m_esmodel == egEnergyCorr::es2017_R21_v1 or
3059  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
3060  m_esmodel == egEnergyCorr::es2018_R21_v0 or
3061  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3062  m_esmodel == egEnergyCorr::es2022_R22_PRE or
3063  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
3064 
3065  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
3066  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
3067  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3068  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
3069  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
3070  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
3071  //
3072  // in es02017_R21_v1 : AF2 to FullSim correction is in a 2D eta-Pt
3073  // histogram
3074 
3075  if (ptype == PATCore::ParticleType::Electron) {
3076  return (1. + getValueHistAt(*m_G4OverAFII_electron_2D, aeta, ptGeV,
3077  true, true, true, true));
3078  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3079  return (1. + getValueHistAt(*m_G4OverAFII_converted_2D, aeta, ptGeV,
3080  true, true, true, true));
3081  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3082  return (1. + getValueHistAt(*m_G4OverAFII_unconverted_2D, aeta, ptGeV,
3083  true, true, true, true));
3084  } else {
3085  throw std::runtime_error("particle not valid");
3086  }
3087  } else {
3088  if (ptype == PATCore::ParticleType::Electron) {
3089  return getValueHistoAt(*m_G4OverAFII_electron, aeta);
3090  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3091  return getValueHistoAt(*m_G4OverAFII_converted, aeta);
3092  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3093  return getValueHistoAt(*m_G4OverAFII_unconverted, aeta);
3094  } else {
3095  throw std::runtime_error("particle not valid");
3096  }
3097  }
3098  } else {
3099  // run 1
3100  return m_G4OverAFII_electron->GetBinContent(
3101  std::as_const(*m_G4OverAFII_electron).GetXaxis()->FindBin(eta));
3102  }
3103 }
3104 
3105 // Frozen Showers -> G4 correction
3106 
3107 double egammaEnergyCorrectionTool::applyFStoG4(double eta) const {
3108 
3109  double aeta = std::abs(eta);
3110  if (aeta < 3.3 || aeta > 4.9)
3111  return 1.;
3112 
3113  return m_G4OverFrSh->GetBinContent(
3114  std::as_const(*m_G4OverFrSh).GetXaxis()->FindBin(aeta));
3115 }
3116 
3117 // functions for energy scale corrections
3118 
3119 double egammaEnergyCorrectionTool::getAlphaZee(
3120  long int runnumber, double eta, egEnergyCorr::Scale::Variation var,
3121  double varSF) const {
3122 
3123  if (!m_zeeNom) {
3124  ATH_MSG_FATAL("no data for Zee");
3125  return -999.0;
3126  }
3127 
3128  double value = 0.;
3129  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
3130  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3131  value = m_zeeNom->GetBinContent(ieta);
3132  } else {
3133  if (runnumber > 341649 && runnumber <= 364292) {
3134  // 2018 runnumber range
3135  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3136  value = m_zeeNom->GetBinContent(ieta);
3137  } else if (runnumber > 364292) {
3138  ATH_MSG_WARNING(
3139  "es2023_R22_Run2_v0 is only valid for Run-2 data! using 2018 scales");
3140  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3141  value = m_zeeNom->GetBinContent(ieta);
3142  }
3143  }
3144 
3145  if ((m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3146  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
3147  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3148  runnumber <= 341649 && runnumber >= 324320) {
3149  int ieta = std::as_const(*m_zeeNom_data2017).GetXaxis()->FindBin(eta);
3150  value = m_zeeNom_data2017->GetBinContent(ieta);
3151  }
3152 
3153  // for es2017_R21_v0 different set of scales for 2017, 2016 and 2015 data
3154  if (m_esmodel == egEnergyCorr::es2017_R21_v0 && runnumber < 322817 &&
3155  runnumber >= 297000) {
3156  int ieta = std::as_const(*m_zeeNom_data2016).GetXaxis()->FindBin(eta);
3157  value = m_zeeNom_data2016->GetBinContent(ieta);
3158  }
3159 
3160  if ((m_esmodel == egEnergyCorr::es2017_R21_v1 ||
3161  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3162  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
3163  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3164  runnumber < 322817 && runnumber >= 297000) {
3165  int ieta = std::as_const(*m_zeeNom_data2016).GetXaxis()->FindBin(eta);
3166  value = m_zeeNom_data2016->GetBinContent(ieta);
3167  }
3168 
3169  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber < 322817 &&
3170  runnumber >= 297000) {
3171  int ieta = std::as_const(*m_zeeNom_data2016).GetXaxis()->FindBin(eta);
3172  value = m_zeeNom_data2016->GetBinContent(ieta);
3173  }
3174 
3175  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber < 297000) {
3176  int ieta = std::as_const(*m_zeeNom_data2015).GetXaxis()->FindBin(eta);
3177  value = m_zeeNom_data2015->GetBinContent(ieta);
3178  }
3179 
3180  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber > 347847) {
3181  int ieta = std::as_const(*m_zeeNom_data2018).GetXaxis()->FindBin(eta);
3182  value = m_zeeNom_data2018->GetBinContent(ieta);
3183  }
3184 
3185  if ((m_esmodel == egEnergyCorr::es2017 or
3186  m_esmodel == egEnergyCorr::es2017_summer or
3187  m_esmodel == egEnergyCorr::es2017_summer_improved or
3188  m_esmodel == egEnergyCorr::es2017_summer_final or
3189  m_esmodel == egEnergyCorr::es2015_5TeV or
3190  m_esmodel == egEnergyCorr::es2017_R21_v0 or
3191  m_esmodel == egEnergyCorr::es2017_R21_v1 or
3192  m_esmodel == egEnergyCorr::es2018_R21_v0 or
3193  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3194  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3195  runnumber < 297000) {
3196  // 2 sets of scales for this configuration
3197  // change histogram if 2015 data
3198  int ieta = std::as_const(*m_zeeNom_data2015).GetXaxis()->FindBin(eta);
3199  value = m_zeeNom_data2015->GetBinContent(ieta);
3200  }
3201 
3202  if (m_esmodel == egEnergyCorr::es2015PRE or
3203  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3204  m_esmodel == egEnergyCorr::es2015cPRE or
3205  m_esmodel == egEnergyCorr::es2015cPRE_res_improved) {
3206  // special case for es2015PRE
3207  // additional correction due to LAr temperature effect
3208  // for extrapolation 2012 -> 2015 temperature change
3209  // numbers from Guillaume 20150506
3210  /*
3211  2012 (K) 22/04/2015 DeltaResponse 2015/2012 (-2%/K) deltaAlpha
3212  EndCap C 88.41 88.63 -0.45% -0.45%
3213  Barrel C 88.47 88.70 -0.46% -0.46%
3214  Barrel A 88.50 88.71 -0.42% -0.42%
3215  EndCap A 88.70 88.70 +0.00% +0.00%
3216  */
3217  if (eta >= 0) { // side A
3218  if (eta < 1.45)
3219  value += -0.42E-2;
3220  else if (eta < 3.2)
3221  value += 0.;
3222  } else { // side C
3223  if (eta > -1.45)
3224  value += -0.46E-2;
3225  else if (eta > -3.2)
3226  value += -0.45E-2;
3227  }
3228 
3229  // special case for es2015PRE
3230  // additional correction for uA->MeV first 2 weeks 2015 data
3231  if (runnumber >= 266904 and runnumber <= 267639 and
3232  m_use_uA2MeV_2015_first2weeks_correction) {
3233  const double uA2MeV_correction =
3234  m_uA2MeV_2015_first2weeks_correction->GetBinContent(
3235  m_uA2MeV_2015_first2weeks_correction->FindFixBin(std::abs(eta)));
3236  // this takes into account also O((uA2MeV_correction - 1) * alpha) terms
3237  // a simpler formula would be: value + uA2MeV_correction - 1
3238  value = uA2MeV_correction * (1 + value) - 1;
3239  }
3240  } // end special case for es2015PRE*
3241 
3242  if ((m_esmodel == egEnergyCorr::es2015c_summer or
3243  m_esmodel == egEnergyCorr::es2016PRE) and
3244  m_use_temp_correction201215) {
3245  // keep the correction 2012->2015 for |eta| > 2.5
3246  // if (eta > 2.5 and eta < 3.2) value += 0.;
3247  if (eta < -2.5 and eta > -3.2)
3248  value += -0.45E-2;
3249  }
3250 
3251  if (m_esmodel == egEnergyCorr::es2015c_summer or
3252  m_esmodel ==
3253  egEnergyCorr::es2016PRE) { // correction for the extrapolation from
3254  // es2015_summer
3255  if (runnumber >= 297000) { // only for 2016 data
3256  if (eta >= 0) { // side A
3257  if (eta < 1.45)
3258  value *= 1.00028;
3259  else if (eta < 3.2)
3260  value *= 1.00018;
3261  } else { // side C
3262  if (eta > -1.45)
3263  value *= 1.00028;
3264  else if (eta > -3.2)
3265  value *= 0.99986;
3266  }
3267  }
3268  }
3269 
3270  ATH_MSG_DEBUG("getAlphaZee, def alpha " << value << " at eta = " << eta);
3271 
3272  if (var == egEnergyCorr::Scale::ZeeStatUp or
3273  var == egEnergyCorr::Scale::ZeeStatDown) {
3274  const double sign = (var == egEnergyCorr::Scale::ZeeStatUp) ? 1 : -1;
3275 
3276  TH1* h = ((TH1*)m_zeeNom.get());
3277 
3278  if ((m_esmodel == egEnergyCorr::es2017 or
3279  m_esmodel == egEnergyCorr::es2017_summer or
3280  m_esmodel == egEnergyCorr::es2017_summer_improved or
3281  m_esmodel == egEnergyCorr::es2017_summer_final or
3282  m_esmodel == egEnergyCorr::es2015_5TeV or
3283  m_esmodel == egEnergyCorr::es2017_R21_v0 or
3284  m_esmodel == egEnergyCorr::es2017_R21_v1 or
3285  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
3286  m_esmodel == egEnergyCorr::es2018_R21_v0 or
3287  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3288  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3289  runnumber < 297000) {
3290  h = ((TH1*)m_zeeNom_data2015.get()); // special for 2015 with es2017
3291  }
3292  if ((m_esmodel == egEnergyCorr::es2017_R21_v0 ||
3293  m_esmodel == egEnergyCorr::es2017_R21_v1 ||
3294  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
3295  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3296  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3297  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3298  runnumber >= 297000 && runnumber < 322817) {
3299  h = m_zeeNom_data2016.get(); // 2016 data
3300  }
3301  if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 && runnumber > 347847) {
3302  h = m_zeeNom_data2018.get();
3303  }
3304  if ((m_esmodel == egEnergyCorr::es2018_R21_v0 ||
3305  m_esmodel == egEnergyCorr::es2018_R21_v1 or
3306  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
3307  runnumber >= 324320 && runnumber <= 341649) {
3308  h = ((TH1*)m_zeeNom_data2017.get()); // 2017 data
3309  }
3310  double stat_error = h->GetBinError(h->FindFixBin(eta));
3311  if (m_use_stat_error_scaling) {
3312  stat_error = stat_error / sqrt(h->GetNbinsX());
3313  }
3314  value += sign * stat_error * varSF;
3315  } else if (var == egEnergyCorr::Scale::ZeeSystUp && m_zeeSyst) {
3316  value += get_ZeeSyst(eta) * varSF;
3317 
3318  } else if (var == egEnergyCorr::Scale::ZeeSystDown && m_zeeSyst) {
3319  value -= get_ZeeSyst(eta) * varSF;
3320  } else if (var == egEnergyCorr::Scale::OFCUp && m_zeeSystOFC) {
3321  value += get_OFCSyst(eta) * varSF;
3322  } else if (var == egEnergyCorr::Scale::EXTRARUN3PREUp &&
3323  m_esmodel ==
3324  egEnergyCorr::es2022_R22_PRE) // as this is a flat 0.4% syst
3325  // hardcoded, need to switch on
3326  // only for es2022_R22_PRE. OFC
3327  // should be OK, as the OFC file
3328  // is only defined for this
3329  // pre-recommendation.
3330  {
3331  value +=
3332  0.4E-2 *
3333  varSF; // flat 0.4% syst (details:
3334  // https://indico.cern.ch/event/1250560/contributions/5253619/attachments/2586538/4462853/mc21-change.pdf)
3335  } else if (var == egEnergyCorr::Scale::EXTRARUN3PREDown &&
3336  m_esmodel == egEnergyCorr::es2022_R22_PRE) {
3337  value -= 0.4E-2 * varSF;
3338  } else if (var == egEnergyCorr::Scale::OFCDown && m_zeeSystOFC) {
3339  value -= get_OFCSyst(eta) * varSF;
3340  } else if (var == egEnergyCorr::Scale::ZeePhysUp && m_zeePhys) {
3341 
3342  int ieta = std::as_const(*m_zeePhys).GetXaxis()->FindBin(eta);
3343  value += m_zeePhys->GetBinContent(ieta) * varSF;
3344 
3345  } else if (var == egEnergyCorr::Scale::ZeePhysDown && m_zeePhys) {
3346 
3347  int ieta = std::as_const(*m_zeePhys).GetXaxis()->FindBin(eta);
3348  value -= m_zeePhys->GetBinContent(ieta) * varSF;
3349 
3350  } else if ((var == egEnergyCorr::Scale::LArTemperature2015PreUp or
3351  var == egEnergyCorr::Scale::LArTemperature2015PreDown) and
3352  (m_esmodel == egEnergyCorr::es2015PRE or
3353  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3354  m_esmodel == egEnergyCorr::es2015cPRE or
3355  m_esmodel == egEnergyCorr::es2015cPRE_res_improved) and
3356  m_use_temp_correction201215) {
3357  // special case only for es2015PRE
3358  // add LAr temperature effect for extrapolation 2012 -> 2015 temperature
3359  // change numbers from Guillaume 20150506
3360 
3361  const double aeta = std::abs(eta);
3362  const double sign =
3363  (var == egEnergyCorr::Scale::LArTemperature2015PreUp) ? 1 : -1;
3364  if (aeta < 1.45) {
3365  value += 0.15E-2 * sign;
3366  } else if (aeta > 1.45 and aeta < 3.2) {
3367  value += 0.25E-2 * sign;
3368  }
3369  }
3370 
3371  else if ((var == egEnergyCorr::Scale::LArTemperature2015PreUp or
3372  var == egEnergyCorr::Scale::LArTemperature2015PreDown) and
3373  (m_esmodel == egEnergyCorr::es2015c_summer or
3374  m_esmodel == egEnergyCorr::es2016PRE) and
3375  m_use_temp_correction201215) {
3376  // keep 2012->2015 extrapolation correction for eta > 2.5
3377  const double aeta = std::abs(eta);
3378  const double sign =
3379  (var == egEnergyCorr::Scale::LArTemperature2015PreUp) ? 1 : -1;
3380  if (aeta > 2.5 and aeta < 3.2) {
3381  value += 0.25E-2 * sign;
3382  }
3383  }
3384 
3385  else if ((var == egEnergyCorr::Scale::LArTemperature2016PreUp or
3386  var == egEnergyCorr::Scale::LArTemperature2016PreDown) and
3387  (m_esmodel == egEnergyCorr::es2016PRE) and
3388  m_use_temp_correction201516) {
3389  // special case for es2016PRE (extrapolation from 2015)
3390  const double sign =
3391  (var == egEnergyCorr::Scale::LArTemperature2016PreUp) ? 1 : -1;
3392  // temp + pileup
3393  value += qsum(0.05E-2, 0.02E-2) *
3394  sign; // Guillaume email 23/05/2016 + 26/5/2016
3395  }
3396 
3397  else if (var == egEnergyCorr::Scale::ZeeAllDown ||
3398  var == egEnergyCorr::Scale::ZeeAllUp) {
3399 
3400  int ieta = std::as_const(*m_zeeNom).GetXaxis()->FindBin(eta);
3401  double diff = pow(m_zeeNom->GetBinError(ieta) * varSF, 2);
3402 
3403  if (m_zeeSyst) {
3404  diff += pow(get_ZeeSyst(eta) * varSF, 2);
3405  }
3406 
3407  if (m_zeePhys) {
3408  ieta = std::as_const(*m_zeePhys).GetXaxis()->FindBin(eta);
3409  diff += pow(m_zeePhys->GetBinContent(ieta) * varSF, 2);
3410  }
3411 
3412  if (var == egEnergyCorr::Scale::ZeeAllUp)
3413  value += sqrt(diff);
3414  else if (var == egEnergyCorr::Scale::ZeeAllDown)
3415  value -= sqrt(diff);
3416  }
3417 
3418  return value;
3419 }
3420 
3421 double egammaEnergyCorrectionTool::getE4Uncertainty(double eta) {
3422  const double aeta = std::abs(eta);
3423  if ((aeta > 1.6) or (aeta < 1.4)) {
3424  return 0.;
3425  }
3426 
3427  // numbers from Archil 20/5/2016
3428 
3429  double data_mc_difference = 0.;
3430  if (aeta < 1.46) {
3431  data_mc_difference = 1E-2;
3432  } // 1.4 - 1.46
3433  else if (aeta < 1.52) {
3434  data_mc_difference = 3E-2;
3435  } // 1.46 - 1.52
3436  else {
3437  data_mc_difference = 4.3E-2;
3438  } // 1.52 - 1.6
3439 
3440  const double em_scale = 2.4E-2;
3441  const double mbias = 1E-2; // Archil presentation 26/5/2016
3442  const double laser = 4E-2;
3443 
3444  return std::sqrt(data_mc_difference * data_mc_difference +
3445  em_scale * em_scale + mbias * mbias + laser * laser);
3446 }
3447 
3448 double egammaEnergyCorrectionTool::getWtots1Uncertainty(
3449  double cl_eta, double energy, PATCore::ParticleType::Type ptype) const {
3450  double value = 0;
3451 
3452  // Get slopes and wstot values
3453  // deltaE/E (Et, particle type ) = 2*A/mZ * ( wstot(Et,particle type)_data -
3454  // <wstot(40 GeV Et electrons)_data)> ) - 2*B/mZ* (wstot(Et,particle type)_MC
3455  // - <w wstot(40 GeV Et electrons)_MC>) factor 2 to go from slopes in dM/M to
3456  // dE/E
3457 
3458  //|eta|>2.4 => use last eta bin
3459  if (cl_eta < -2.4)
3460  cl_eta = -2.35;
3461  if (cl_eta > 2.4)
3462  cl_eta = 2.35;
3463 
3464  int bin = m_wstot_slope_A_data->FindFixBin(cl_eta);
3465  double A = m_wstot_slope_A_data->GetBinContent(bin);
3466  double B = m_wstot_slope_B_MC->GetBinContent(bin);
3467 
3468  // the wstot=f(pT) depends on the particle type
3469  double ETGeV = energy / cosh(cl_eta) / 1E3;
3470  double wstot_pT_data_p0 = 0.;
3471  double wstot_pT_data_p1 = 0.;
3472  double wstot_pT_MC_p0 = 0.;
3473  double wstot_pT_MC_p1 = 0.;
3474 
3475  double wstot_40_data =
3476  m_wstot_pT_data_p0_electrons->GetBinContent(bin) +
3477  (m_wstot_pT_data_p1_electrons->GetBinContent(bin)) / sqrt(40.);
3478  double wstot_40_MC =
3479  m_wstot_pT_MC_p0_electrons->GetBinContent(bin) +
3480  (m_wstot_pT_MC_p1_electrons->GetBinContent(bin)) / sqrt(40.);
3481 
3482  if (ptype == PATCore::ParticleType::Electron) {
3483  wstot_pT_data_p0 = m_wstot_pT_data_p0_electrons->GetBinContent(bin);
3484  wstot_pT_data_p1 = m_wstot_pT_data_p1_electrons->GetBinContent(bin);
3485  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_electrons->GetBinContent(bin);
3486  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_electrons->GetBinContent(bin);
3487  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3488  wstot_pT_data_p0 =
3489  m_wstot_pT_data_p0_unconverted_photons->GetBinContent(bin);
3490  wstot_pT_data_p1 =
3491  m_wstot_pT_data_p1_unconverted_photons->GetBinContent(bin);
3492  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_unconverted_photons->GetBinContent(bin);
3493  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_unconverted_photons->GetBinContent(bin);
3494  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3495  wstot_pT_data_p0 = m_wstot_pT_data_p0_converted_photons->GetBinContent(bin);
3496  wstot_pT_data_p1 = m_wstot_pT_data_p1_converted_photons->GetBinContent(bin);
3497  wstot_pT_MC_p0 = m_wstot_pT_MC_p0_converted_photons->GetBinContent(bin);
3498  wstot_pT_MC_p1 = m_wstot_pT_MC_p1_converted_photons->GetBinContent(bin);
3499  }
3500 
3501  double wstot_pT_data = 0.;
3502  double wstot_pT_MC = 0.;
3503 
3504  // Initial parametrization: [0]+1*pT
3505  // wstot_pT_data = wstot_pT_data_p0+wstot_pT_data_p1*ETGeV;
3506  // prevent wstot_pT_data from being negative
3507  // if(wstot_pT_data<0) wstot_pT_data = 0.;
3508 
3509  // New parametrization: p0+p1/sqrt(pT)
3510  // flat uncertainty below 25 GeV
3511  if (ETGeV < 25.)
3512  ETGeV = 25.;
3513 
3514  wstot_pT_data = wstot_pT_data_p0 + wstot_pT_data_p1 / sqrt(ETGeV);
3515  wstot_pT_MC = wstot_pT_MC_p0 + wstot_pT_MC_p1 / sqrt(ETGeV);
3516 
3517  value = 2 * A / 91.2 * (wstot_pT_data - wstot_40_data) -
3518  2 * B / 91.2 * (wstot_pT_MC - wstot_40_MC);
3519 
3520  return value;
3521 }
3522 
3523 // Layer scale uncertainties and induced non-linearity
3525 
3526 double egammaEnergyCorrectionTool::getLayerUncertainty(
3527  int iLayer, double cl_eta, egEnergyCorr::Scale::Variation var,
3528  double varSF) const {
3529 
3530  double value = 0.;
3531 
3532  if (var == egEnergyCorr::Scale::Nominal)
3533  return value;
3534 
3535  // nearest eta outside of crack (for PS scale values and uncertainties)
3536  double nearestEta = cl_eta;
3537  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
3538  nearestEta = nearestEtaBEC(cl_eta);
3539 
3540  if (iLayer == 0) { // use nearestEta
3541 
3542  if (var == egEnergyCorr::Scale::PSUp && m_aPSNom)
3543  value = m_aPSNom->GetBinError(m_aPSNom->FindFixBin(nearestEta));
3544 
3545  else if (var == egEnergyCorr::Scale::PSDown && m_aPSNom)
3546  value = -m_aPSNom->GetBinError(m_aPSNom->FindFixBin(nearestEta));
3547 
3548  else if (var == egEnergyCorr::Scale::PSb12Up && m_daPSb12)
3549  value = m_daPSb12->GetBinContent(m_daPSb12->FindFixBin(nearestEta));
3550 
3551  else if (var == egEnergyCorr::Scale::PSb12Down && m_daPSb12)
3552  value = -m_daPSb12->GetBinContent(m_daPSb12->FindFixBin(nearestEta));
3553 
3554  else if (var == egEnergyCorr::Scale::LArElecUnconvUp && m_daPSCor)
3555  value = m_daPSCor->GetBinContent(m_daPSCor->FindFixBin(nearestEta));
3556 
3557  else if (var == egEnergyCorr::Scale::LArElecUnconvDown && m_daPSCor)
3558  value = -m_daPSCor->GetBinContent(m_daPSCor->FindFixBin(nearestEta));
3559 
3560  }
3561 
3562  else if (iLayer == 1) { // use cl_eta
3563 
3564  if (var == egEnergyCorr::Scale::S12Up && m_aS12Nom) {
3565  value = m_aS12Nom->GetBinError(m_aS12Nom->FindFixBin(cl_eta));
3566  } else if (var == egEnergyCorr::Scale::S12Down && m_aS12Nom) {
3567  value = -m_aS12Nom->GetBinError(m_aS12Nom->FindFixBin(cl_eta));
3568  } else if (var == egEnergyCorr::Scale::LArCalibUp && m_daS12Cor) {
3569  value = m_daS12Cor->GetBinContent(m_daS12Cor->FindFixBin(cl_eta));
3570  } else if (var == egEnergyCorr::Scale::LArCalibDown && m_daS12Cor) {
3571  value = -m_daS12Cor->GetBinContent(m_daS12Cor->FindFixBin(cl_eta));
3572  } else if (var == egEnergyCorr::Scale::LArCalibExtra2015PreUp and
3573  (m_esmodel == egEnergyCorr::es2015PRE or
3574  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3575  m_esmodel == egEnergyCorr::es2015cPRE or
3576  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3577  m_esmodel == egEnergyCorr::es2015c_summer or
3578  m_esmodel == egEnergyCorr::es2016PRE or
3579  m_esmodel == egEnergyCorr::es2017 or
3580  m_esmodel == egEnergyCorr::es2017_summer or
3581  m_esmodel == egEnergyCorr::es2017_summer_improved or
3582  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3583  m_esmodel == egEnergyCorr::es2015_5TeV)) {
3584  // special case for es2015PRE and also for es2015c_summer and also for
3585  // es2017 numbers from Lydia and Christophe,
3586  // https://indico.cern.ch/event/395345/contribution/2/material/slides/0.pdf
3587  // assuming constant uncertainty
3588  // es2017_summer: increased to 5% in the endcap
3589  const double aeta = std::abs(cl_eta);
3590  // endcap
3591  if (aeta >= 1.37 and aeta < 2.5) {
3592  if (m_esmodel == egEnergyCorr::es2017_summer or
3593  m_esmodel == egEnergyCorr::es2017_summer_improved or
3594  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3595  m_esmodel == egEnergyCorr::es2015_5TeV)
3596  value = 5.0E-2;
3597  else
3598  value = 1.5E-2;
3599  } else { // barrel
3600  if (m_esmodel == egEnergyCorr::es2017_summer_improved)
3601  value = 2.5E-2;
3602  else
3603  value = 1.5E-2;
3604  }
3605  } else if (var == egEnergyCorr::Scale::LArCalibExtra2015PreDown and
3606  (m_esmodel == egEnergyCorr::es2015PRE or
3607  m_esmodel == egEnergyCorr::es2015PRE_res_improved or
3608  m_esmodel == egEnergyCorr::es2015cPRE or
3609  m_esmodel == egEnergyCorr::es2015cPRE_res_improved or
3610  m_esmodel == egEnergyCorr::es2015c_summer or
3611  m_esmodel == egEnergyCorr::es2016PRE or
3612  m_esmodel == egEnergyCorr::es2017 or
3613  m_esmodel == egEnergyCorr::es2017_summer or
3614  m_esmodel == egEnergyCorr::es2017_summer_improved or
3615  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3616  m_esmodel == egEnergyCorr::es2015_5TeV)) {
3617  const double aeta = std::abs(cl_eta);
3618  // endcap
3619  if (aeta >= 1.37 and aeta < 2.5) {
3620  if (m_esmodel == egEnergyCorr::es2017_summer or
3621  m_esmodel == egEnergyCorr::es2017_summer_improved or
3622  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3623  m_esmodel == egEnergyCorr::es2015_5TeV)
3624  value = -5.0E-2;
3625  else
3626  value = -1.5E-2;
3627  } else { // barrel
3628  if (m_esmodel == egEnergyCorr::es2017_summer_improved or
3629  m_esmodel == egEnergyCorr::es2015_5TeV)
3630  value = -2.5E-2;
3631  else
3632  value = -1.5E-2;
3633  }
3634  }
3635 
3636  else if (var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up or
3637  var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down) {
3638  // special large sys for run2 in the last eta-bin in es2017, see
3639  // ATLASEG-42
3640  if (m_esmodel == egEnergyCorr::es2017 or
3641  m_esmodel == egEnergyCorr::es2017_summer or
3642  m_esmodel == egEnergyCorr::es2017_summer_improved or
3643  m_esmodel == egEnergyCorr::es2017_R21_PRE or
3644  m_esmodel == egEnergyCorr::es2015_5TeV) {
3645  const double aeta = std::abs(cl_eta);
3646  if (aeta >= 2.4 and aeta < 2.5) {
3647  if (var == egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up)
3648  value = 25E-2;
3649  else
3650  value = -25E-2;
3651  }
3652  }
3653  }
3654  }
3655 
3656  return value * varSF;
3657 }
3658 
3659 double egammaEnergyCorrectionTool::getE4NonLinearity(
3660  double cl_eta, double energy, PATCore::ParticleType::Type ptype) const {
3661  double value = 0;
3662  const double aeta = std::abs(cl_eta);
3663  const double ETGeV = energy / cosh(cl_eta) / 1E3;
3664 
3665  // This will point to the return of get() of a unique_ptr
3666  const TAxis* axis;
3667  const TList* graphs;
3668 
3669  if (ptype == PATCore::ParticleType::Electron) {
3670  axis = m_E4ElectronEtaBins.get();
3671  graphs = m_E4ElectronGraphs.get();
3672  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3673  axis = m_E4UnconvertedEtaBins.get();
3674  graphs = m_E4UnconvertedGraphs.get();
3675  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3676  axis = m_E4ConvertedEtaBins.get();
3677  graphs = m_E4ConvertedGraphs.get();
3678  } else {
3679  ATH_MSG_FATAL("invalid particle type");
3680  return -1;
3681  }
3682 
3683  const int ieta = axis->FindFixBin(aeta) - 1;
3684  if (ieta >= 0 and ieta < graphs->GetSize()) {
3685  value = static_cast<TGraph*>(graphs->At(ieta))->Eval(ETGeV);
3686  }
3687 
3688  return value;
3689 }
3690 
3691 double egammaEnergyCorrectionTool::getLayerNonLinearity(
3692  int iLayer, double cl_eta, double energy,
3693  PATCore::ParticleType::Type ptype) const {
3694 
3695  double value = 0;
3696  // Accordion histogram specicif condition
3697  if (iLayer == 6 && std::abs(cl_eta) >= 2.47)
3698  cl_eta = 2.46;
3699  double aeta = std::abs(cl_eta);
3700  double ET = energy / cosh(cl_eta);
3701 
3702  // move out of crack
3703  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
3704  aeta = nearestEtaBEC(aeta);
3705 
3706  // argument ET is transverse energy in MeV
3707 
3708  if (iLayer == 0 && aeta >= 1.82)
3709  return value;
3710 
3711  if (ptype == PATCore::ParticleType::Electron) {
3712 
3713  if (iLayer == 0) {
3714 
3715  const int ieta = m_psElectronEtaBins->FindFixBin(aeta) - 1;
3716  if (ieta >= 0 and ieta < m_psElectronGraphs->GetSize()) {
3717  value = ((TF1*)m_psElectronGraphs->At(ieta))->Eval(ET);
3718  }
3719  } else if (iLayer == 1) {
3720 
3721  const int ieta = m_s12ElectronEtaBins->FindFixBin(aeta) - 1;
3722  if (ieta >= 0 and ieta < m_s12ElectronGraphs->GetSize()) {
3723  value = ((TF1*)m_s12ElectronGraphs->At(ieta))->Eval(ET);
3724  }
3725  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3726 
3727  const int ieta = m_EaccElectronEtaBins->FindFixBin(aeta) - 1;
3728  if (ieta >= 0 && ieta < m_EaccElectronGraphs->GetSize()) {
3729  value = ((TF1*)m_EaccElectronGraphs->At(ieta))->Eval(ET);
3730  }
3731  }
3732 
3733  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3734 
3735  if (iLayer == 0) {
3736 
3737  const int ieta = m_psUnconvertedEtaBins->FindFixBin(aeta) - 1;
3738  if (ieta >= 0 and ieta < m_psUnconvertedGraphs->GetSize()) {
3739  value = ((TF1*)m_psUnconvertedGraphs->At(ieta))->Eval(ET);
3740  }
3741 
3742  } else if (iLayer == 1) {
3743 
3744  const int ieta = m_s12UnconvertedEtaBins->FindFixBin(aeta) - 1;
3745  if (ieta >= 0 and ieta < m_s12UnconvertedGraphs->GetSize()) {
3746  value = ((TF1*)m_s12UnconvertedGraphs->At(ieta))->Eval(ET);
3747  }
3748  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3749 
3750  const int ieta = m_EaccUnconvertedEtaBins->FindFixBin(aeta) - 1;
3751  if (ieta >= 0 && ieta < m_EaccUnconvertedGraphs->GetSize()) {
3752  value = ((TF1*)m_EaccUnconvertedGraphs->At(ieta))->Eval(ET);
3753  }
3754  }
3755 
3756  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3757 
3758  if (iLayer == 0) {
3759 
3760  const int ieta = m_psConvertedEtaBins->FindFixBin(aeta) - 1;
3761  if (ieta >= 0 and ieta < m_psConvertedGraphs->GetSize()) {
3762  value = ((TF1*)m_psConvertedGraphs->At(ieta))->Eval(ET);
3763  }
3764 
3765  } else if (iLayer == 1) {
3766 
3767  const int ieta = m_s12ConvertedEtaBins->FindFixBin(aeta) - 1;
3768  if (ieta >= 0 and ieta < m_s12ConvertedGraphs->GetSize()) {
3769  value = ((TF1*)m_s12ConvertedGraphs->At(ieta))->Eval(ET);
3770  }
3771  } else if (iLayer == 6) { // Accordion correction (for Precision Run-2)
3772 
3773  const int ieta = m_EaccConvertedEtaBins->FindFixBin(aeta) - 1;
3774  if (ieta >= 0 && ieta < m_EaccConvertedGraphs->GetSize()) {
3775  if (ET < 10000. && (aeta < 1.2 || (aeta >= 1.59 && aeta < 1.73))) {
3776  // harcoded condition to correct bad beahviour of function at low ET
3777  // <10GeV
3778  value = ((TF1*)m_EaccConvertedGraphs->At(ieta))->Eval(10000.);
3779  } else {
3780  value = ((TF1*)m_EaccConvertedGraphs->At(ieta))->Eval(ET);
3781  }
3782  }
3783  }
3784  }
3785 
3786  ATH_MSG_DEBUG("Layer non-linearity: " << iLayer << " value: " << value);
3787 
3788  if (value < 0) {
3789  ATH_MSG_DEBUG("Value is negative -> set to 0");
3790  value = 0;
3791  }
3792 
3793  return value;
3794 }
3795 
3796 // passive material correction
3798 
3799 // ... material look-up function, called internally by getAlphaMaterial() and
3800 // getMaterialNonLinearity()
3801 
3802 double egammaEnergyCorrectionTool::getDeltaX(
3803  double cl_eta, egEnergyCorr::MaterialCategory imat,
3804  egEnergyCorr::Scale::Variation var) const {
3805 
3806  double value = 0.;
3807  double aeta = std::abs(cl_eta);
3808 
3809  // "ID" : inner detector material; bottom-up (from construction/simulation
3810  // accuracy : ConfigA)
3811 
3812  if (imat == egEnergyCorr::MatID && m_dX_ID_Nom) {
3813 
3814  // ... NOTE : watch out here : this histo does not follow the usual
3815  // value/error look-up convention
3816 
3817  if (var == egEnergyCorr::Scale::MatIDUp)
3818  value += m_dX_ID_Nom->GetBinContent(m_dX_ID_Nom->FindFixBin(aeta));
3819  else if (var == egEnergyCorr::Scale::MatIDDown)
3820  value -= m_dX_ID_Nom->GetBinContent(m_dX_ID_Nom->FindFixBin(aeta));
3821 
3822  // "Cryo" : integral from IP to PS or Acc, depending on eta
3823 
3824  } else if (imat == egEnergyCorr::MatCryo && aeta < 1.82 &&
3825  m_dX_IPPS_Nom) { // Integral between IP and PS
3826 
3827  value = m_dX_IPPS_Nom->GetBinContent(m_dX_IPPS_Nom->FindFixBin(aeta));
3828 
3829  if (var == egEnergyCorr::Scale::MatCryoUp)
3830  value += m_dX_IPPS_Nom->GetBinError(m_dX_IPPS_Nom->FindFixBin(aeta));
3831  else if (var == egEnergyCorr::Scale::MatCryoDown)
3832  value -= m_dX_IPPS_Nom->GetBinError(m_dX_IPPS_Nom->FindFixBin(aeta));
3833 
3834  // ... careful : sign below should be opposite to the effect of this source
3835  // on the PS scale!
3836  if (var == egEnergyCorr::Scale::LArElecUnconvUp && m_dX_IPPS_LAr)
3837  value -= m_dX_IPPS_LAr->GetBinContent(m_dX_IPPS_LAr->FindFixBin(aeta));
3838  else if (var == egEnergyCorr::Scale::LArElecUnconvDown && m_dX_IPPS_LAr)
3839  value += m_dX_IPPS_LAr->GetBinContent(m_dX_IPPS_LAr->FindFixBin(aeta));
3840 
3841  } else if (imat == egEnergyCorr::MatCryo && aeta > 1.82 &&
3842  m_dX_IPAcc_Nom) { // Integral between IP and Accordion
3843 
3844  value = m_dX_IPAcc_Nom->GetBinContent(m_dX_IPAcc_Nom->FindFixBin(aeta));
3845 
3846  if (var == egEnergyCorr::Scale::MatCryoUp)
3847  value += m_dX_IPAcc_Nom->GetBinError(m_dX_IPAcc_Nom->FindFixBin(aeta));
3848  else if (var == egEnergyCorr::Scale::MatCryoDown)
3849  value -= m_dX_IPAcc_Nom->GetBinError(m_dX_IPAcc_Nom->FindFixBin(aeta));
3850 
3851  if (var == egEnergyCorr::Scale::LArElecCalibUp && m_dX_IPAcc_LAr)
3852  value += m_dX_IPAcc_LAr->GetBinContent(m_dX_IPAcc_LAr->FindFixBin(aeta));
3853  else if (var == egEnergyCorr::Scale::LArElecCalibDown && m_dX_IPAcc_LAr)
3854  value -= m_dX_IPAcc_LAr->GetBinContent(m_dX_IPAcc_LAr->FindFixBin(aeta));
3855 
3856  if (var == egEnergyCorr::Scale::G4Up && m_dX_IPAcc_G4)
3857  value += m_dX_IPAcc_G4->GetBinContent(m_dX_IPAcc_G4->FindFixBin(aeta));
3858  else if (var == egEnergyCorr::Scale::G4Down && m_dX_IPAcc_G4)
3859  value -= m_dX_IPAcc_G4->GetBinContent(m_dX_IPAcc_G4->FindFixBin(aeta));
3860 
3861  if (var == egEnergyCorr::Scale::L1GainUp && m_dX_IPAcc_GL1)
3862  value += m_dX_IPAcc_GL1->GetBinContent(m_dX_IPAcc_GL1->FindFixBin(aeta));
3863  else if (var == egEnergyCorr::Scale::L1GainDown && m_dX_IPAcc_GL1)
3864  value -= m_dX_IPAcc_GL1->GetBinContent(m_dX_IPAcc_GL1->FindFixBin(aeta));
3865 
3866  // "Calo" : between PS and Strips
3867 
3868  } else if (imat == egEnergyCorr::MatCalo && aeta < 1.82 && m_dX_PSAcc_Nom) {
3869 
3870  value = m_dX_PSAcc_Nom->GetBinContent(m_dX_PSAcc_Nom->FindFixBin(aeta));
3871 
3872  if (var == egEnergyCorr::Scale::MatCaloUp)
3873  value += m_dX_PSAcc_Nom->GetBinError(m_dX_PSAcc_Nom->FindFixBin(aeta));
3874  else if (var == egEnergyCorr::Scale::MatCaloDown)
3875  value -= m_dX_PSAcc_Nom->GetBinError(m_dX_PSAcc_Nom->FindFixBin(aeta));
3876 
3877  if (var == egEnergyCorr::Scale::LArUnconvCalibUp && m_dX_PSAcc_LAr)
3878  value += m_dX_PSAcc_LAr->GetBinContent(m_dX_PSAcc_LAr->FindFixBin(aeta));
3879  else if (var == egEnergyCorr::Scale::LArUnconvCalibDown && m_dX_PSAcc_LAr)
3880  value -= m_dX_PSAcc_LAr->GetBinContent(m_dX_PSAcc_LAr->FindFixBin(aeta));
3881 
3882  if (var == egEnergyCorr::Scale::G4Up && m_dX_PSAcc_G4)
3883  value += m_dX_PSAcc_G4->GetBinContent(m_dX_PSAcc_G4->FindFixBin(aeta));
3884  else if (var == egEnergyCorr::Scale::G4Down && m_dX_PSAcc_G4)
3885  value -= m_dX_PSAcc_G4->GetBinContent(m_dX_PSAcc_G4->FindFixBin(aeta));
3886  }
3887 
3888  return value;
3889 }
3890 
3891 // returns the impact of material variation on response.
3892 // non-zero for photons only (the average effect is absorbed by the effective Z
3893 // scales for electrons).
3894 
3895 // Strategy for material before the PS :
3896 // - consider ID material and uncertainty fixed to ConfigA
3897 // - attribute measured material to ConfigL, with uncertainty from difference
3898 // between measurement and ConfigA
3899 // I.e : DX_A = 0 +- dA ; DX_L = DX_Meas +- (dMeas ++ dA)
3900 
3901 // Strategy for material after the PS :
3902 // - direct measurement
3903 // I.e : DX_M = DX_Meas +- dMeas
3904 
3905 // Then calculate the impact on the scale accordingly.
3906 
3907 double egammaEnergyCorrectionTool::getAlphaMaterial(
3908  double cl_eta, egEnergyCorr::MaterialCategory imat,
3909  PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var,
3910  double varSF) const {
3911 
3912  double value = 0.;
3913  if (ptype == PATCore::ParticleType::Electron)
3914  return value;
3915  if (var == egEnergyCorr::Scale::Nominal)
3916  return value;
3917 
3918  egEnergyCorr::Geometry geoID, geoCryo, geoCalo, geoGp;
3919  geoID = egEnergyCorr::ConfigA;
3920  if (std::abs(cl_eta) < 2.)
3921  geoCryo = egEnergyCorr::ConfigEL;
3922  else
3923  geoCryo = egEnergyCorr::ConfigFMX;
3924  geoCalo = egEnergyCorr::ConfigFMX;
3925  geoGp = egEnergyCorr::ConfigGp;
3926 
3927  // look up material bias
3928 
3929  double DeltaX = getDeltaX(cl_eta, imat, var) -
3930  getDeltaX(cl_eta, imat, egEnergyCorr::Scale::Nominal);
3931 
3932  // calculate scale change per unit added material
3933 
3934  double DAlphaDXID, DAlphaDXCryo, DAlphaDXCalo, DAlphaDXGp;
3935  DAlphaDXID = DAlphaDXCryo = DAlphaDXCalo = DAlphaDXGp = 0;
3936  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
3937  DAlphaDXGp = m_matUnconvertedScale[geoGp]->GetBinContent(
3938  m_matUnconvertedScale[geoGp]->FindBin(cl_eta));
3939  DAlphaDXID = m_matUnconvertedScale[geoID]->GetBinContent(
3940  m_matUnconvertedScale[geoID]->FindBin(cl_eta));
3941  DAlphaDXCryo = m_matUnconvertedScale[geoCryo]->GetBinContent(
3942  m_matUnconvertedScale[geoCryo]->FindBin(cl_eta));
3943  DAlphaDXCalo = m_matUnconvertedScale[geoCalo]->GetBinContent(
3944  m_matUnconvertedScale[geoCalo]->FindBin(cl_eta));
3945  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
3946  DAlphaDXGp = m_matConvertedScale[geoGp]->GetBinContent(
3947  m_matConvertedScale[geoGp]->FindBin(cl_eta));
3948  DAlphaDXID = m_matConvertedScale[geoID]->GetBinContent(
3949  m_matConvertedScale[geoID]->FindBin(cl_eta));
3950  DAlphaDXCryo = m_matConvertedScale[geoCryo]->GetBinContent(
3951  m_matConvertedScale[geoCryo]->FindBin(cl_eta));
3952  DAlphaDXCalo = m_matConvertedScale[geoCalo]->GetBinContent(
3953  m_matConvertedScale[geoCalo]->FindBin(cl_eta));
3954  }
3955 
3956  // when in crack, use G', exit
3957 
3958  if (isInCrack(cl_eta)) {
3959  if (imat == egEnergyCorr::MatID && var == egEnergyCorr::Scale::MatIDUp)
3960  value = DAlphaDXGp;
3961  else if (imat == egEnergyCorr::MatID &&
3962  var == egEnergyCorr::Scale::MatIDDown)
3963  value = -DAlphaDXGp;
3964  return value;
3965  }
3966 
3967  // normal case
3968 
3969  int idx = m_matX0Additions[geoID]->FindBin(std::abs(cl_eta));
3970  if (idx < 1 || idx > m_matX0Additions[geoID]->GetNbinsX())
3971  DAlphaDXID = 0;
3972  else
3973  DAlphaDXID /= m_matX0Additions[geoID]->GetBinContent(idx);
3974 
3975  idx = m_matX0Additions[geoCryo]->FindBin(std::abs(cl_eta));
3976  if (idx < 1 || idx > m_matX0Additions[geoCryo]->GetNbinsX())
3977  DAlphaDXCryo = 0;
3978  else
3979  DAlphaDXCryo /= m_matX0Additions[geoCryo]->GetBinContent(idx);
3980 
3981  idx = m_matX0Additions[geoCalo]->FindBin(std::abs(cl_eta));
3982  if (idx < 1 || idx > m_matX0Additions[geoCalo]->GetNbinsX())
3983  DAlphaDXCalo = 0;
3984  else
3985  DAlphaDXCalo /= m_matX0Additions[geoCalo]->GetBinContent(idx);
3986 
3987  // final value
3988 
3989  if (imat == egEnergyCorr::MatID)
3990  value = DeltaX * (DAlphaDXID - DAlphaDXCryo);
3991  else if (imat == egEnergyCorr::MatCryo)
3992  value = DeltaX * DAlphaDXCryo;
3993  else if (imat == egEnergyCorr::MatCalo)
3994  value = DeltaX * DAlphaDXCalo;
3995 
3996  return value * varSF;
3997 }
3998 
3999 double egammaEnergyCorrectionTool::getMaterialEffect(
4000  egEnergyCorr::Geometry geo, PATCore::ParticleType::Type ptype,
4001  double cl_eta, double ET) const {
4002 
4003  // Again this does no need to be ptr just get the one owned
4004  TH2D* hmat;
4005 
4006  if (ptype == PATCore::ParticleType::Electron) {
4007  if (geo == egEnergyCorr::ConfigA)
4008  hmat = ((TH2D*)m_electronBias_ConfigA.get());
4009  else if (geo == egEnergyCorr::ConfigEL)
4010  hmat = ((TH2D*)m_electronBias_ConfigEpLp.get());
4011  else if (geo == egEnergyCorr::ConfigFMX)
4012  hmat = ((TH2D*)m_electronBias_ConfigFpMX.get());
4013  else if (geo == egEnergyCorr::ConfigN)
4014  hmat = ((TH2D*)m_electronBias_ConfigN.get());
4015  else if (geo == egEnergyCorr::ConfigIBL)
4016  hmat = ((TH2D*)m_electronBias_ConfigIBL.get());
4017  else if (geo == egEnergyCorr::ConfigPP0)
4018  hmat = ((TH2D*)m_electronBias_ConfigPP0.get());
4019  else
4020  return 0;
4021  } else if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4022  if (geo == egEnergyCorr::ConfigA)
4023  hmat = ((TH2D*)m_unconvertedBias_ConfigA.get());
4024  else if (geo == egEnergyCorr::ConfigEL)
4025  hmat = ((TH2D*)m_unconvertedBias_ConfigEpLp.get());
4026  else if (geo == egEnergyCorr::ConfigFMX)
4027  hmat = ((TH2D*)m_unconvertedBias_ConfigFpMX.get());
4028  else if (geo == egEnergyCorr::ConfigN)
4029  hmat = ((TH2D*)m_unconvertedBias_ConfigN.get());
4030  else if (geo == egEnergyCorr::ConfigIBL)
4031  hmat = ((TH2D*)m_unconvertedBias_ConfigIBL.get());
4032  else if (geo == egEnergyCorr::ConfigPP0)
4033  hmat = ((TH2D*)m_unconvertedBias_ConfigIBL.get());
4034  else
4035  return 0;
4036  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4037  if (geo == egEnergyCorr::ConfigA)
4038  hmat = ((TH2D*)m_convertedBias_ConfigA.get());
4039  else if (geo == egEnergyCorr::ConfigEL)
4040  hmat = ((TH2D*)m_convertedBias_ConfigEpLp.get());
4041  else if (geo == egEnergyCorr::ConfigFMX)
4042  hmat = ((TH2D*)m_convertedBias_ConfigFpMX.get());
4043  else if (geo == egEnergyCorr::ConfigN)
4044  hmat = ((TH2D*)m_convertedBias_ConfigN.get());
4045  else if (geo == egEnergyCorr::ConfigIBL)
4046  hmat = ((TH2D*)m_convertedBias_ConfigIBL.get());
4047  else if (geo == egEnergyCorr::ConfigPP0)
4048  hmat = ((TH2D*)m_convertedBias_ConfigPP0.get());
4049  else
4050  return 0;
4051  } else
4052  return 0;
4053 
4054  // use one bin in eta and linear interpolation in Et between 2 bins
4055 
4056  double aeta = std::abs(cl_eta);
4057  int ieta = hmat->GetXaxis()->FindBin(aeta);
4058 
4059  int ipt = hmat->GetYaxis()->FindBin(ET);
4060  double ptBin = hmat->GetYaxis()->GetBinCenter(ipt);
4061 
4062  int i1, i2;
4063  double pt1, pt2;
4064  if (ET > ptBin) {
4065  i1 = ipt;
4066  i2 = ipt + 1;
4067  pt1 = ptBin;
4068  pt2 = hmat->GetYaxis()->GetBinCenter(i2);
4069  } else {
4070  i1 = ipt - 1;
4071  i2 = ipt;
4072  pt1 = hmat->GetYaxis()->GetBinCenter(i1);
4073  pt2 = ptBin;
4074  }
4075 
4076  int nbins = hmat->GetYaxis()->GetNbins();
4077  double value = 0;
4078  if (i1 >= 1 && i1 < nbins) {
4079  double v1 = hmat->GetBinContent(ieta, i1);
4080  double v2 = hmat->GetBinContent(ieta, i2);
4081  value = (v1 * (pt2 - ET) + v2 * (ET - pt1)) / (pt2 - pt1);
4082  } else {
4083  if (ipt < 1)
4084  ipt = 1;
4085  if (ipt > nbins)
4086  ipt = nbins;
4087  value = hmat->GetBinContent(ieta, ipt);
4088  }
4089  return value;
4090 }
4091 
4092 // returns the energy dependence of the above (non-zero for electrons only).
4093 
4094 double egammaEnergyCorrectionTool::getMaterialNonLinearity(
4095  double cl_eta, double energy, egEnergyCorr::MaterialCategory imat,
4096  PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var,
4097  double varSF) const {
4098 
4099  double value = 0;
4100  double ET = energy / cosh(cl_eta) / GeV;
4101 
4102  if ((ptype != PATCore::ParticleType::Electron &&
4103  (m_esmodel != egEnergyCorr::es2017_R21_v1 &&
4104  m_esmodel != egEnergyCorr::es2017_R21_ofc0_v1 &&
4105  m_esmodel != egEnergyCorr::es2018_R21_v0 &&
4106  m_esmodel != egEnergyCorr::es2018_R21_v1 &&
4107  m_esmodel != egEnergyCorr::es2022_R22_PRE &&
4108  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)) ||
4109  var == egEnergyCorr::Scale::Nominal)
4110  return value;
4111 
4112  egEnergyCorr::Geometry geoID, geoCryo, geoCalo, geoGp;
4113  geoID = egEnergyCorr::ConfigA;
4114  if (std::abs(cl_eta) < 2.)
4115  geoCryo = egEnergyCorr::ConfigEL;
4116  else
4117  geoCryo = egEnergyCorr::ConfigFMX;
4118 
4119  // G.Unal 21.08.2018
4120  // for Calo material use correctly ConfigN material for endcap (PS to Calo) in
4121  // release 21 (not done for run 1, which used FMX in this case)
4122  if (std::abs(cl_eta) > 1.52 &&
4123  (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4124  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4125  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4126  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4127  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4128  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0))
4129  geoCalo = egEnergyCorr::ConfigN;
4130  else
4131  geoCalo = egEnergyCorr::ConfigFMX;
4132  geoGp = egEnergyCorr::ConfigGp;
4133 
4134  // look up material bias
4135 
4136  double DeltaX = getDeltaX(cl_eta, imat, var) -
4137  getDeltaX(cl_eta, imat, egEnergyCorr::Scale::Nominal);
4138 
4139  // calculate scale change per unit added material
4140 
4141  // G.Unal 21.08.2019 new code called for release 21 sensivitities
4142 
4143  double DAlphaDXGp, DAlphaDXID, DAlphaDXCryo, DAlphaDXCalo;
4144 
4145  if (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4146  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4147  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4148  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4149  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4150  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4151  DAlphaDXGp =
4152  getMaterialEffect(egEnergyCorr::ConfigFMX, ptype, cl_eta,
4153  ET); // no G' in release 21, use FMX for the crack
4154  DAlphaDXID = getMaterialEffect(geoID, ptype, cl_eta, ET);
4155  DAlphaDXCryo = getMaterialEffect(geoCryo, ptype, cl_eta, ET);
4156  DAlphaDXCalo = getMaterialEffect(geoCalo, ptype, cl_eta, ET);
4157 
4158  } else {
4159  int ialpha = m_matElectronEtaBins->FindFixBin(std::abs(cl_eta)) - 1;
4160  if (ialpha < 0 || ialpha >= m_matElectronGraphs[geoGp]->GetSize())
4161  return 0.;
4162 
4163  DAlphaDXGp = ((TGraphErrors*)m_matElectronGraphs[geoGp]->At(ialpha))
4164  ->GetFunction("fNonLin")
4165  ->Eval(ET);
4166  DAlphaDXID = ((TGraphErrors*)m_matElectronGraphs[geoID]->At(ialpha))
4167  ->GetFunction("fNonLin")
4168  ->Eval(ET);
4169  DAlphaDXCryo = ((TGraphErrors*)m_matElectronGraphs[geoCryo]->At(ialpha))
4170  ->GetFunction("fNonLin")
4171  ->Eval(ET);
4172  DAlphaDXCalo = ((TGraphErrors*)m_matElectronGraphs[geoCalo]->At(ialpha))
4173  ->GetFunction("fNonLin")
4174  ->Eval(ET);
4175  }
4176 
4177  // when in crack, use G', exit
4178 
4179  if (isInCrack(cl_eta)) {
4180  if (imat == egEnergyCorr::MatID && var == egEnergyCorr::Scale::MatIDUp)
4181  value = DAlphaDXGp;
4182  else if (imat == egEnergyCorr::MatID &&
4183  var == egEnergyCorr::Scale::MatIDDown)
4184  value = -DAlphaDXGp;
4185  return value;
4186  }
4187 
4188  int idx = m_matX0Additions[geoID]->FindBin(std::abs(cl_eta));
4189  if (idx < 1 || idx > m_matX0Additions[geoID]->GetNbinsX())
4190  DAlphaDXID = 0;
4191  else {
4192  if (m_matX0Additions[geoID]->GetBinContent(idx) > 0.)
4193  DAlphaDXID /= m_matX0Additions[geoID]->GetBinContent(idx);
4194  else
4195  DAlphaDXID = 0.;
4196  }
4197 
4198  idx = m_matX0Additions[geoCryo]->FindBin(std::abs(cl_eta));
4199  if (idx < 1 || idx > m_matX0Additions[geoCryo]->GetNbinsX())
4200  DAlphaDXCryo = 0;
4201  else {
4202  if (m_matX0Additions[geoCryo]->GetBinContent(idx) > 0.)
4203  DAlphaDXCryo /= m_matX0Additions[geoCryo]->GetBinContent(idx);
4204  else
4205  DAlphaDXCryo = 0.;
4206  }
4207 
4208  idx = m_matX0Additions[geoCalo]->FindBin(std::abs(cl_eta));
4209  if (idx < 1 || idx > m_matX0Additions[geoCalo]->GetNbinsX())
4210  DAlphaDXCalo = 0;
4211  else {
4212  if (m_matX0Additions[geoCalo]->GetBinContent(idx) > 0.)
4213  DAlphaDXCalo /= m_matX0Additions[geoCalo]->GetBinContent(idx);
4214  else
4215  DAlphaDXCalo = 0.;
4216  }
4217 
4218  // final value
4219 
4220  if (imat == egEnergyCorr::MatID)
4221  value = DeltaX * (DAlphaDXID - DAlphaDXCryo);
4222  else if (imat == egEnergyCorr::MatCryo)
4223  value = DeltaX * DAlphaDXCryo;
4224  else if (imat == egEnergyCorr::MatCalo)
4225  value = DeltaX * DAlphaDXCalo;
4226 
4227  return value * varSF;
4228 }
4229 
4230 double egammaEnergyCorrectionTool::getAlphaLeakage(
4231  double cl_eta, PATCore::ParticleType::Type ptype,
4232  egEnergyCorr::Scale::Variation var, double varSF) const {
4233 
4234  double alpha = 0.;
4235  double aeta = std::abs(cl_eta);
4236 
4237  if (var == egEnergyCorr::Scale::Nominal ||
4238  ptype == PATCore::ParticleType::Electron)
4239  return alpha;
4240 
4241  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4242 
4243  if (var == egEnergyCorr::Scale::LeakageUnconvUp) {
4244  alpha = m_leakageUnconverted->GetBinContent(
4245  m_leakageUnconverted->FindFixBin(aeta));
4246  } else if (var == egEnergyCorr::Scale::LeakageUnconvDown) {
4247  alpha = -m_leakageUnconverted->GetBinContent(
4248  m_leakageUnconverted->FindFixBin(aeta));
4249  }
4250 
4251  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4252 
4253  if (var == egEnergyCorr::Scale::LeakageConvUp) {
4254  alpha = m_leakageConverted->GetBinContent(
4255  m_leakageConverted->FindFixBin(aeta));
4256  } else if (var == egEnergyCorr::Scale::LeakageConvDown) {
4257  alpha = -m_leakageConverted->GetBinContent(
4258  m_leakageConverted->FindFixBin(aeta));
4259  }
4260  }
4261 
4262  return alpha * varSF;
4263 }
4264 
4265 double egammaEnergyCorrectionTool::getAlphaLeakage2D(
4266  double cl_eta, double et, PATCore::ParticleType::Type ptype,
4267  egEnergyCorr::Scale::Variation var, double varSF) const {
4268 
4269  // To be on the safe side
4270  if (m_esmodel != egEnergyCorr::es2023_R22_Run2_v0) {
4271  return getAlphaLeakage(cl_eta, ptype, var, varSF);
4272  }
4273 
4274  // No correction for electron
4275  if (ptype == PATCore::ParticleType::Electron &&
4276  var != egEnergyCorr::Scale::LeakageElecDown &&
4277  var != egEnergyCorr::Scale::LeakageElecUp)
4278  return 0.;
4279 
4280  // Outside acceptance. Should never happen
4281  double aeta = std::abs(cl_eta);
4282  if (aeta > 2.47) {
4283  ATH_MSG_WARNING("Very high |eta| object, eta = " << cl_eta);
4284  return 0.;
4285  }
4286 
4287  // If no correction applied, can only be the egEnergyCorr::Scale::LeakageXXX
4288  // syst
4289  if (!m_useLeakageCorrection && var != egEnergyCorr::Scale::LeakageConvDown &&
4290  var != egEnergyCorr::Scale::LeakageConvUp &&
4291  var != egEnergyCorr::Scale::LeakageUnconvDown &&
4292  var != egEnergyCorr::Scale::LeakageUnconvUp &&
4293  var != egEnergyCorr::Scale::LeakageElecDown &&
4294  var != egEnergyCorr::Scale::LeakageElecUp)
4295  return 0.;
4296 
4297  double etGeV = et / GeV;
4298  double alpha = 0, dalpha = 0;
4299  if (var == egEnergyCorr::Scale::LeakageElecDown ||
4300  var == egEnergyCorr::Scale::LeakageElecUp) {
4301  dalpha = getAlphaUncAlpha(*m_leakageElectron, aeta, etGeV,
4302  m_usepTInterpolationForLeakage)
4303  .first;
4304  if (var == egEnergyCorr::Scale::LeakageElecDown)
4305  dalpha *= -1;
4306  if (ptype == PATCore::ParticleType::Electron)
4307  return dalpha;
4308  }
4309 
4310  bool isConv = ptype == PATCore::ParticleType::ConvertedPhoton;
4311  TH1* hh = isConv ? m_leakageConverted.get() : m_leakageUnconverted.get();
4312  std::pair<double, double> p =
4313  getAlphaUncAlpha(*hh, aeta, etGeV, m_usepTInterpolationForLeakage);
4314 
4315  if (m_useLeakageCorrection) {
4316  alpha = p.first;
4317  }
4318  if ((isConv && (var == egEnergyCorr::Scale::LeakageConvDown ||
4319  var == egEnergyCorr::Scale::LeakageConvUp)) ||
4320  (!isConv && (var == egEnergyCorr::Scale::LeakageUnconvDown ||
4321  var == egEnergyCorr::Scale::LeakageUnconvUp))) {
4322  // If we correct, use uncertainty. Else use full size of the effect
4323  // for es2023_R22_Run2_v0, use full size of correction as uncertainty
4324  if (m_useLeakageCorrection && m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4325  dalpha = p.second;
4326  else
4327  dalpha = alpha;
4328 
4329  if (var == egEnergyCorr::Scale::LeakageConvDown ||
4330  var == egEnergyCorr::Scale::LeakageUnconvDown)
4331  dalpha *= -1;
4332  }
4333  alpha += dalpha;
4334 
4335  ATH_MSG_VERBOSE(
4336  "In leakage2D alpha = " << alpha << " from var = " << variationName(var));
4337 
4338  return alpha * varSF;
4339 }
4340 
4341 std::pair<double, double> egammaEnergyCorrectionTool::getAlphaUncAlpha(
4342  const TH1& hh, double aeta, double et, bool useInterp) const {
4343 
4344  // stay within the histogram limits in pT
4345  // no warning to say the pT is not in the "validity" range...
4346  int ibeta = hh.GetXaxis()->FindBin(aeta);
4347  int nbpT = hh.GetYaxis()->GetNbins();
4348  int ibpT = hh.GetYaxis()->FindBin(et);
4349  bool isOUFlow = false;
4350  if (ibpT > nbpT) {
4351  ibpT = nbpT;
4352  isOUFlow = true;
4353  } else if (ibpT == 0) {
4354  ibpT = 1;
4355  isOUFlow = true;
4356  }
4357  double alpha = 0.;
4358  double pTp = hh.GetYaxis()->GetBinCenter(ibpT), pTn = pTp;
4359  if (!useInterp || isOUFlow || (ibpT == nbpT && et > pTp) ||
4360  (ibpT == 1 && et < pTp))
4361  alpha = hh.GetBinContent(ibeta, ibpT);
4362  else {
4363  int jp = ibpT, jn = ibpT - 1;
4364  if (et > pTp) {
4365  jp = ibpT + 1;
4366  jn = ibpT;
4367  pTn = pTp;
4368  pTp = hh.GetYaxis()->GetBinCenter(jp);
4369  } else {
4370  pTn = hh.GetYaxis()->GetBinCenter(jn);
4371  }
4372  double aPos = hh.GetBinContent(ibeta, jp);
4373  double aNeg = hh.GetBinContent(ibeta, jn);
4374  alpha = (aPos * (et - pTn) + aNeg * (pTp - et)) / (pTp - pTn);
4375  ATH_MSG_VERBOSE("interp et = " << et << " alpha+ = " << aPos << " alpha- = "
4376  << aNeg << " alpha = " << alpha);
4377  }
4378  double dalpha = hh.GetBinError(ibeta, ibpT);
4379 
4380  return std::make_pair(alpha, dalpha);
4381 }
4382 
4383 double egammaEnergyCorrectionTool::getAlphaConvSyst(
4384  double cl_eta, double energy, PATCore::ParticleType::Type ptype,
4385  egEnergyCorr::Scale::Variation var, double varSF) const {
4386 
4387  double alpha = 0.;
4388  double aeta = std::abs(cl_eta);
4389  if (aeta > 2.37)
4390  aeta = 2.36;
4391  double ET = energy / std::cosh(cl_eta);
4392 
4393  if (var == egEnergyCorr::Scale::Nominal ||
4394  ptype == PATCore::ParticleType::Electron)
4395  return alpha;
4396 
4397  if (ptype == PATCore::ParticleType::UnconvertedPhoton) {
4398 
4399  if (var == egEnergyCorr::Scale::ConvEfficiencyUp &&
4400  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4401  alpha = m_convRecoEfficiency->GetBinContent(
4402  m_convRecoEfficiency->FindFixBin(aeta));
4403  else if (var == egEnergyCorr::Scale::ConvEfficiencyDown &&
4404  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4405  alpha = -m_convRecoEfficiency->GetBinContent(
4406  m_convRecoEfficiency->FindFixBin(aeta));
4407  else if (var == egEnergyCorr::Scale::ConvRecoUp &&
4408  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4409  alpha = getInterpolateConvSyst2D(*m_convRecoEfficiency_2D, aeta, ET);
4410  else if (var == egEnergyCorr::Scale::ConvRecoDown &&
4411  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4412  alpha =
4413  -1. * getInterpolateConvSyst2D(*m_convRecoEfficiency_2D, aeta, ET);
4414 
4415  } else if (ptype == PATCore::ParticleType::ConvertedPhoton) {
4416 
4417  if (var == egEnergyCorr::Scale::ConvFakeRateUp &&
4418  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4419  alpha = m_convFakeRate->GetBinContent(m_convFakeRate->FindFixBin(aeta));
4420  else if (var == egEnergyCorr::Scale::ConvFakeRateDown &&
4421  m_esmodel != egEnergyCorr::es2023_R22_Run2_v0)
4422  alpha = -m_convFakeRate->GetBinContent(m_convFakeRate->FindFixBin(aeta));
4423  else if (var == egEnergyCorr::Scale::ConvRecoUp &&
4424  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4425  alpha = getInterpolateConvSyst2D(*m_convFakeRate_2D, aeta, ET);
4426  else if (var == egEnergyCorr::Scale::ConvRecoDown &&
4427  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4428  alpha = -1. * getInterpolateConvSyst2D(*m_convFakeRate_2D, aeta, ET);
4429  else if (var == egEnergyCorr::Scale::ConvRadiusUp)
4430  alpha =
4431  m_convRadius->GetBinContent(m_convRadius->FindFixBin(aeta, ET / GeV));
4432  else if (var == egEnergyCorr::Scale::ConvRadiusDown)
4433  alpha = -m_convRadius->GetBinContent(
4434  m_convRadius->FindFixBin(aeta, ET / GeV));
4435  }
4436 
4437  return alpha * varSF;
4438 }
4439 
4440 double egammaEnergyCorrectionTool::getInterpolateConvSyst2D(
4441  const TH2& conv_hist, double aeta, double ET) const {
4442 
4443  // use one bin in eta and linear interpolation in Et between 2 bins
4444  int ieta = conv_hist.GetXaxis()->FindBin(aeta);
4445 
4446  int ipt = conv_hist.GetYaxis()->FindBin(ET);
4447  double ptBin = conv_hist.GetYaxis()->GetBinCenter(ipt);
4448 
4449  int i1, i2;
4450  double pt1, pt2;
4451  if (ET > ptBin) {
4452  i1 = ipt;
4453  i2 = ipt + 1;
4454  pt1 = ptBin;
4455  pt2 = conv_hist.GetYaxis()->GetBinCenter(i2);
4456  } else {
4457  i1 = ipt - 1;
4458  i2 = ipt;
4459  pt1 = conv_hist.GetYaxis()->GetBinCenter(i1);
4460  pt2 = ptBin;
4461  }
4462 
4463  int nbins = conv_hist.GetYaxis()->GetNbins();
4464  double value = 0;
4465  if (i1 >= 1 && i1 < nbins) {
4466  double v1 = conv_hist.GetBinContent(ieta, i1);
4467  double v2 = conv_hist.GetBinContent(ieta, i2);
4468  value = (v1 * (pt2 - ET) + v2 * (ET - pt1)) / (pt2 - pt1);
4469  } else {
4470  if (ipt < 1)
4471  ipt = 1;
4472  if (ipt > nbins)
4473  ipt = nbins;
4474  value = conv_hist.GetBinContent(ieta, ipt);
4475  }
4476 
4477  return value;
4478 }
4479 
4480 double egammaEnergyCorrectionTool::getAlphaPedestal(
4481  double cl_eta, double energy, double eraw,
4482  PATCore::ParticleType::Type ptype, bool isRef,
4483  egEnergyCorr::Scale::Variation var, double varSF) const {
4484  double alpha = 0.;
4485  if (var == egEnergyCorr::Scale::PedestalUp ||
4486  var == egEnergyCorr::Scale::PedestalDown) {
4487  if (m_esmodel == egEnergyCorr::es2017) {
4488  const double delta =
4489  getValueHistoAt(*m_pedestals_es2017, std::abs(cl_eta));
4490  alpha = delta / (energy / cosh(cl_eta));
4491  if (var == egEnergyCorr::Scale::PedestalDown)
4492  alpha *= -1;
4493  } else if (m_esmodel == egEnergyCorr::es2017_summer or
4494  m_esmodel == egEnergyCorr::es2017_summer_improved or
4495  m_esmodel == egEnergyCorr::es2017_summer_final or
4496  m_esmodel == egEnergyCorr::es2017_R21_PRE or
4497  m_esmodel == egEnergyCorr::es2015_5TeV or
4498  m_esmodel == egEnergyCorr::es2017_R21_v0 or
4499  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4500  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4501  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4502  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4503  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4504  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4505  // Et uncertainty band: 10 MeV for the corrected cluster
4506  alpha = 10. / (energy / cosh(cl_eta));
4507  if (var == egEnergyCorr::Scale::PedestalDown)
4508  alpha *= -1;
4509  } else {
4510  // observed pedestal corrected as a systematic on MC for now.
4511  // TODO : correct for it in the data
4512 
4513  double pedestal = getLayerPedestal(cl_eta, ptype, 0, var, varSF) +
4514  getLayerPedestal(cl_eta, ptype, 1, var, varSF) +
4515  getLayerPedestal(cl_eta, ptype, 2, var, varSF) +
4516  getLayerPedestal(cl_eta, ptype, 3, var, varSF);
4517 
4518  if (isRef)
4519  alpha = pedestal / energy *
4520  1.06; // approximate average ratio between calibrated and raw
4521  else
4522  alpha = pedestal / eraw;
4523  }
4524  }
4525 
4526  return alpha * varSF;
4527 }
4528 
4529 double egammaEnergyCorrectionTool::getLayerPedestal(
4530  double cl_eta, PATCore::ParticleType::Type ptype, int iLayer,
4531  egEnergyCorr::Scale::Variation var, double varSF) const {
4532 
4533  double pedestal = 0.;
4534  double aeta = std::abs(cl_eta);
4535 
4536  if (var == egEnergyCorr::Scale::PedestalUp ||
4537  var == egEnergyCorr::Scale::PedestalDown) {
4538 
4539  if (iLayer == 0)
4540  pedestal = m_pedestalL0->GetBinContent(m_pedestalL0->FindFixBin(aeta));
4541  else if (iLayer == 1)
4542  pedestal = m_pedestalL1->GetBinContent(m_pedestalL1->FindFixBin(aeta));
4543  else if (iLayer == 2)
4544  pedestal = m_pedestalL2->GetBinContent(m_pedestalL2->FindFixBin(aeta));
4545  else if (iLayer == 3)
4546  pedestal = m_pedestalL3->GetBinContent(m_pedestalL3->FindFixBin(aeta));
4547 
4548  if (ptype == PATCore::ParticleType::UnconvertedPhoton && aeta < 1.4) {
4549  if (iLayer <= 1)
4550  pedestal /= 1.5;
4551  else if (iLayer == 2)
4552  pedestal *= 15. / 21.;
4553  }
4554 
4555  if (var == egEnergyCorr::Scale::PedestalDown)
4556  pedestal *= -1.;
4557  }
4558 
4559  return pedestal * varSF;
4560 }
4561 
4562 bool egammaEnergyCorrectionTool::isInCrack(double cl_eta) {
4563 
4564  return std::abs(cl_eta) >= 1.35 && std::abs(cl_eta) <= 1.55;
4565 }
4566 
4567 double egammaEnergyCorrectionTool::nearestEtaBEC(double cl_eta) {
4568 
4569  double newEta = cl_eta;
4570 
4571  if (!isInCrack(newEta))
4572  return newEta;
4573 
4574  if (newEta >= 1.35 && newEta <= 1.45)
4575  newEta = 1.349;
4576  if (newEta >= 1.45 && newEta <= 1.55)
4577  newEta = 1.551;
4578 
4579  if (newEta >= -1.55 && newEta <= -1.45)
4580  newEta = -1.551;
4581  if (newEta >= -1.45 && newEta <= -1.35)
4582  newEta = -1.349;
4583 
4584  return newEta;
4585 }
4586 
4587 double egammaEnergyCorrectionTool::pileUpTerm(double energy, double eta,
4588  int particle_type) const {
4589 
4590  double pileupNoise;
4591 
4592  // release 21 for <mu> =32 (combined 2015-2016-2017 dataset), pileup noise =
4593  // f(Et) for superclusters
4594  if (m_esmodel == egEnergyCorr::es2017_R21_v0 or
4595  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4596  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4597  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4598  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4599  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4600  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4601  double avgmu = 32;
4602  if (m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)
4603  avgmu = 34.;
4604 
4605  double et = energy / cosh(eta);
4606  if (et < 5000.)
4607  et = 5000.;
4608  if (et > 50000.)
4609  et = 50000.;
4610  pileupNoise = sqrt(avgmu) * (60. + 40. * log(et / 10000.) / log(5.));
4611  } else {
4612  // approximate pileup noise addition to the total noise in MeV for
4613  // <mu_data> (2012) = 20 converted photons and electrons
4614  pileupNoise = 240.;
4615  // unconverted photons, different values in barrel and end-cap
4616  if (particle_type == 1) {
4617  if (std::abs(eta) < 1.4)
4618  pileupNoise = 200.;
4619  }
4620  }
4621  return pileupNoise;
4622 }
4623 
4624 void egammaEnergyCorrectionTool::getResolution_systematics(
4625  int particle_type, double energy, double eta, double etaCalo, int syst_mask,
4626  double& resolution, double& resolution_error, double& resolution_error_up,
4627  double& resolution_error_down, int resol_type, bool fast) const {
4628 
4629  double pileupNoise = pileUpTerm(energy, eta, particle_type);
4630  double et = energy / cosh(eta);
4631 
4632  resolution =
4633  m_resolution_tool->getResolution(particle_type, energy, eta, resol_type);
4634  // std::cout << " resolution from tool " << resolution << std::endl;
4635  double smearingZ = dataConstantTerm(m_use_etaCalo_scales ? etaCalo : eta);
4636  double esmearingZ =
4637  dataConstantTermError(m_use_etaCalo_scales ? etaCalo : eta);
4638  double esmearingOFC = m_esmodel == egEnergyCorr::es2022_R22_PRE
4639  ? dataConstantTermOFCError(eta)
4640  : 0.;
4641  double resolution2 = resolution * resolution + smearingZ * smearingZ +
4642  (pileupNoise * pileupNoise) / (et * et);
4643  resolution = sqrt(resolution2);
4644 
4645  double_t sum_sigma_resolution2 = 0.;
4646  double sum_deltaDown = 0.;
4647  double sum_deltaUp = 0.;
4648 
4649  for (int isys = 0; isys < 11; isys++) {
4650 
4651  if (syst_mask & (1 << isys)) {
4652 
4653  double sigma2 = 0.;
4654  double sigma2up = 0.;
4655  double sigma2down = 0.;
4656 
4657  // systematics on Z smearing measurement
4658  if (isys == 0) {
4659  double d1 = (smearingZ + esmearingZ) * (smearingZ + esmearingZ) -
4660  smearingZ * smearingZ;
4661  double d2 = smearingZ * smearingZ -
4662  (smearingZ - esmearingZ) * (smearingZ - esmearingZ);
4663  double d = 0.5 * (d1 + d2);
4664  sigma2up = d1;
4665  sigma2down = -d2;
4666  sigma2 = d;
4667  ATH_MSG_DEBUG(
4668  std::format("sys resolution Zsmearing: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4669  }
4670 
4671  // systematics on intrinsic resolution
4672  if (isys == 1) {
4673  double resolutionZ = m_resolution_tool->getResolution(
4674  3, 40000. * cosh(eta), eta, resol_type);
4675  double deltaSigma2 = (1.1 * resolutionZ) * (1.1 * resolutionZ) -
4676  resolutionZ * resolutionZ;
4677  double resolution1 =
4678  m_resolution_tool->getResolution(3, energy, eta, resol_type);
4679  sigma2up = (1.1 * resolution1) * (1.1 * resolution1) -
4680  resolution1 * resolution1 - deltaSigma2;
4681  deltaSigma2 = (0.9 * resolutionZ) * (0.9 * resolutionZ) -
4682  resolutionZ * resolutionZ;
4683  sigma2down = (0.9 * resolution1) * (0.9 * resolution1) -
4684  resolution1 * resolution1 - deltaSigma2;
4685  sigma2 = 0.5 * (sigma2up - sigma2down);
4686  ATH_MSG_DEBUG(
4687  std::format("sys resolution intrinsic: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4688  }
4689 
4690  // systematics from configA ID material
4691  else if (isys == 2) {
4692  double sigmaA =
4693  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 0);
4694  sigma2 = sigmaA * sigmaA;
4695  sigma2up = sigma2;
4696  sigma2down = -1. * sigma2;
4697  ATH_MSG_DEBUG(
4698  std::format("sys resolution configA ID material: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4699  }
4700 
4701  // systematics from material presampler-layer 1 in barrel (based on half
4702  // config M )
4703  else if (isys == 3) {
4704  if (std::abs(eta) < 1.45) {
4705  double sigmaM =
4706  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 3);
4707  sigma2 = 0.5 * sigmaM * sigmaM;
4708  } else
4709  sigma2 = 0.;
4710  sigma2up = sigma2;
4711  sigma2down = -1. * sigma2;
4712  ATH_MSG_DEBUG(
4713  std::format("sys resolution presampler-layer1: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4714  }
4715 
4716  // systematic from material in barrel-endcap gap (using full config X for
4717  // now)
4718  else if (isys == 4) {
4719  if (std::abs(eta) > 1.52 && std::abs(eta) < 1.82) {
4720  double sigmaX =
4721  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 3);
4722  sigma2 = sigmaX * sigmaX;
4723  } else
4724  sigma2 = 0.;
4725  sigma2up = sigma2;
4726  sigma2down = -1. * sigma2;
4727  ATH_MSG_DEBUG(
4728  std::format("sys resolution barrel-endcap gap: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4729  }
4730 
4731  // systematics from material in cryostat area (using half config EL,
4732  // FIXME: could use clever eta dependent scaling)
4733  else if (isys == 5) {
4734  double sigmaEL =
4735  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 2);
4736  sigma2 = 0.5 * sigmaEL * sigmaEL;
4737  sigma2up = sigma2;
4738  sigma2down = -1. * sigma2;
4739  ATH_MSG_DEBUG(
4740  std::format("sys resolution cryostat area: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4741  }
4742 
4743  // systematics from pileup noise on total noise (200 MeV in quadrature,
4744  // somewhat conservative)
4745  else if (isys == 6) {
4746  double et = energy / cosh(eta);
4747  double sigmaPileUp = 0.;
4748  double sigmaZ = 0.;
4749  // release 21 - 10% uncertainty on pileup noise
4750  if (m_esmodel == egEnergyCorr::es2017_R21_v0 or
4751  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4752  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4753  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4754  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4755  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) {
4756  double deltaNoise =
4757  sqrt(1.1 * 1.1 - 1.0) *
4758  pileupNoise; // uncertainty in quadrature 1.1*noise - noise
4759  sigmaPileUp = deltaNoise / et; // sigmaE/E impact
4760  sigmaZ = deltaNoise / 40000.; // sigmaE/E for Z->ee electrons
4761  // (absorbed in smearing correction)
4762  }
4763  // no pileup noise uncertainty for es2017_R21_ofc0_v1
4764  else if (m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1) {
4765  sigmaPileUp = 0.;
4766  sigmaZ = 0.;
4767  } else {
4768  // older models
4769  double deltaPileupNoise = 100.; // MeV
4770  if (std::abs(eta) >= 1.4 && std::abs(eta) < 1.8)
4771  deltaPileupNoise = 200.; // larger systematic in this eta bin
4772  double scaleNcells = 1;
4773  if (particle_type == 1 && std::abs(eta) < 1.4)
4774  scaleNcells = sqrt(3. / 5.); // cluster=3X5 instead of 3x7, rms
4775  // scales with cluster area
4776  sigmaPileUp = deltaPileupNoise * scaleNcells / et;
4777  sigmaZ =
4778  deltaPileupNoise / (40000.); // effect for Z->ee at Et=40 GeV
4779  }
4780  sigma2 = sigmaPileUp * sigmaPileUp - sigmaZ * sigmaZ;
4781  sigma2up = sigma2;
4782  sigma2down = -1. * sigma2;
4783  ATH_MSG_DEBUG(std::format("sys resolution pileup noise: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4784  }
4785 
4786  // systematics from material in IBL+PP0 for barrel
4787  else if (isys == 7 && std::abs(eta) < 1.5 &&
4788  (m_esmodel == egEnergyCorr::es2017 or
4789  m_esmodel == egEnergyCorr::es2017_summer or
4790  m_esmodel == egEnergyCorr::es2017_summer_improved or
4791  m_esmodel == egEnergyCorr::es2017_summer_final or
4792  m_esmodel == egEnergyCorr::es2015_5TeV or
4793  m_esmodel == egEnergyCorr::es2017_R21_v0 or
4794  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4795  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4796  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4797  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4798  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4799  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
4800  double sigmaE =
4801  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 5);
4802  sigma2 = sigmaE * sigmaE;
4803  sigma2up = sigma2;
4804  sigma2down = -1. * sigma2;
4805  ATH_MSG_DEBUG(
4806  std::format("sys resolution ibl material: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4807  }
4808 
4809  // systematics from material in IBL+PP0 for end-cap
4810  else if (isys == 8 && std::abs(eta) > 1.5 &&
4811  (m_esmodel == egEnergyCorr::es2017 or
4812  m_esmodel == egEnergyCorr::es2017_summer or
4813  m_esmodel == egEnergyCorr::es2017_summer_improved or
4814  m_esmodel == egEnergyCorr::es2017_summer_final or
4815  m_esmodel == egEnergyCorr::es2015_5TeV or
4816  m_esmodel == egEnergyCorr::es2017_R21_v0 or
4817  m_esmodel == egEnergyCorr::es2017_R21_v1 or
4818  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 or
4819  m_esmodel == egEnergyCorr::es2018_R21_v0 or
4820  m_esmodel == egEnergyCorr::es2018_R21_v1 or
4821  m_esmodel == egEnergyCorr::es2022_R22_PRE or
4822  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0)) {
4823  double sigmaE =
4824  m_getMaterialDelta->getDelta(particle_type, energy, eta, 1, 5);
4825  // scale factor 2.3 in X0 => sqrt(2) in resolution or 2 in resolution**2
4826  sigma2 = 2.3 * sigmaE * sigmaE;
4827  sigma2up = sigma2;
4828  sigma2down = -1. * sigma2;
4829  ATH_MSG_DEBUG(
4830  std::format("sys resolution pp0 material: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4831 
4832  }
4833 
4834  // AF2 resolution systematics for es2017_R21_v1 model (neglected before
4835  // that...)
4836  else if (isys == 9 &&
4837  (m_esmodel == egEnergyCorr::es2017_R21_v1 ||
4838  m_esmodel == egEnergyCorr::es2017_R21_ofc0_v1 ||
4839  m_esmodel == egEnergyCorr::es2018_R21_v0 ||
4840  m_esmodel == egEnergyCorr::es2018_R21_v1 ||
4841  m_esmodel == egEnergyCorr::es2022_R22_PRE ||
4842  m_esmodel == egEnergyCorr::es2023_R22_Run2_v0) &&
4843  fast) {
4844  const double ptGeV = et / 1e3;
4845  if (particle_type == 0)
4846  sigma2 = getValueHistAt(*m_G4OverAFII_resolution_electron, eta, ptGeV,
4847  true, true, true, true);
4848  if (particle_type == 1)
4849  sigma2 = getValueHistAt(*m_G4OverAFII_resolution_unconverted, eta,
4850  ptGeV, true, true, true, true);
4851  if (particle_type == 2)
4852  sigma2 = getValueHistAt(*m_G4OverAFII_resolution_converted, eta,
4853  ptGeV, true, true, true, true);
4854  sigma2up = -1. * sigma2; // AF2 resolution worse than full Sim,
4855  // sigma2up gives back AF2 resolution
4856  sigma2down = sigma2;
4857  }
4858 
4859  // OFC resolution systematics for for es2022_RUN3_PRE
4860  else if (isys == 10 && (m_esmodel == egEnergyCorr::es2022_R22_PRE)) {
4861  double d1 = (smearingZ + esmearingOFC) * (smearingZ + esmearingOFC) -
4862  smearingZ * smearingZ;
4863  double d2 = smearingZ * smearingZ -
4864  (smearingZ - esmearingOFC) * (smearingZ - esmearingOFC);
4865  double d = 0.5 * (d1 + d2);
4866  sigma2up = d1;
4867  sigma2down = -d2;
4868  sigma2 = d;
4869  ATH_MSG_DEBUG(std::format("sys resolution OFC unc.: {:.7f} {:.7f} {:.7f}", sigma2, sigma2up, sigma2down));
4870  }
4871 
4872  // old method to use max of up and down for All
4873  /*
4874  double rr1 = sqrt(resolution2+sigma2); // nominal (data) +
4875  average error double rr2=0.; if((resolution2-sigma2) > 0.) rr2 =
4876  sqrt(resolution2-sigma2); // max(0, nominal (data) - average error)
4877  double deltaSigma_sys;
4878  if ((rr1-resolution) > (resolution-rr2) ) deltaSigma_sys =
4879  rr1-resolution; else deltaSigma_sys = resolution-rr2; deltaSigma_sys =
4880  deltaSigma_sys / resolution;
4881  */
4882 
4883  // use average of up and down for symmetric uncertainty for All
4884 
4885  double rr1 = 0.;
4886  if ((resolution2 + sigma2up) > 0.)
4887  rr1 = sqrt(resolution2 + sigma2up); // nominal (data) + up error
4888  double rr2 = 0.;
4889  if ((resolution2 + sigma2down) > 0.)
4890  rr2 = sqrt(resolution2 +
4891  sigma2down); // max(0, nominal (data) + down error
4892  double deltaSigma_sys;
4893  deltaSigma_sys =
4894  0.5 * (rr1 - rr2); // average of up and down uncertainties
4895  deltaSigma_sys =
4896  deltaSigma_sys / resolution; // relative resolution uncertainty
4897 
4898  sum_sigma_resolution2 += deltaSigma_sys * deltaSigma_sys;
4899 
4900  if ((resolution2 + sigma2up) > 0.)
4901  rr1 = sqrt(resolution2 + sigma2up);
4902  else
4903  rr1 = 0.;
4904  double deltaSigmaUp = (rr1 - resolution) / resolution;
4905  ATH_MSG_VERBOSE("relative resolution change Up " << deltaSigmaUp);
4906 
4907  if ((resolution2 + sigma2down) > 0.)
4908  rr2 = sqrt(resolution2 + sigma2down);
4909  else
4910  rr2 = 0.;
4911  double deltaSigmaDown = (rr2 - resolution) / resolution;
4912  ATH_MSG_VERBOSE("relative resolution change Down " << deltaSigmaDown);
4913 
4914  sum_deltaUp += deltaSigmaUp;
4915  sum_deltaDown += deltaSigmaDown;
4916  }
4917  }
4918 
4919  resolution = resolution * energy; // to return final resolution in MeV
4920  resolution_error = sqrt(sum_sigma_resolution2) *
4921  resolution; // to return resolution uncertainty in MeV
4922 
4923  resolution_error_up = sum_deltaUp * resolution;
4924  resolution_error_down = sum_deltaDown * resolution;
4925 
4926  ATH_MSG_VERBOSE("Resolution (MeV): "
4927  << resolution
4928  << " Resolution Error (MeV): " << resolution_error << " down "
4929  << resolution_error_down << " up " << resolution_error_up
4930  << " Z smearing " << smearingZ << " +- " << esmearingZ
4931  << " using mask " << syst_mask);
4932 }
4933 
4934 string egammaEnergyCorrectionTool::variationName(
4935  egEnergyCorr::Scale::Variation& var) {
4936  switch (var) {
4937  case egEnergyCorr::Scale::None:
4938  return "None";
4939  case egEnergyCorr::Scale::Nominal:
4940  return "Nominal";
4941  case egEnergyCorr::Scale::topoClusterThresUp:
4942  return "topoClusterThresUp";
4943  case egEnergyCorr::Scale::topoClusterThresDown:
4944  return "topoClusterThresDown";
4945  case egEnergyCorr::Scale::MomentumUp:
4946  return "MomentumUp";
4947  case egEnergyCorr::Scale::MomentumDown:
4948  return "MomentumDown";
4949  case egEnergyCorr::Scale::ZeeStatUp:
4950  return "ZeeStatUp";
4951  case egEnergyCorr::Scale::ZeeStatDown:
4952  return "ZeeStatDown";
4953  case egEnergyCorr::Scale::ZeeSystUp:
4954  return "ZeeSystUp";
4955  case egEnergyCorr::Scale::ZeeSystDown:
4956  return "ZeeSystDown";
4957  case egEnergyCorr::Scale::ZeePhysUp:
4958  return "ZeePhysUp";
4959  case egEnergyCorr::Scale::ZeePhysDown:
4960  return "ZeePhysDown";
4961  case egEnergyCorr::Scale::ZeeAllUp:
4962  return "ZeeAllUp";
4963  case egEnergyCorr::Scale::ZeeAllDown:
4964  return "ZeeAllDown";
4965  case egEnergyCorr::Scale::LArCalibUp:
4966  return "LArCalibUp";
4967  case egEnergyCorr::Scale::LArCalibDown:
4968  return "LArCalibDown";
4969  case egEnergyCorr::Scale::LArUnconvCalibUp:
4970  return "LArUnconvCalibUp";
4971  case egEnergyCorr::Scale::LArUnconvCalibDown:
4972  return "LArUnconvCalibDown";
4973  case egEnergyCorr::Scale::LArElecCalibUp:
4974  return "LArElecCalibUp";
4975  case egEnergyCorr::Scale::LArElecCalibDown:
4976  return "LArElecCalibDown";
4977  case egEnergyCorr::Scale::LArCalibExtra2015PreUp:
4978  return "LArCalibExtra2015PreUp";
4979  case egEnergyCorr::Scale::LArCalibExtra2015PreDown:
4980  return "LArCalibExtra2015PreDown";
4981  case egEnergyCorr::Scale::LArElecUnconvUp:
4982  return "LArElecUnconvUp";
4983  case egEnergyCorr::Scale::LArElecUnconvDown:
4984  return "LArElecUnconvDown";
4985  case egEnergyCorr::Scale::G4Up:
4986  return "G4Up";
4987  case egEnergyCorr::Scale::G4Down:
4988  return "G4Down";
4989  case egEnergyCorr::Scale::PSUp:
4990  return "PSUp";
4991  case egEnergyCorr::Scale::PSDown:
4992  return "PSDown";
4993  case egEnergyCorr::Scale::PSb12Up:
4994  return "PSb12Up";
4995  case egEnergyCorr::Scale::PSb12Down:
4996  return "PSb12Down";
4997  case egEnergyCorr::Scale::S12Up:
4998  return "S12Up";
4999  case egEnergyCorr::Scale::S12Down:
5000  return "S12Down";
5001  case egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up:
5002  return "S12ExtraLastEtaBinRun2Up";
5003  case egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down:
5004  return "S12ExtraLastEtaBinRun2Down";
5005  case egEnergyCorr::Scale::MatIDUp:
5006  return "MatIDUp";
5007  case egEnergyCorr::Scale::MatIDDown:
5008  return "MatIDDown";
5009  case egEnergyCorr::Scale::MatCryoUp:
5010  return "MatCryoUp";
5011  case egEnergyCorr::Scale::MatCryoDown:
5012  return "MatCryoDown";
5013  case egEnergyCorr::Scale::MatCaloUp:
5014  return "MatCaloUp";
5015  case egEnergyCorr::Scale::MatCaloDown:
5016  return "MatCaloDown";
5017  case egEnergyCorr::Scale::L1GainUp:
5018  return "L1GainUp";
5019  case egEnergyCorr::Scale::L1GainDown:
5020  return "L1GainDown";
5021  case egEnergyCorr::Scale::L2GainUp:
5022  return "L2GainUp";
5023  case egEnergyCorr::Scale::L2GainDown:
5024  return "L2GainDown";
5025  case egEnergyCorr::Scale::L2LowGainDown:
5026  return "L2LowGainDown";
5027  case egEnergyCorr::Scale::L2LowGainUp:
5028  return "L2LowGainUp";
5029  case egEnergyCorr::Scale::L2MediumGainDown:
5030  return "L2MediumGainDown";
5031  case egEnergyCorr::Scale::L2MediumGainUp:
5032  return "L2MediumGainUp";
5033  case egEnergyCorr::Scale::ADCLinUp:
5034  return "ADCLinUp";
5035  case egEnergyCorr::Scale::ADCLinDown:
5036  return "ADCLinDown";
5037  case egEnergyCorr::Scale::LeakageElecUp:
5038  return "LeakageElecUp";
5039  case egEnergyCorr::Scale::LeakageElecDown:
5040  return "LeakageElecDown";
5041  case egEnergyCorr::Scale::ConvRecoUp:
5042  return "ConvRecoUp";
5043  case egEnergyCorr::Scale::ConvRecoDown:
5044  return "ConvRecoDown";
5045  case egEnergyCorr::Scale::af2Up:
5046  return "af2Up";
5047  case egEnergyCorr::Scale::af2Down:
5048  return "af2Down";
5049  case egEnergyCorr::Scale::LeakageUnconvUp:
5050  return "LeakageUnconvUp";
5051  case egEnergyCorr::Scale::LeakageUnconvDown:
5052  return "LeakageUnconvDown";
5053  case egEnergyCorr::Scale::LeakageConvUp:
5054  return "LeakageConvUp";
5055  case egEnergyCorr::Scale::LeakageConvDown:
5056  return "LeakageConvDown";
5057  case egEnergyCorr::Scale::ConvEfficiencyUp:
5058  return "ConvEfficiencyUp";
5059  case egEnergyCorr::Scale::ConvEfficiencyDown:
5060  return "ConvEfficiencyDown";
5061  case egEnergyCorr::Scale::ConvFakeRateUp:
5062  return "ConvFakeRateUp";
5063  case egEnergyCorr::Scale::ConvFakeRateDown:
5064  return "ConvFakeRateDown";
5065  case egEnergyCorr::Scale::ConvRadiusUp:
5066  return "ConvRadiusUp";
5067  case egEnergyCorr::Scale::ConvRadiusDown:
5068  return "ConvRadiusDown";
5069  case egEnergyCorr::Scale::PedestalUp:
5070  return "PedestalUp";
5071  case egEnergyCorr::Scale::PedestalDown:
5072  return "PedestalDown";
5073  case egEnergyCorr::Scale::AllUp:
5074  return "AllUp";
5075  case egEnergyCorr::Scale::AllDown:
5076  return "AllDown";
5077  case egEnergyCorr::Scale::AllCorrelatedUp:
5078  return "AllCorrelatedUp";
5079  case egEnergyCorr::Scale::AllCorrelatedDown:
5080  return "AllCorrelatedDown";
5081  case egEnergyCorr::Scale::LArTemperature2015PreUp:
5082  return "LArTemperature2015PreUp";
5083  case egEnergyCorr::Scale::LArTemperature2015PreDown:
5084  return "LArTemperature2015PreDown";
5085  case egEnergyCorr::Scale::LArTemperature2016PreUp:
5086  return "LArTemperature2016PreUp";
5087  case egEnergyCorr::Scale::LArTemperature2016PreDown:
5088  return "LArTemperature2016PreDown";
5089  case egEnergyCorr::Scale::E4ScintillatorUp:
5090  return "E4ScintillatorUp";
5091  case egEnergyCorr::Scale::E4ScintillatorDown:
5092  return "E4ScintillatorDown";
5093  case egEnergyCorr::Scale::MatPP0Up:
5094  return "MatPP0Up";
5095  case egEnergyCorr::Scale::MatPP0Down:
5096  return "MatPP0Down";
5097  case egEnergyCorr::Scale::Wtots1Up:
5098  return "Wtots1Up";
5099  case egEnergyCorr::Scale::Wtots1Down:
5100  return "Wtots1Down";
5101  case egEnergyCorr::Scale::LastScaleVariation:
5102  return "LastScaleVariation";
5103  case egEnergyCorr::Scale::OFCUp:
5104  return "OFCUp";
5105  case egEnergyCorr::Scale::OFCDown:
5106  return "OFCDown";
5107  case egEnergyCorr::Scale::EXTRARUN3PREUp:
5108  return "EXTRARUN3PREUp";
5109  case egEnergyCorr::Scale::EXTRARUN3PREDown:
5110  return "EXTRARUN3PREDown";
5111  default:
5112  return "Unknown";
5113  }
5114 }
5115 
5116 string egammaEnergyCorrectionTool::variationName(
5117  egEnergyCorr::Resolution::Variation& var) {
5118  switch (var) {
5119  case egEnergyCorr::Resolution::None:
5120  return "Resolution::None";
5121  case egEnergyCorr::Resolution::Nominal:
5122  return "Resolution::Nominal";
5123  case egEnergyCorr::Resolution::AllDown:
5124  return "Resolution::AllDown";
5125  case egEnergyCorr::Resolution::AllUp:
5126  return "Resolution::AllUp";
5127  case egEnergyCorr::Resolution::ZSmearingUp:
5128  return "Resolution::ZSmearingUp";
5129  case egEnergyCorr::Resolution::ZSmearingDown:
5130  return "Resolution::ZSmearingDown";
5131  case egEnergyCorr::Resolution::SamplingTermUp:
5132  return "Resolution::SamplingTermUp";
5133  case egEnergyCorr::Resolution::SamplingTermDown:
5134  return "Resolution::SamplingTermDown";
5135  case egEnergyCorr::Resolution::MaterialIDUp:
5136  return "Resolution::MaterialUp";
5137  case egEnergyCorr::Resolution::MaterialIDDown:
5138  return "Resolution::MaterialDown";
5139  case egEnergyCorr::Resolution::MaterialCaloUp:
5140  return "Resolution::MaterialUp";
5141  case egEnergyCorr::Resolution::MaterialCaloDown:
5142  return "Resolution::MaterialDown";
5143  case egEnergyCorr::Resolution::MaterialCryoUp:
5144  return "Resolution::MaterialUp";
5145  case egEnergyCorr::Resolution::MaterialCryoDown:
5146  return "Resolution::MaterialDown";
5147  case egEnergyCorr::Resolution::MaterialGapUp:
5148  return "Resolution::MaterialUp";
5149  case egEnergyCorr::Resolution::MaterialGapDown:
5150  return "Resolution::MaterialDown";
5151  case egEnergyCorr::Resolution::PileUpUp:
5152  return "Resolution::PileUpUp";
5153  case egEnergyCorr::Resolution::PileUpDown:
5154  return "Resolution::PileUpDown";
5155  case egEnergyCorr::Resolution::MaterialPP0Up:
5156  return "Resolution::MaterialPP0Up";
5157  case egEnergyCorr::Resolution::MaterialPP0Down:
5158  return "Resolution::MaterialPP0Down";
5159  case egEnergyCorr::Resolution::MaterialIBLUp:
5160  return "Resolution::MaterialIBLUp";
5161  case egEnergyCorr::Resolution::MaterialIBLDown:
5162  return "Resolution::MaterialIBLDown";
5163  case egEnergyCorr::Resolution::af2Up:
5164  return "Resolution::af2Up";
5165  case egEnergyCorr::Resolution::af2Down:
5166  return "Resolution::af2Down";
5167  case egEnergyCorr::Resolution::OFCUp:
5168  return "Resolution::OFCUp";
5169  case egEnergyCorr::Resolution::OFCDown:
5170  return "Resolution::OFCDown";
5171  case egEnergyCorr::Resolution::LastResolutionVariation:
5172  return "LastResolutionVariation";
5173  default:
5174  return "Resolution::Unknown";
5175  }
5176 }
5177 
5178 double egammaEnergyCorrectionTool::get_ZeeSyst(double eta) const {
5179  const auto ieta = std::as_const(*m_zeeSyst).GetXaxis()->FindFixBin(eta);
5180  auto value_histo = m_zeeSyst->GetBinContent(ieta);
5181 
5182  return value_histo;
5183 }
5184 
5185 double egammaEnergyCorrectionTool::get_OFCSyst(double eta) const {
5186  const auto ieta = std::as_const(*m_zeeSystOFC).GetXaxis()->FindFixBin(eta);
5187  auto value_histo = m_zeeSystOFC->GetBinContent(ieta);
5188 
5189  return value_histo;
5190 }
5191 
5192 const TAxis& egammaEnergyCorrectionTool::get_ZeeStat_eta_axis() const {
5193  return *std::as_const(*m_zeeNom).GetXaxis();
5194 }
5195 
5196 } // namespace AtlasRoot
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPPS_LAr
std::unique_ptr< TH1 > m_dX_IPPS_LAr
Definition: egammaEnergyCorrectionTool.h:664
AtlasRoot::egammaEnergyCorrectionTool::get_ZeeStat_eta_axis
const TAxis & get_ZeeStat_eta_axis() const
Definition: egammaEnergyCorrectionTool.cxx:5192
egEnergyCorr::Scale::ZeeSystDown
@ ZeeSystDown
Definition: egammaEnergyCorrectionTool.h:147
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
egEnergyCorr::Resolution::MaterialPP0Up
@ MaterialPP0Up
Definition: egammaEnergyCorrectionTool.h:93
AtlasRoot::egammaEnergyCorrectionTool::m_resSyst
std::unique_ptr< TH1 > m_resSyst
Definition: egammaEnergyCorrectionTool.h:656
beamspotnt.var
var
Definition: bin/beamspotnt.py:1394
AtlasRoot::egammaEnergyCorrectionTool::m_rootFileName
std::string m_rootFileName
Definition: egammaEnergyCorrectionTool.h:627
egEnergyCorr::Scale::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:266
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2015
std::unique_ptr< TH1 > m_zeeNom_data2015
Definition: egammaEnergyCorrectionTool.h:642
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:736
egEnergyCorr::Scale::PSDown
@ PSDown
Definition: egammaEnergyCorrectionTool.h:184
PATCore::ParticleType::UnconvertedPhoton
@ UnconvertedPhoton
Definition: PATCoreEnums.h:38
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_electrons
std::unique_ptr< TH1 > m_wstot_pT_data_p0_electrons
Definition: egammaEnergyCorrectionTool.h:728
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronCstTerm
std::vector< std::unique_ptr< TH1 > > m_matElectronCstTerm
Definition: egammaEnergyCorrectionTool.h:746
et
Extra patterns decribing particle interation process.
egEnergyCorr::Resolution::SamplingTermUp
@ SamplingTermUp
Definition: egammaEnergyCorrectionTool.h:74
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
egEnergyCorr::es2011c
@ es2011c
Definition: egammaEnergyCorrectionTool.h:289
egEnergyCorr::ConfigIBL
@ ConfigIBL
Definition: egammaEnergyCorrectionTool.h:343
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
egEnergyCorr::Scale::LArCalibExtra2015PreDown
@ LArCalibExtra2015PreDown
Definition: egammaEnergyCorrectionTool.h:166
egEnergyCorr::Scale::LastScaleVariation
@ LastScaleVariation
Definition: egammaEnergyCorrectionTool.h:278
mc.random_seed
random_seed
Definition: mc.PhPy8EG_Hto4l_NNLOPS_nnlo_30_ggH125_ZZ4l.py:43
AtlasRoot::egammaEnergyCorrectionTool::mcSamplingTermRelError
static double mcSamplingTermRelError(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2548
AtlasRoot::egammaEnergyCorrectionTool::m_initialized
bool m_initialized
Definition: egammaEnergyCorrectionTool.h:801
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigN
std::unique_ptr< TH2 > m_unconvertedBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:765
egEnergyCorr::es2011d
@ es2011d
Definition: egammaEnergyCorrectionTool.h:291
max
#define max(a, b)
Definition: cfImp.cxx:41
egEnergyCorr::Scale::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:265
egEnergyCorr::Scale::MatIDDown
@ MatIDDown
Definition: egammaEnergyCorrectionTool.h:216
beamspotman.sigmaZ
sigmaZ
Definition: beamspotman.py:1625
vtune_athena.format
format
Definition: vtune_athena.py:14
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigA
std::unique_ptr< TH2 > m_convertedBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:768
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigPP0
std::unique_ptr< TH2 > m_unconvertedBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:767
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
PATCore::ParticleType::Type
Type
Definition: PATCoreEnums.h:35
AtlasRoot::egammaEnergyCorrectionTool::m_resNom
std::unique_ptr< TH1 > m_resNom
Definition: egammaEnergyCorrectionTool.h:655
DiTauMassTools::TauTypes::hh
@ hh
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:53
AtlasRoot::egammaEnergyCorrectionTool::m_EaccUnconvertedGraphs
std::unique_ptr< TList > m_EaccUnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:699
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::et
et
Definition: TrigEMCluster_v1.cxx:25
AtlasRoot::egammaEnergyCorrectionTool::m_psElectronGraphs
std::unique_ptr< TList > m_psElectronGraphs
Definition: egammaEnergyCorrectionTool.h:676
egEnergyCorr::Scale::LArTemperature2016PreUp
@ LArTemperature2016PreUp
Definition: egammaEnergyCorrectionTool.h:171
egEnergyCorr::Scale::AllCorrelatedDown
@ AllCorrelatedDown
Definition: egammaEnergyCorrectionTool.h:275
AtlasRoot::egammaEnergyCorrectionTool::m_endRunNumber
unsigned int m_endRunNumber
Definition: egammaEnergyCorrectionTool.h:630
AtlasRoot::egammaEnergyCorrectionTool::m_leakageElectron
std::unique_ptr< TH1 > m_leakageElectron
Definition: egammaEnergyCorrectionTool.h:718
AtlasRoot::egammaEnergyCorrectionTool::applyAFtoG4
double applyAFtoG4(double eta, double ptGeV, PATCore::ParticleType::Type ptype) const
MC calibration corrections.
Definition: egammaEnergyCorrectionTool.cxx:3040
egEnergyCorr::Scale::ConvFakeRateDown
@ ConvFakeRateDown
Definition: egammaEnergyCorrectionTool.h:255
graphs
Definition: graphs.py:1
egEnergyCorr::Resolution::ZSmearingUp
@ ZSmearingUp
Definition: egammaEnergyCorrectionTool.h:70
egEnergyCorr::Scale::G4Down
@ G4Down
Definition: egammaEnergyCorrectionTool.h:176
egEnergyCorr::Scale::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:273
hist_file_dump.d
d
Definition: hist_file_dump.py:137
RootHelpers::FindBin
Int_t FindBin(const TAxis *axis, const double x)
Definition: RootHelpers.cxx:14
AtlasRoot::egammaEnergyCorrectionTool::m_applyS12Correction
bool m_applyS12Correction
Definition: egammaEnergyCorrectionTool.h:799
AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedEtaBins
std::unique_ptr< TAxis > m_s12ConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:693
AtlasRoot::egammaEnergyCorrectionTool::m_zeeES2Profile
std::unique_ptr< TH1 > m_zeeES2Profile
Definition: egammaEnergyCorrectionTool.h:720
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_B_MC
std::unique_ptr< TH1 > m_wstot_slope_B_MC
Definition: egammaEnergyCorrectionTool.h:727
egEnergyCorr::Scale::L2GainDown
@ L2GainDown
Definition: egammaEnergyCorrectionTool.h:226
AtlasRoot::egammaEnergyCorrectionTool::getResolutionError
double getResolutionError(PATCore::ParticleDataType::DataType dataType, double energy, double eta, double etaCalo, PATCore::ParticleType::Type ptype, egEnergyCorr::Resolution::Variation value, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
Definition: egammaEnergyCorrectionTool.cxx:2655
AtlasRoot::egammaEnergyCorrectionTool::getE4NonLinearity
double getE4NonLinearity(double cl_eta, double meanE, PATCore::ParticleType::Type) const
Definition: egammaEnergyCorrectionTool.cxx:3659
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_elec
std::unique_ptr< TH2 > m_pp0_elec
Definition: egammaEnergyCorrectionTool.h:722
AtlasRoot::egammaEnergyCorrectionTool::getAlphaValue
double getAlphaValue(long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:1992
egEnergyCorr::Scale::LArTemperature2015PreDown
@ LArTemperature2015PreDown
Definition: egammaEnergyCorrectionTool.h:168
egEnergyCorr::Scale::LArElecUnconvUp
@ LArElecUnconvUp
Definition: egammaEnergyCorrectionTool.h:161
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigEpLp
std::unique_ptr< TH2 > m_unconvertedBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:763
AtlasRoot::egammaEnergyCorrectionTool::getResolution_systematics
void getResolution_systematics(int particle_type, double energy, double eta, double etaCalo, int syst_mask, double &resolution, double &resolution_error, double &resolution_error_up, double &resolution_error_down, int resol_type=0, bool fast=false) const
get resolution and its uncertainty)
Definition: egammaEnergyCorrectionTool.cxx:4624
AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedGraphs
std::unique_ptr< TList > m_psConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:680
AtlasRoot::egammaEnergyCorrectionTool::m_s12ConvertedGraphs
std::unique_ptr< TList > m_s12ConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:694
PATCore::ParticleDataType::Fast
@ Fast
Definition: PATCoreEnums.h:22
AtlasRoot::egammaEnergyCorrectionTool::getDeltaX
double getDeltaX(double cl_eta, egEnergyCorr::MaterialCategory imat, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal) const
Definition: egammaEnergyCorrectionTool.cxx:3802
egEnergyCorr::Scale::LArElecCalibUp
@ LArElecCalibUp
Definition: egammaEnergyCorrectionTool.h:159
conifer::pow
constexpr int pow(int x)
Definition: conifer.h:20
egEnergyCorr::Scale::MatIDUp
@ MatIDUp
Definition: egammaEnergyCorrectionTool.h:215
egEnergyCorr::es2017_R21_v1
@ es2017_R21_v1
Definition: egammaEnergyCorrectionTool.h:320
egEnergyCorr::Scale::LeakageElecUp
@ LeakageElecUp
Definition: egammaEnergyCorrectionTool.h:197
yodamerge_tmp.axis
list axis
Definition: yodamerge_tmp.py:241
AtlasRoot::egammaEnergyCorrectionTool::m_E4ConvertedEtaBins
std::unique_ptr< TAxis > m_E4ConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:686
AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool
std::unique_ptr< egGain::GainTool > m_gain_tool
Definition: egammaEnergyCorrectionTool.h:460
egEnergyCorr::Scale::LeakageConvDown
@ LeakageConvDown
Definition: egammaEnergyCorrectionTool.h:204
egEnergyCorr::Scale::MatPP0Down
@ MatPP0Down
Definition: egammaEnergyCorrectionTool.h:242
AtlasRoot::egammaEnergyCorrectionTool::m_aS12Nom
std::unique_ptr< TH1 > m_aS12Nom
Definition: egammaEnergyCorrectionTool.h:638
egEnergyCorr::es2015PRE_res_improved
@ es2015PRE_res_improved
Definition: egammaEnergyCorrectionTool.h:304
AtlasRoot::egammaEnergyCorrectionTool::m_dX_ID_Nom
std::unique_ptr< TH1 > m_dX_ID_Nom
Definition: egammaEnergyCorrectionTool.h:661
AtlasRoot::egammaEnergyCorrectionTool::get_ZeeSyst
double get_ZeeSyst(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:5178
asg
Definition: DataHandleTestTool.h:28
egEnergyCorr::Resolution::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:98
egammaEnergyCorrectionTool.h
bin
Definition: BinsDiffFromStripMedian.h:43
EgammaARTmonitoring_plotsMaker.particle_type
particle_type
Definition: EgammaARTmonitoring_plotsMaker.py:633
AtlasRoot::egammaEnergyCorrectionTool::m_matUnconvertedScale
std::vector< std::unique_ptr< TH1 > > m_matUnconvertedScale
Definition: egammaEnergyCorrectionTool.h:744
egEnergyCorr::Scale::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:132
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
AtlasRoot::egammaEnergyCorrectionTool::mcZPeakResolution
double mcZPeakResolution(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2618
egEnergyCorr::Scale::EXTRARUN3PREDown
@ EXTRARUN3PREDown
Definition: egammaEnergyCorrectionTool.h:270
AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedGraphs
std::unique_ptr< TList > m_s12UnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:692
egEnergyCorr::Scale::S12Up
@ S12Up
Definition: egammaEnergyCorrectionTool.h:185
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
AtlasRoot::egammaEnergyCorrectionTool::m_daS12Cor
std::unique_ptr< TH1 > m_daS12Cor
Definition: egammaEnergyCorrectionTool.h:639
egEnergyCorr::Scale::L2LowGainDown
@ L2LowGainDown
Definition: egammaEnergyCorrectionTool.h:229
AtlasRoot::egammaEnergyCorrectionTool::m_e1hg_tool
std::unique_ptr< e1hg_systematics > m_e1hg_tool
Definition: egammaEnergyCorrectionTool.h:466
athena.value
value
Definition: athena.py:124
egEnergyCorr::Scale::ZeeStatUp
@ ZeeStatUp
Definition: egammaEnergyCorrectionTool.h:144
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTerm
double dataConstantTerm(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2596
egEnergyCorr::es2011dMedium
@ es2011dMedium
Definition: egammaEnergyCorrectionTool.h:292
AtlasRoot::egammaEnergyCorrectionTool::m_meanZeeProfile
std::unique_ptr< TProfile > m_meanZeeProfile
Definition: egammaEnergyCorrectionTool.h:653
AtlasRoot::egammaEnergyCorrectionTool::getAlphaPedestal
double getAlphaPedestal(double cl_eta, double energy, double eraw, PATCore::ParticleType::Type ptype, bool isRef, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4480
AtlasRoot::egammaEnergyCorrectionTool::mcNoiseTerm
static double mcNoiseTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2556
AtlasRoot::egammaEnergyCorrectionTool::m_uA2MeV_2015_first2weeks_correction
std::unique_ptr< TH1 > m_uA2MeV_2015_first2weeks_correction
Definition: egammaEnergyCorrectionTool.h:652
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL1
std::unique_ptr< TH1 > m_pedestalL1
Definition: egammaEnergyCorrectionTool.h:704
e1hg_systematics.h
AtlasRoot::egammaEnergyCorrectionTool::variationName
static std::string variationName(egEnergyCorr::Scale::Variation &var)
Definition: egammaEnergyCorrectionTool.cxx:4934
egEnergyCorr::Scale::ConvRadiusUp
@ ConvRadiusUp
Definition: egammaEnergyCorrectionTool.h:256
egEnergyCorr::Scale::Wtots1Up
@ Wtots1Up
Definition: egammaEnergyCorrectionTool.h:237
egEnergyCorr::Scale::MatCryoDown
@ MatCryoDown
Definition: egammaEnergyCorrectionTool.h:218
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
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
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
AtlasRoot::egammaEnergyCorrectionTool::RandomNumber
unsigned int RandomNumber
Definition: egammaEnergyCorrectionTool.h:365
D3PDTest::rng
uint32_t rng()
Definition: FillerAlg.cxx:40
x
#define x
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
Dedxcorrection::resolution
double resolution[nGasTypes][nParametersResolution]
Definition: TRT_ToT_Corrections.h:46
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
AtlasRoot::egammaEnergyCorrectionTool::m_begRunNumber
unsigned int m_begRunNumber
Definition: egammaEnergyCorrectionTool.h:629
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_electrons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_electrons
Definition: egammaEnergyCorrectionTool.h:735
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
AtlasRoot::egammaEnergyCorrectionTool::getInterpolateConvSyst2D
double getInterpolateConvSyst2D(const TH2 &conv_hist, double aeta, double ET) const
Definition: egammaEnergyCorrectionTool.cxx:4440
AtlasRoot::egammaEnergyCorrectionTool::m_leakageUnconverted
std::unique_ptr< TH1 > m_leakageUnconverted
Definition: egammaEnergyCorrectionTool.h:717
egEnergyCorr::ConfigN
@ ConfigN
Definition: egammaEnergyCorrectionTool.h:342
egEnergyCorr::Scale::L2GainUp
@ L2GainUp
Definition: egammaEnergyCorrectionTool.h:225
AtlasRoot::egammaEnergyCorrectionTool::m_EaccConvertedEtaBins
std::unique_ptr< TAxis > m_EaccConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:700
PATCore::ParticleDataType::DataType
DataType
Definition: PATCoreEnums.h:22
egEnergyCorr::Scale::AllCorrelatedUp
@ AllCorrelatedUp
Definition: egammaEnergyCorrectionTool.h:274
egEnergyCorr::Scale::MatCaloDown
@ MatCaloDown
Definition: egammaEnergyCorrectionTool.h:220
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
egEnergyCorr::Resolution::MaterialGapUp
@ MaterialGapUp
Definition: egammaEnergyCorrectionTool.h:82
egEnergyCorr::es2017_R21_v0
@ es2017_R21_v0
Definition: egammaEnergyCorrectionTool.h:318
AtlasRoot::egammaEnergyCorrectionTool::mcConstantTerm
static double mcConstantTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2575
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_unconverted
std::unique_ptr< TH2 > m_G4OverAFII_resolution_unconverted
Definition: egammaEnergyCorrectionTool.h:786
egEnergyCorr::Scale::LeakageElecDown
@ LeakageElecDown
Definition: egammaEnergyCorrectionTool.h:198
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigIBL
std::unique_ptr< TH2 > m_unconvertedBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:766
AtlasRoot::egammaEnergyCorrectionTool::m_zeeFwdk
std::unique_ptr< const TH1 > m_zeeFwdk
Definition: egammaEnergyCorrectionTool.h:646
AtlasRoot::egammaEnergyCorrectionTool::getLayerNonLinearity
double getLayerNonLinearity(int iLayer, double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
Definition: egammaEnergyCorrectionTool.cxx:3691
AtlasRoot::egammaEnergyCorrectionTool::m_E4ConvertedGraphs
std::unique_ptr< TList > m_E4ConvertedGraphs
Definition: egammaEnergyCorrectionTool.h:687
egEnergyCorr::Scale::L2LowGainUp
@ L2LowGainUp
Definition: egammaEnergyCorrectionTool.h:230
egEnergyCorr::ConfigPP0
@ ConfigPP0
Definition: egammaEnergyCorrectionTool.h:344
AtlasRoot::egammaEnergyCorrectionTool::m_use_stat_error_scaling
bool m_use_stat_error_scaling
Definition: egammaEnergyCorrectionTool.h:803
eg_resolution.h
AtlasRoot::egammaEnergyCorrectionTool::m_usepTInterpolationForLeakage
bool m_usepTInterpolationForLeakage
Definition: egammaEnergyCorrectionTool.h:808
AtlasRoot::egammaEnergyCorrectionTool::getAlphaLeakage2D
double getAlphaLeakage2D(double cl_eta, double et, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4265
AtlasRoot::egammaEnergyCorrectionTool::m_psUnconvertedEtaBins
std::unique_ptr< TAxis > m_psUnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:677
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPPS_Nom
std::unique_ptr< TH1 > m_dX_IPPS_Nom
Definition: egammaEnergyCorrectionTool.h:663
egEnergyCorr::Scale::MomentumUp
@ MomentumUp
Definition: egammaEnergyCorrectionTool.h:137
AtlasRoot::egammaEnergyCorrectionTool::m_RunNumber
unsigned int m_RunNumber
Definition: egammaEnergyCorrectionTool.h:631
PATCore::ParticleType::ConvertedPhoton
@ ConvertedPhoton
Definition: PATCoreEnums.h:39
AtlasRoot::egammaEnergyCorrectionTool::m_use_etaCalo_scales
bool m_use_etaCalo_scales
Definition: egammaEnergyCorrectionTool.h:795
egEnergyCorr::es2015cPRE
@ es2015cPRE
Definition: egammaEnergyCorrectionTool.h:305
AtlasRoot::egammaEnergyCorrectionTool::getAlphaMaterial
double getAlphaMaterial(double cl_eta, egEnergyCorr::MaterialCategory imat, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3907
AtlasRoot::egammaEnergyCorrectionTool::m_s12ElectronEtaBins
std::unique_ptr< TAxis > m_s12ElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:689
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_converted_photons
Definition: egammaEnergyCorrectionTool.h:739
egEnergyCorr::Scale::LArTemperature2015PreUp
@ LArTemperature2015PreUp
Definition: egammaEnergyCorrectionTool.h:167
egEnergyCorr::Scale::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:272
AtlasRoot::egammaEnergyCorrectionTool::pileUpTerm
double pileUpTerm(double energy, double eta, int particle_type) const
Definition: egammaEnergyCorrectionTool.cxx:4587
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_LAr
std::unique_ptr< TH1 > m_dX_PSAcc_LAr
Definition: egammaEnergyCorrectionTool.h:673
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_electrons
std::unique_ptr< TH1 > m_wstot_pT_data_p1_electrons
Definition: egammaEnergyCorrectionTool.h:729
egEnergyCorr::Scale::L1GainDown
@ L1GainDown
Definition: egammaEnergyCorrectionTool.h:224
egEnergyCorr::Resolution::ZSmearingDown
@ ZSmearingDown
Definition: egammaEnergyCorrectionTool.h:69
A
AtlasRoot::egammaEnergyCorrectionTool::m_convFakeRate
std::unique_ptr< TH1 > m_convFakeRate
Definition: egammaEnergyCorrectionTool.h:711
AtlasRoot::egammaEnergyCorrectionTool::m_matX0Additions
std::vector< std::unique_ptr< TH1 > > m_matX0Additions
Definition: egammaEnergyCorrectionTool.h:747
AtlasRoot::egammaEnergyCorrectionTool::m_resolution_tool
std::unique_ptr< eg_resolution > m_resolution_tool
Definition: egammaEnergyCorrectionTool.h:464
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
egEnergyCorr::es2015_day0_3percent
@ es2015_day0_3percent
Definition: egammaEnergyCorrectionTool.h:301
egEnergyCorr::Scale::LArCalibUp
@ LArCalibUp
Definition: egammaEnergyCorrectionTool.h:155
egEnergyCorr::Resolution::MaterialPP0Down
@ MaterialPP0Down
Definition: egammaEnergyCorrectionTool.h:94
egEnergyCorr::es2010
@ es2010
Definition: egammaEnergyCorrectionTool.h:287
egEnergyCorr::Geometry
Geometry
Definition: egammaEnergyCorrectionTool.h:336
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
UNDEFINED
@ UNDEFINED
Definition: sTGCenumeration.h:18
egEnergyCorr::Resolution::MaterialCryoUp
@ MaterialCryoUp
Definition: egammaEnergyCorrectionTool.h:84
egEnergyCorr::es2017_R21_PRE
@ es2017_R21_PRE
Definition: egammaEnergyCorrectionTool.h:316
ParticleGun_EoverP_Config.momentum
momentum
Definition: ParticleGun_EoverP_Config.py:63
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_Nom
std::unique_ptr< TH1 > m_dX_PSAcc_Nom
Definition: egammaEnergyCorrectionTool.h:671
AtlasRoot::egammaEnergyCorrectionTool::m_psConvertedEtaBins
std::unique_ptr< TAxis > m_psConvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:679
egEnergyCorr::Scale::L1GainUp
@ L1GainUp
Definition: egammaEnergyCorrectionTool.h:223
egEnergyCorr::es2015cPRE_res_improved
@ es2015cPRE_res_improved
Definition: egammaEnergyCorrectionTool.h:306
lumiFormat.i
int i
Definition: lumiFormat.py:85
egEnergyCorr::Scale::topoClusterThresUp
@ topoClusterThresUp
Definition: egammaEnergyCorrectionTool.h:207
egEnergyCorr::Scale::ConvEfficiencyDown
@ ConvEfficiencyDown
Definition: egammaEnergyCorrectionTool.h:253
LinearityADC.h
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_converted_photons
Definition: egammaEnergyCorrectionTool.h:738
AtlasRoot::egammaEnergyCorrectionTool::getAlphaZee
double getAlphaZee(long int runnumber, double eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3119
egEnergyCorr::Scale::LArElecUnconvDown
@ LArElecUnconvDown
Definition: egammaEnergyCorrectionTool.h:162
AtlasRoot::egammaEnergyCorrectionTool::m_use_new_resolution_model
bool m_use_new_resolution_model
Definition: egammaEnergyCorrectionTool.h:802
AtlasRoot::egammaEnergyCorrectionTool::m_psElectronEtaBins
std::unique_ptr< TAxis > m_psElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:675
GainUncertainty.h
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
AtlasRoot::egammaEnergyCorrectionTool::m_zeePhys
std::unique_ptr< TH1 > m_zeePhys
Definition: egammaEnergyCorrectionTool.h:651
AtlasRoot::egammaEnergyCorrectionTool::getWtots1Uncertainty
double getWtots1Uncertainty(double cl_eta, double energy, PATCore::ParticleType::Type ptype) const
Definition: egammaEnergyCorrectionTool.cxx:3448
AtlasRoot::egammaEnergyCorrectionTool::m_use_uA2MeV_2015_first2weeks_correction
bool m_use_uA2MeV_2015_first2weeks_correction
Definition: egammaEnergyCorrectionTool.h:812
egEnergyCorr::Resolution::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:62
plotBeamSpotCompare.ivar
int ivar
Definition: plotBeamSpotCompare.py:383
AtlasRoot::egammaEnergyCorrectionTool::isInCrack
static bool isInCrack(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:4562
AtlasRoot::egammaEnergyCorrectionTool::fcn_sigma
static double fcn_sigma(double energy, double Cdata, double Cdata_er, double S, double S_er)
Definition: egammaEnergyCorrectionTool.cxx:2918
AtlasRoot::egammaEnergyCorrectionTool::m_esmodel
egEnergyCorr::ESModel m_esmodel
Definition: egammaEnergyCorrectionTool.h:791
egEnergyCorr::MaterialCategory
MaterialCategory
Definition: egammaEnergyCorrectionTool.h:349
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_Nom
std::unique_ptr< TH1 > m_dX_IPAcc_Nom
Definition: egammaEnergyCorrectionTool.h:666
asg::AsgMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AsgMessaging.cxx:49
egEnergyCorr::es2012a
@ es2012a
Definition: egammaEnergyCorrectionTool.h:295
AtlasRoot::egammaEnergyCorrectionTool::m_applyPSCorrection
bool m_applyPSCorrection
Definition: egammaEnergyCorrectionTool.h:798
sign
int sign(int a)
Definition: TRT_StrawNeighbourSvc.h:107
AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201516
bool m_use_temp_correction201516
Definition: egammaEnergyCorrectionTool.h:811
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2016
std::unique_ptr< TH1 > m_zeeNom_data2016
Definition: egammaEnergyCorrectionTool.h:643
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigEpLp
std::unique_ptr< TH2 > m_convertedBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:769
AtlasRoot::egammaEnergyCorrectionTool::m_aPSNom
std::unique_ptr< TH1 > m_aPSNom
Definition: egammaEnergyCorrectionTool.h:635
egEnergyCorr::Scale::S12Down
@ S12Down
Definition: egammaEnergyCorrectionTool.h:186
egEnergyCorr::es2017_summer
@ es2017_summer
Definition: egammaEnergyCorrectionTool.h:310
AtlasRoot::egammaEnergyCorrectionTool::getAlphaLeakage
double getAlphaLeakage(double cl_eta, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4230
makeComparison.rootFile
rootFile
Definition: makeComparison.py:27
egEnergyCorr::es2015c_summer
@ es2015c_summer
Definition: egammaEnergyCorrectionTool.h:307
AtlasRoot::egammaEnergyCorrectionTool::m_zeeFwdb
std::unique_ptr< const TH1 > m_zeeFwdb
Definition: egammaEnergyCorrectionTool.h:647
egEnergyCorr::Scale::G4Up
@ G4Up
Definition: egammaEnergyCorrectionTool.h:175
AtlasRoot::egammaEnergyCorrectionTool::nearestEtaBEC
static double nearestEtaBEC(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:4567
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronEtaBins
std::unique_ptr< TAxis > m_matElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:751
AtlasRoot::egammaEnergyCorrectionTool::m_leakageConverted
std::unique_ptr< TH1 > m_leakageConverted
Definition: egammaEnergyCorrectionTool.h:716
egEnergyCorr::Scale::L2MediumGainUp
@ L2MediumGainUp
Definition: egammaEnergyCorrectionTool.h:228
egEnergyCorr::Scale::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:245
egEnergyCorr::Scale::None
@ None
Definition: egammaEnergyCorrectionTool.h:129
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_converted_2D
std::unique_ptr< TH2 > m_G4OverAFII_converted_2D
Definition: egammaEnergyCorrectionTool.h:781
AtlasRoot::egammaEnergyCorrectionTool::m_convRadius
std::unique_ptr< TH1 > m_convRadius
Definition: egammaEnergyCorrectionTool.h:710
egEnergyCorr::Resolution::MaterialCryoDown
@ MaterialCryoDown
Definition: egammaEnergyCorrectionTool.h:83
egEnergyCorr::UNDEFINED
@ UNDEFINED
Definition: egammaEnergyCorrectionTool.h:330
egEnergyCorr::Scale::MatCaloUp
@ MatCaloUp
Definition: egammaEnergyCorrectionTool.h:219
GainTool.h
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
get_MaterialResolutionEffect.h
egEnergyCorr::Scale::ZeeStatDown
@ ZeeStatDown
Definition: egammaEnergyCorrectionTool.h:145
AtlasRoot::egammaEnergyCorrectionTool::m_zeeSystOFC
std::unique_ptr< TH1 > m_zeeSystOFC
Definition: egammaEnergyCorrectionTool.h:650
AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronGraphs
std::unique_ptr< TList > m_EaccElectronGraphs
Definition: egammaEnergyCorrectionTool.h:697
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigA
std::unique_ptr< TH2 > m_electronBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:756
AtlasRoot::egammaEnergyCorrectionTool::m_gain_tool_run2
std::unique_ptr< egGain::GainUncertainty > m_gain_tool_run2
Definition: egammaEnergyCorrectionTool.h:462
egEnergyCorr::Scale::PedestalUp
@ PedestalUp
Definition: egammaEnergyCorrectionTool.h:233
DeMoScan.runnumber
runnumber
Definition: DeMoScan.py:266
AtlasRoot::egammaEnergyCorrectionTool::getMaterialNonLinearity
double getMaterialNonLinearity(double cl_eta, double energy, egEnergyCorr::MaterialCategory imat, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4094
egEnergyCorr::Resolution::None
@ None
Definition: egammaEnergyCorrectionTool.h:59
AtlasRoot::egammaEnergyCorrectionTool::m_E4UnconvertedEtaBins
std::unique_ptr< TAxis > m_E4UnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:684
egEnergyCorr::Resolution::PileUpDown
@ PileUpDown
Definition: egammaEnergyCorrectionTool.h:87
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigFpMX
std::unique_ptr< TH2 > m_convertedBias_ConfigFpMX
Definition: egammaEnergyCorrectionTool.h:770
egEnergyCorr::Scale::E4ScintillatorUp
@ E4ScintillatorUp
Definition: egammaEnergyCorrectionTool.h:179
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_converted
std::unique_ptr< TH1 > m_G4OverAFII_converted
Definition: egammaEnergyCorrectionTool.h:778
egEnergyCorr::Scale::ZeePhysDown
@ ZeePhysDown
Definition: egammaEnergyCorrectionTool.h:149
egEnergyCorr::Scale::Variation
Variation
Definition: egammaEnergyCorrectionTool.h:126
AtlasRoot::egammaEnergyCorrectionTool::resolutionError
void resolutionError(double energy, double cl_eta, double &errUp, double &errDown) const
Definition: egammaEnergyCorrectionTool.cxx:2765
AtlasRoot::egammaEnergyCorrectionTool::m_convRecoEfficiency_2D
std::unique_ptr< TH2 > m_convRecoEfficiency_2D
Definition: egammaEnergyCorrectionTool.h:714
egEnergyCorr::ConfigEL
@ ConfigEL
Definition: egammaEnergyCorrectionTool.h:339
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigN
std::unique_ptr< TH2 > m_electronBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:759
PathResolver.h
AtlasRoot::egammaEnergyCorrectionTool::m_EaccUnconvertedEtaBins
std::unique_ptr< TAxis > m_EaccUnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:698
AtlasRoot::egammaEnergyCorrectionTool::resolution
double resolution(double energy, double cl_eta, double cl_etaCalo, PATCore::ParticleType::Type ptype, bool withCT, bool fast, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
Definition: egammaEnergyCorrectionTool.cxx:2804
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL0
std::unique_ptr< TH1 > m_pedestalL0
Definition: egammaEnergyCorrectionTool.h:703
AtlasRoot::egammaEnergyCorrectionTool::m_daPSCor
std::unique_ptr< TH1 > m_daPSCor
Definition: egammaEnergyCorrectionTool.h:636
AtlasRoot
Definition: egammaEnergyCorrectionTool.h:357
egEnergyCorr::Scale::LArCalibExtra2015PreUp
@ LArCalibExtra2015PreUp
Definition: egammaEnergyCorrectionTool.h:165
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigIBL
std::unique_ptr< TH2 > m_convertedBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:772
AtlasRoot::egammaEnergyCorrectionTool::m_useLeakageCorrection
bool m_useLeakageCorrection
Definition: egammaEnergyCorrectionTool.h:807
AtlasRoot::egammaEnergyCorrectionTool::getAlphaConvSyst
double getAlphaConvSyst(double cl_eta, double energy, PATCore::ParticleType::Type ptype, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4383
VP1PartSpect::E
@ E
Definition: VP1PartSpectFlags.h:21
egEnergyCorr::Resolution::MaterialIBLUp
@ MaterialIBLUp
Definition: egammaEnergyCorrectionTool.h:91
egEnergyCorr::Resolution::Variation
Variation
Definition: egammaEnergyCorrectionTool.h:55
AtlasRoot::egammaEnergyCorrectionTool::m_psUnconvertedGraphs
std::unique_ptr< TList > m_psUnconvertedGraphs
Definition: egammaEnergyCorrectionTool.h:678
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
egEnergyCorr::es2016PRE
@ es2016PRE
Definition: egammaEnergyCorrectionTool.h:308
egEnergyCorr::MatID
@ MatID
Definition: egammaEnergyCorrectionTool.h:350
AtlasRoot::egammaEnergyCorrectionTool::m_pedestalL2
std::unique_ptr< TH1 > m_pedestalL2
Definition: egammaEnergyCorrectionTool.h:705
egEnergyCorr::es2017_summer_final
@ es2017_summer_final
Definition: egammaEnergyCorrectionTool.h:312
AtlasRoot::egammaEnergyCorrectionTool::getMaterialEffect
double getMaterialEffect(egEnergyCorr::Geometry geo, PATCore::ParticleType::Type ptype, double cl_eta, double ET) const
Definition: egammaEnergyCorrectionTool.cxx:3999
egGain::GainUncertainty::GainType::LOW
@ LOW
egEnergyCorr::Scale::ADCLinUp
@ ADCLinUp
Definition: egammaEnergyCorrectionTool.h:193
egEnergyCorr::Scale::ZeeAllDown
@ ZeeAllDown
Definition: egammaEnergyCorrectionTool.h:151
egEnergyCorr::Resolution::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:101
egEnergyCorr::Scale::MatPP0Up
@ MatPP0Up
Definition: egammaEnergyCorrectionTool.h:241
egEnergyCorr::es2012XX
@ es2012XX
Definition: egammaEnergyCorrectionTool.h:302
egEnergyCorr::Scale::ADCLinDown
@ ADCLinDown
Definition: egammaEnergyCorrectionTool.h:194
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down
@ S12ExtraLastEtaBinRun2Down
Definition: egammaEnergyCorrectionTool.h:212
egEnergyCorr::ConfigFMX
@ ConfigFMX
Definition: egammaEnergyCorrectionTool.h:340
egEnergyCorr::es2023_R22_Run2_v0
@ es2023_R22_Run2_v0
Definition: egammaEnergyCorrectionTool.h:328
egEnergyCorr::es2012c
@ es2012c
Definition: egammaEnergyCorrectionTool.h:297
egEnergyCorr::Resolution::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:102
egEnergyCorr::Scale::PSb12Down
@ PSb12Down
Definition: egammaEnergyCorrectionTool.h:190
egEnergyCorr::es2017
@ es2017
Definition: egammaEnergyCorrectionTool.h:309
egEnergyCorr::es2018_R21_v1
@ es2018_R21_v1
Definition: egammaEnergyCorrectionTool.h:325
AtlasRoot::egammaEnergyCorrectionTool::m_resSystOFC
std::unique_ptr< TH1 > m_resSystOFC
Definition: egammaEnergyCorrectionTool.h:657
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
AtlasRoot::egammaEnergyCorrectionTool::getSmearingCorrection
double getSmearingCorrection(double eta, double etaCalo, double energy, RandomNumber seed, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, PATCore::ParticleDataType::DataType dataType=PATCore::ParticleDataType::Full, egEnergyCorr::Resolution::Variation value=egEnergyCorr::Resolution::Nominal, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90) const
smearing corrections
Definition: egammaEnergyCorrectionTool.cxx:2934
AtlasRoot::egammaEnergyCorrectionTool::m_pp0_conv
std::unique_ptr< TH2 > m_pp0_conv
Definition: egammaEnergyCorrectionTool.h:724
AtlasRoot::egammaEnergyCorrectionTool::m_matConvertedScale
std::vector< std::unique_ptr< TH1 > > m_matConvertedScale
Definition: egammaEnergyCorrectionTool.h:745
AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainInterpolation
bool m_useL2GainInterpolation
Definition: egammaEnergyCorrectionTool.h:806
ReadCellNoiseFromCoolCompare.v2
v2
Definition: ReadCellNoiseFromCoolCompare.py:364
AtlasRoot::egammaEnergyCorrectionTool::mcSamplingTerm
static double mcSamplingTerm(double cl_eta)
Definition: egammaEnergyCorrectionTool.cxx:2520
python.AthDsoLogger.fname
string fname
Definition: AthDsoLogger.py:67
fast
bool fast
Definition: TrigGlobEffCorrValidation.cxx:190
egEnergyCorr::Scale::LArUnconvCalibDown
@ LArUnconvCalibDown
Definition: egammaEnergyCorrectionTool.h:158
python.PyAthena.v
v
Definition: PyAthena.py:154
egEnergyCorr::Scale::ConvEfficiencyUp
@ ConvEfficiencyUp
Definition: egammaEnergyCorrectionTool.h:252
egEnergyCorr::Scale::PSb12Up
@ PSb12Up
Definition: egammaEnergyCorrectionTool.h:189
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_electron
std::unique_ptr< TH2 > m_G4OverAFII_resolution_electron
Definition: egammaEnergyCorrectionTool.h:785
AtlasRoot::egammaEnergyCorrectionTool::m_getMaterialDelta
std::unique_ptr< get_MaterialResolutionEffect > m_getMaterialDelta
Definition: egammaEnergyCorrectionTool.h:465
egEnergyCorr::Scale::E4ScintillatorDown
@ E4ScintillatorDown
Definition: egammaEnergyCorrectionTool.h:180
AtlasRoot::egammaEnergyCorrectionTool::m_pedestals_es2017
std::unique_ptr< TH1 > m_pedestals_es2017
Definition: egammaEnergyCorrectionTool.h:708
egEnergyCorr::Resolution::MaterialIDDown
@ MaterialIDDown
Definition: egammaEnergyCorrectionTool.h:77
egEnergyCorr::Scale::ConvFakeRateUp
@ ConvFakeRateUp
Definition: egammaEnergyCorrectionTool.h:254
AtlasRoot::egammaEnergyCorrectionTool::m_convRecoEfficiency
std::unique_ptr< TH1 > m_convRecoEfficiency
Definition: egammaEnergyCorrectionTool.h:712
a
TList * a
Definition: liststreamerinfos.cxx:10
egEnergyCorr::Resolution::MaterialIDUp
@ MaterialIDUp
Definition: egammaEnergyCorrectionTool.h:78
AtlasRoot::egammaEnergyCorrectionTool::m_EaccElectronEtaBins
std::unique_ptr< TAxis > m_EaccElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:696
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p1_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p1_converted_photons
Definition: egammaEnergyCorrectionTool.h:733
egEnergyCorr::Scale::Wtots1Down
@ Wtots1Down
Definition: egammaEnergyCorrectionTool.h:238
egEnergyCorr::Scale::PSUp
@ PSUp
Definition: egammaEnergyCorrectionTool.h:183
y
#define y
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
AtlasRoot::egammaEnergyCorrectionTool::getCorrectedMomentum
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,...
Definition: egammaEnergyCorrectionTool.cxx:1847
egEnergyCorr::es2017_summer_improved
@ es2017_summer_improved
Definition: egammaEnergyCorrectionTool.h:311
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermCorError
double dataConstantTermCorError(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2626
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
egEnergyCorr::Scale::LArElecCalibDown
@ LArElecCalibDown
Definition: egammaEnergyCorrectionTool.h:160
AtlasRoot::egammaEnergyCorrectionTool::egammaEnergyCorrectionTool
egammaEnergyCorrectionTool()
Definition: egammaEnergyCorrectionTool.cxx:121
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
AtlasRoot::egammaEnergyCorrectionTool::m_ADCLinearity_tool
std::shared_ptr< LinearityADC > m_ADCLinearity_tool
Definition: egammaEnergyCorrectionTool.h:463
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p0_electrons
std::unique_ptr< TH1 > m_wstot_pT_MC_p0_electrons
Definition: egammaEnergyCorrectionTool.h:734
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_unconverted
std::unique_ptr< TH1 > m_G4OverAFII_unconverted
Definition: egammaEnergyCorrectionTool.h:779
dq_defect_virtual_defect_validation.d2
d2
Definition: dq_defect_virtual_defect_validation.py:81
egEnergyCorr::Resolution::MaterialCaloUp
@ MaterialCaloUp
Definition: egammaEnergyCorrectionTool.h:80
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigPP0
std::unique_ptr< TH2 > m_electronBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:761
AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncAlpha
std::pair< double, double > getAlphaUncAlpha(const TH1 &hh, double cl_eta, double et, bool useInterp) const
Definition: egammaEnergyCorrectionTool.cxx:4341
egEnergyCorr::Resolution::SamplingTermDown
@ SamplingTermDown
Definition: egammaEnergyCorrectionTool.h:73
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_data_p0_converted_photons
std::unique_ptr< TH1 > m_wstot_pT_data_p0_converted_photons
Definition: egammaEnergyCorrectionTool.h:732
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_slope_A_data
std::unique_ptr< TH1 > m_wstot_slope_A_data
Definition: egammaEnergyCorrectionTool.h:726
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_electron
std::unique_ptr< TH1 > m_G4OverAFII_electron
Definition: egammaEnergyCorrectionTool.h:777
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_electron_2D
std::unique_ptr< TH2 > m_G4OverAFII_electron_2D
Definition: egammaEnergyCorrectionTool.h:780
AtlasRoot::egammaEnergyCorrectionTool::initialize
int initialize()
Definition: egammaEnergyCorrectionTool.cxx:178
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermError
double dataConstantTermError(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2600
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_G4
std::unique_ptr< TH1 > m_dX_IPAcc_G4
Definition: egammaEnergyCorrectionTool.h:667
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AtlasRoot::egammaEnergyCorrectionTool::m_wstot_pT_MC_p1_unconverted_photons
std::unique_ptr< TH1 > m_wstot_pT_MC_p1_unconverted_photons
Definition: egammaEnergyCorrectionTool.h:737
egEnergyCorr::Scale::L2MediumGainDown
@ L2MediumGainDown
Definition: egammaEnergyCorrectionTool.h:227
AtlasRoot::egammaEnergyCorrectionTool::m_useL2GainCorrection
bool m_useL2GainCorrection
Definition: egammaEnergyCorrectionTool.h:805
egEnergyCorr::Resolution::MaterialGapDown
@ MaterialGapDown
Definition: egammaEnergyCorrectionTool.h:81
egEnergyCorr::es2017_R21_ofc0_v1
@ es2017_R21_ofc0_v1
Definition: egammaEnergyCorrectionTool.h:322
AtlasRoot::egammaEnergyCorrectionTool::dataConstantTermOFCError
double dataConstantTermOFCError(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:2604
egEnergyCorr::Scale::ZeePhysUp
@ ZeePhysUp
Definition: egammaEnergyCorrectionTool.h:148
AtlasRoot::egammaEnergyCorrectionTool::m_s12UnconvertedEtaBins
std::unique_ptr< TAxis > m_s12UnconvertedEtaBins
Definition: egammaEnergyCorrectionTool.h:691
egEnergyCorr::ConfigA
@ ConfigA
Definition: egammaEnergyCorrectionTool.h:337
egEnergyCorr::Scale::EXTRARUN3PREUp
@ EXTRARUN3PREUp
Definition: egammaEnergyCorrectionTool.h:269
AtlasRoot::egammaEnergyCorrectionTool::applyFStoG4
double applyFStoG4(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:3107
egEnergyCorr::Scale::LArTemperature2016PreDown
@ LArTemperature2016PreDown
Definition: egammaEnergyCorrectionTool.h:172
egEnergyCorr::Resolution::resolutionType
resolutionType
Definition: egammaEnergyCorrectionTool.h:110
egEnergyCorr::es2022_R22_PRE
@ es2022_R22_PRE
Definition: egammaEnergyCorrectionTool.h:327
AtlasRoot::egammaEnergyCorrectionTool::getCorrectedEnergy
double getCorrectedEnergy(unsigned int runnumber, PATCore::ParticleDataType::DataType dataType, PATCore::ParticleType::Type ptype, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, RandomNumber seed, egEnergyCorr::Scale::Variation scaleVar=egEnergyCorr::Scale::None, egEnergyCorr::Resolution::Variation resVar=egEnergyCorr::Resolution::None, egEnergyCorr::Resolution::resolutionType resType=egEnergyCorr::Resolution::SigmaEff90, double varSF=1.0) const
Definition: egammaEnergyCorrectionTool.cxx:1872
egEnergyCorr::Scale::PedestalDown
@ PedestalDown
Definition: egammaEnergyCorrectionTool.h:234
AtlasRoot::egammaEnergyCorrectionTool::m_trkSyst
std::unique_ptr< TH1 > m_trkSyst
Definition: egammaEnergyCorrectionTool.h:633
egEnergyCorr::Scale::ConvRadiusDown
@ ConvRadiusDown
Definition: egammaEnergyCorrectionTool.h:257
egEnergyCorr::Scale::LArCalibDown
@ LArCalibDown
Definition: egammaEnergyCorrectionTool.h:156
PATCore::ParticleType::Electron
@ Electron
Definition: PATCoreEnums.h:40
PATCore::ParticleDataType::FastShower
@ FastShower
Definition: PATCoreEnums.h:22
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigFpMX
std::unique_ptr< TH2 > m_electronBias_ConfigFpMX
Definition: egammaEnergyCorrectionTool.h:758
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2017
std::unique_ptr< TH1 > m_zeeNom_data2017
Definition: egammaEnergyCorrectionTool.h:644
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigN
std::unique_ptr< TH2 > m_convertedBias_ConfigN
Definition: egammaEnergyCorrectionTool.h:771
AtlasRoot::egammaEnergyCorrectionTool::getZeeMeanET
double getZeeMeanET(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2504
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_LAr
std::unique_ptr< TH1 > m_dX_IPAcc_LAr
Definition: egammaEnergyCorrectionTool.h:668
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigEpLp
std::unique_ptr< TH2 > m_electronBias_ConfigEpLp
Definition: egammaEnergyCorrectionTool.h:757
AtlasRoot::egammaEnergyCorrectionTool::m_electronBias_ConfigIBL
std::unique_ptr< TH2 > m_electronBias_ConfigIBL
Definition: egammaEnergyCorrectionTool.h:760
plotBeamSpotCompare.histo
histo
Definition: plotBeamSpotCompare.py:415
AtlasRoot::egammaEnergyCorrectionTool::m_use_temp_correction201215
bool m_use_temp_correction201215
Definition: egammaEnergyCorrectionTool.h:810
python.PyAthena.obj
obj
Definition: PyAthena.py:132
AtlasRoot::egammaEnergyCorrectionTool::m_unconvertedBias_ConfigA
std::unique_ptr< TH2 > m_unconvertedBias_ConfigA
Definition: egammaEnergyCorrectionTool.h:762
egEnergyCorr::Scale::MatCryoUp
@ MatCryoUp
Definition: egammaEnergyCorrectionTool.h:217
AtlasRoot::egammaEnergyCorrectionTool::m_matElectronGraphs
std::vector< std::unique_ptr< TList > > m_matElectronGraphs
Definition: egammaEnergyCorrectionTool.h:752
egEnergyCorr::Resolution::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:97
egEnergyCorr::Scale::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:246
AtlasRoot::egammaEnergyCorrectionTool::~egammaEnergyCorrectionTool
virtual ~egammaEnergyCorrectionTool()
Definition: egammaEnergyCorrectionTool.cxx:173
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_unconverted_2D
std::unique_ptr< TH2 > m_G4OverAFII_unconverted_2D
Definition: egammaEnergyCorrectionTool.h:782
python.compressB64.c
def c
Definition: compressB64.py:93
egEnergyCorr::es2015_5TeV
@ es2015_5TeV
Definition: egammaEnergyCorrectionTool.h:314
egEnergyCorr::Resolution::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:66
egEnergyCorr::Resolution::MaterialCaloDown
@ MaterialCaloDown
Definition: egammaEnergyCorrectionTool.h:79
AtlasRoot::egammaEnergyCorrectionTool::m_G4OverAFII_resolution_converted
std::unique_ptr< TH2 > m_G4OverAFII_resolution_converted
Definition: egammaEnergyCorrectionTool.h:787
AtlasRoot::egammaEnergyCorrectionTool::getLayerUncertainty
double getLayerUncertainty(int iLayer, double cl_eta, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:3526
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up
@ S12ExtraLastEtaBinRun2Up
Definition: egammaEnergyCorrectionTool.h:211
AtlasRoot::egammaEnergyCorrectionTool::m_convertedBias_ConfigPP0
std::unique_ptr< TH2 > m_convertedBias_ConfigPP0
Definition: egammaEnergyCorrectionTool.h:773
AtlasRoot::egammaEnergyCorrectionTool::m_daPSb12
std::unique_ptr< TH1 > m_daPSb12
Definition: egammaEnergyCorrectionTool.h:637
AtlasRoot::egammaEnergyCorrectionTool::getLayerPedestal
double getLayerPedestal(double cl_eta, PATCore::ParticleType::Type ptype, int iLayer, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:4529
egEnergyCorr::es2018_R21_v0
@ es2018_R21_v0
Definition: egammaEnergyCorrectionTool.h:324
egEnergyCorr::es2015PRE
@ es2015PRE
Definition: egammaEnergyCorrectionTool.h:303
AtlasRoot::egammaEnergyCorrectionTool::m_zeeSyst
std::unique_ptr< TH1 > m_zeeSyst
Definition: egammaEnergyCorrectionTool.h:649
AtlasRoot::egammaEnergyCorrectionTool::dataZPeakResolution
double dataZPeakResolution(double cl_eta) const
Definition: egammaEnergyCorrectionTool.cxx:2610
AtlasRoot::egammaEnergyCorrectionTool::applyMCCalibration
double applyMCCalibration(double eta, double ET, PATCore::ParticleType::Type ptype) const
Definition: egammaEnergyCorrectionTool.cxx:3005
AtlasRoot::egammaEnergyCorrectionTool::getAlphaUncertainty
double getAlphaUncertainty(long int runnumber, double cl_eta, double cl_etaS2, double cl_etaCalo, double energy, double energyS2, double eraw, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, egEnergyCorr::Scale::Variation var=egEnergyCorr::Scale::Nominal, double varSF=1.) const
Definition: egammaEnergyCorrectionTool.cxx:2420
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
AtlasRoot::egammaEnergyCorrectionTool::getE4Uncertainty
static double getE4Uncertainty(double eta)
Definition: egammaEnergyCorrectionTool.cxx:3421
AtlasRoot::egammaEnergyCorrectionTool::m_dX_PSAcc_G4
std::unique_ptr< TH1 > m_dX_PSAcc_G4
Definition: egammaEnergyCorrectionTool.h:672
egEnergyCorr
Definition: egammaEnergyCorrectionTool.h:44
AtlasRoot::egammaEnergyCorrectionTool::get_OFCSyst
double get_OFCSyst(double eta) const
Definition: egammaEnergyCorrectionTool.cxx:5185
egEnergyCorr::Scale::topoClusterThresDown
@ topoClusterThresDown
Definition: egammaEnergyCorrectionTool.h:208
egEnergyCorr::Resolution::MaterialIBLDown
@ MaterialIBLDown
Definition: egammaEnergyCorrectionTool.h:92
AtlasRoot::egammaEnergyCorrectionTool::m_E4ElectronEtaBins
std::unique_ptr< TAxis > m_E4ElectronEtaBins
Definition: egammaEnergyCorrectionTool.h:682
egEnergyCorr::Scale::LArUnconvCalibUp
@ LArUnconvCalibUp
Definition: egammaEnergyCorrectionTool.h:157
AtlasRoot::egammaEnergyCorrectionTool::m_E4ElectronGraphs
std::unique_ptr< TList > m_E4ElectronGraphs
Definition: egammaEnergyCorrectionTool.h:683
AtlasRoot::egammaEnergyCorrectionTool::m_zeeNom_data2018
std::unique_ptr< TH1 > m_zeeNom_data2018
Definition: egammaEnergyCorrectionTool.h:645
egEnergyCorr::Resolution::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:65
AtlasRoot::egammaEnergyCorrectionTool::m_dX_IPAcc_GL1
std::unique_ptr< TH1 > m_dX_IPAcc_GL1
Definition: egammaEnergyCorrectionTool.h:669
Generated on Thu Nov 7 2024 21:14:14 for ATLAS Offline Software by   doxygen 1.8.18