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