ATLAS Offline Software
EgammaCalibrationAndSmearingTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include <memory>
6 
7 #include <string>
8 #include <utility>
9 
10 #include <boost/format.hpp>
11 
12 #include <AsgTools/AsgToolConfig.h>
13 #include <AsgServices/AsgServiceConfig.h>
14 #include "xAODEgamma/Egamma.h"
15 #include "xAODEgamma/EgammaDefs.h"
16 #include "xAODEgamma/EgammaxAODHelpers.h"
17 #include "xAODCaloEvent/CaloCluster.h"
18 #include "xAODTracking/Vertex.h"
19 #include "xAODTracking/TrackParticle.h"
20 #include "xAODTracking/TrackingPrimitives.h"
21 #include "xAODEventInfo/EventInfo.h"
22 #include "AthContainers/ConstAccessor.h"
23 #include "PATInterfaces/SystematicRegistry.h"
24 #include "PathResolver/PathResolver.h"
25 #include <algorithm>
26 
27 #ifndef ROOTCORE
28 #include "AthAnalysisBaseComps/AthAnalysisHelper.h"
29 #endif
30 
31 // internal (old) tool
32 #include "ElectronPhotonFourMomentumCorrection/egammaEnergyCorrectionTool.h"
33 
34 #include "egammaLayerRecalibTool/egammaLayerRecalibTool.h"
35 #include "ElectronPhotonFourMomentumCorrection/GainTool.h"
36 
37 #include "ElectronPhotonFourMomentumCorrection/EgammaCalibrationAndSmearingTool.h"
38 #include <cmath>
39 
40 
41 namespace CP {
42 
43 const double GeV = 1000.;
44 
45 std::unique_ptr<egGain::GainTool> gainToolFactory(egEnergyCorr::ESModel model)
46 {
47  switch (model)
48  {
49  case egEnergyCorr::es2011d:
50  case egEnergyCorr::es2011dMedium:
51  case egEnergyCorr::es2011dTight:
52  case egEnergyCorr::es2012c:
53  case egEnergyCorr::es2012XX:
54  case egEnergyCorr::es2015PRE:
55  case egEnergyCorr::es2015cPRE:
56  case egEnergyCorr::es2015PRE_res_improved:
57  case egEnergyCorr::es2015cPRE_res_improved:
58  case egEnergyCorr::es2015c_summer:
59  case egEnergyCorr::es2015_day0_3percent:
60  case egEnergyCorr::es2016PRE:
61  {
62  const std::string gain_filename1 = PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/FunctionsTO.root");
63  const std::string gain_filename2 = PathResolverFindCalibFile("ElectronPhotonFourMomentumCorrection/v8/FunctionsG_all.root");
64  return std::make_unique<egGain::GainTool>(gain_filename1, gain_filename2);
65  }
66  case egEnergyCorr::es2017:
67  case egEnergyCorr::es2017_summer:
68  case egEnergyCorr::es2017_summer_improved:
69  case egEnergyCorr::es2017_summer_final:
70  case egEnergyCorr::es2017_R21_PRE:
71  case egEnergyCorr::es2017_R21_v0:
72  case egEnergyCorr::es2017_R21_v1:
73  case egEnergyCorr::es2017_R21_ofc0_v1:
74  case egEnergyCorr::es2018_R21_v0:
75  case egEnergyCorr::es2018_R21_v1:
76  case egEnergyCorr::es2022_R22_PRE:
77  return nullptr;
78  default:
79  return nullptr;
80  }
81 }
82 
83 std::string egammaMVAToolFolder(egEnergyCorr::ESModel model)
84 {
85  std::string folder;
86  switch (model)
87  {
88  case egEnergyCorr::es2011d:
89  case egEnergyCorr::es2011dMedium:
90  case egEnergyCorr::es2011dTight:
91  folder = "egammaMVACalib/v1";
92  break;
93  case egEnergyCorr::es2012c:
94  folder = "egammaMVACalib/v1";
95  break;
96  case egEnergyCorr::es2012XX:
97  case egEnergyCorr::es2015PRE:
98  case egEnergyCorr::es2015PRE_res_improved:
99  case egEnergyCorr::es2015_day0_3percent:
100  folder = "egammaMVACalib/offline/v3";
101  break;
102  case egEnergyCorr::es2015cPRE:
103  case egEnergyCorr::es2015cPRE_res_improved:
104  folder = "egammaMVACalib/offline/v3_E4crack_bis";
105  break;
106  case egEnergyCorr::es2015c_summer:
107  case egEnergyCorr::es2016PRE:
108  case egEnergyCorr::es2017:
109  case egEnergyCorr::es2017_summer:
110  case egEnergyCorr::es2017_summer_improved:
111  case egEnergyCorr::es2017_summer_final:
112  case egEnergyCorr::es2015_5TeV:
113  folder = "egammaMVACalib/offline/v4.0";
114  break;
115  case egEnergyCorr::es2017_R21_PRE:
116  case egEnergyCorr::es2017_R21_v0:
117  case egEnergyCorr::es2017_R21_v1:
118  case egEnergyCorr::es2017_R21_ofc0_v1:
119  case egEnergyCorr::es2018_R21_v0:
120  case egEnergyCorr::es2018_R21_v1:
121  case egEnergyCorr::es2022_R22_PRE:
122  folder = "egammaMVACalib/offline/v7";
123  break;
124  default: folder = "";
125  }
126 
127  return folder;
128 }
129 
130 std::unique_ptr<egammaLayerRecalibTool> egammaLayerRecalibToolFactory(egEnergyCorr::ESModel model)
131 {
132  std::string tune = "";
133  switch (model)
134  {
135  case egEnergyCorr::es2011d:
136  case egEnergyCorr::es2011dMedium:
137  case egEnergyCorr::es2011dTight:
138  tune = "2011_alt_with_layer2";
139  break;
140  case egEnergyCorr::es2012c:
141  case egEnergyCorr::es2012XX:
142  case egEnergyCorr::es2015PRE:
143  case egEnergyCorr::es2015cPRE:
144  case egEnergyCorr::es2015PRE_res_improved:
145  case egEnergyCorr::es2015cPRE_res_improved:
146  case egEnergyCorr::es2015_day0_3percent:
147  case egEnergyCorr::es2015c_summer:
148  case egEnergyCorr::es2016PRE:
149  case egEnergyCorr::es2017:
150  case egEnergyCorr::es2015_5TeV:
151  case egEnergyCorr::es2017_R21_PRE:
152  tune = "2012_alt_with_layer2";
153  break;
154  case egEnergyCorr::es2017_summer:
155  case egEnergyCorr::es2017_summer_improved:
156  tune = "es2017_20.7_improved";
157  break;
158  case egEnergyCorr::es2017_summer_final:
159  tune = "es2017_20.7_final";
160  break;
161  case egEnergyCorr::es2017_R21_v0:
162  case egEnergyCorr::es2017_R21_v1:
163  case egEnergyCorr::es2017_R21_ofc0_v1:
164  case egEnergyCorr::es2018_R21_v0:
165  case egEnergyCorr::es2022_R22_PRE:
166  tune = "es2017_21.0_v0";
167  break;
168  case egEnergyCorr::es2018_R21_v1:
169  tune = "es2018_21.0_v0";
170  break;
171  default:
172  return nullptr;
173  }
174  return std::make_unique<egammaLayerRecalibTool>(tune);
175 }
176 
177 bool use_intermodule_correction(egEnergyCorr::ESModel model)
178 {
179  switch (model)
180  {
181  case egEnergyCorr::es2010:
182  case egEnergyCorr::es2011c:
183  case egEnergyCorr::es2011d:
184  case egEnergyCorr::es2011dMedium:
185  case egEnergyCorr::es2011dTight:
186  case egEnergyCorr::es2012a:
187  return false;
188  case egEnergyCorr::es2012c:
189  case egEnergyCorr::es2012cMedium:
190  case egEnergyCorr::es2012cTight:
191  case egEnergyCorr::es2015_day0_3percent:
192  case egEnergyCorr::es2012XX:
193  case egEnergyCorr::es2015PRE:
194  case egEnergyCorr::es2015cPRE:
195  case egEnergyCorr::es2015PRE_res_improved:
196  case egEnergyCorr::es2015cPRE_res_improved:
197  case egEnergyCorr::es2015c_summer:
198  case egEnergyCorr::es2016PRE:
199  case egEnergyCorr::es2017:
200  case egEnergyCorr::es2017_summer:
201  case egEnergyCorr::es2017_summer_improved:
202  case egEnergyCorr::es2017_summer_final:
203  case egEnergyCorr::es2015_5TeV:
204  case egEnergyCorr::es2017_R21_PRE:
205  case egEnergyCorr::es2017_R21_v0:
206  case egEnergyCorr::es2017_R21_v1:
207  case egEnergyCorr::es2017_R21_ofc0_v1:
208  case egEnergyCorr::es2018_R21_v0:
209  case egEnergyCorr::es2018_R21_v1:
210  case egEnergyCorr::es2022_R22_PRE:
211  return true;
212  case egEnergyCorr::UNDEFINED: // TODO: find better logic
213  return false;
214  }
215  assert(false);
216  return false;
217 }
218 
219 bool use_phi_uniform_correction(egEnergyCorr::ESModel model)
220 {
221  return use_intermodule_correction(model); // they are equal
222 }
223 
224 bool is_run2(egEnergyCorr::ESModel model)
225 {
226  switch (model) {
227  case egEnergyCorr::es2010:
228  case egEnergyCorr::es2011c:
229  case egEnergyCorr::es2011d:
230  case egEnergyCorr::es2011dMedium:
231  case egEnergyCorr::es2011dTight:
232  case egEnergyCorr::es2012a:
233  case egEnergyCorr::es2012c:
234  case egEnergyCorr::es2012cMedium:
235  case egEnergyCorr::es2012cTight:
236  return false;
237  case egEnergyCorr::es2015_day0_3percent:
238  case egEnergyCorr::es2012XX:
239  case egEnergyCorr::es2015PRE:
240  case egEnergyCorr::es2015cPRE:
241  case egEnergyCorr::es2015PRE_res_improved:
242  case egEnergyCorr::es2015cPRE_res_improved:
243  case egEnergyCorr::es2015c_summer:
244  case egEnergyCorr::es2016PRE:
245  case egEnergyCorr::es2017:
246  case egEnergyCorr::es2017_summer:
247  case egEnergyCorr::es2017_summer_improved:
248  case egEnergyCorr::es2017_summer_final:
249  case egEnergyCorr::es2015_5TeV:
250  case egEnergyCorr::es2017_R21_PRE:
251  case egEnergyCorr::es2017_R21_v0:
252  case egEnergyCorr::es2017_R21_v1:
253  case egEnergyCorr::es2017_R21_ofc0_v1:
254  case egEnergyCorr::es2018_R21_v0:
255  case egEnergyCorr::es2018_R21_v1:
256  case egEnergyCorr::es2022_R22_PRE:
257  return true;
258  case egEnergyCorr::UNDEFINED: // TODO: find better logic
259  return false;
260  }
261  assert(false);
262  return false;
263 }
264 
265 
266 EgammaCalibrationAndSmearingTool::EgammaCalibrationAndSmearingTool(const std::string& name)
267  : asg::AsgMetadataTool(name),
268  m_TESModel(egEnergyCorr::UNDEFINED),
269  m_TResolutionType(egEnergyCorr::Resolution::SigmaEff90),
270  m_use_mapping_correction(false), m_currentScaleVariation_MC(egEnergyCorr::Scale::None),
271  m_currentScaleVariation_data(egEnergyCorr::Scale::Nominal),
272  m_currentResolutionVariation_MC(egEnergyCorr::Resolution::Nominal),
273  m_currentResolutionVariation_data(egEnergyCorr::Resolution::None),
274  m_set_seed_function([](const EgammaCalibrationAndSmearingTool&,
275  const xAOD::Egamma& egamma,
276  const xAOD::EventInfo& ei) {
277  // avoid 0 as result, see https://root.cern.ch/root/html/TRandom3.html#TRandom3:SetSeed
278  return 1 + static_cast<RandomNumber>(std::abs(egamma.caloCluster()->phi()) * 1E6 + std::abs(egamma.caloCluster()->eta()) * 1E3 + ei.eventNumber()); })
279 {
280  declareProperty("ESModel", m_ESModel = "");
281  declareProperty("decorrelationModel", m_decorrelation_model_name = "");
282  declareProperty("decorrelationModelScale", m_decorrelation_model_scale_name = "");
283  declareProperty("decorrelationModelResolution", m_decorrelation_model_resolution_name = "");
284  declareProperty("ResolutionType", m_ResolutionType = "SigmaEff90");
285  declareProperty("varSF", m_varSF = 1.0);
286  declareProperty("doScaleCorrection", m_doScaleCorrection = AUTO);
287  declareProperty("doSmearing", m_doSmearing = AUTO);
288  declareProperty("useLayerCorrection", m_useLayerCorrection = AUTO);
289  declareProperty("usePSCorrection", m_usePSCorrection = AUTO);
290  declareProperty("useS12Correction", m_useS12Correction = AUTO);
291  declareProperty("useLayer2Recalibration", m_useLayer2Recalibration = AUTO);
292  declareProperty("useIntermoduleCorrection", m_useIntermoduleCorrection = AUTO);
293  declareProperty("usePhiUniformCorrection", m_usePhiUniformCorrection = AUTO);
294  declareProperty("useGainCorrection", m_useGainCorrection = AUTO);
295  declareProperty("MVAfolder", m_MVAfolder = "");
296  declareProperty("layerRecalibrationTune", m_layer_recalibration_tune = "");
297  declareProperty("useEPCombination", m_use_ep_combination = false);
298  declareProperty("useMVACalibration", m_use_mva_calibration = AUTO);
299  declareProperty("use_full_statistical_error", m_use_full_statistical_error=false);
300  declareProperty("use_temp_correction201215", m_use_temp_correction201215=AUTO);
301  declareProperty("use_uA2MeV_2015_first2weeks_correction", m_use_uA2MeV_2015_first2weeks_correction=AUTO);
302  declareProperty("randomRunNumber", m_user_random_run_number=0);
303  // this is the user input, it is never changed by the tool. The tool uses m_simulation.
304  declareProperty("useFastSim", m_useFastSim = -1, "This should be explicitly set by the user depending on the data type (int)0=full sim, (int)1=fast sim");
305  declareProperty("useAFII", m_use_AFII = -1, "This is now deprecated. Kept for explicit error message for now");
306 
307 }
308 
309 EgammaCalibrationAndSmearingTool::~EgammaCalibrationAndSmearingTool() {
310  ATH_MSG_DEBUG("destructor");
311  delete m_layer_recalibration_tool;
312  delete m_gain_tool;
313 }
314 
315 StatusCode EgammaCalibrationAndSmearingTool::initialize() {
316  ATH_MSG_INFO("Initialization");
317 
318  if (m_ESModel == "es2015XX") { ATH_MSG_ERROR("es2015XX is deprecated. Use es2015PRE"); }
319 
320  if (m_ESModel == "es2010") { m_TESModel = egEnergyCorr::es2010; } // legacy
321  else if (m_ESModel == "es2011c") { m_TESModel = egEnergyCorr::es2011c; } // mc11c : faulty G4; old geometry
322  else if (m_ESModel == "es2011d") { m_TESModel = egEnergyCorr::es2011d; } // mc11d : corrected G4; new geometry == final Run1 scheme
323  else if (m_ESModel == "es2012a") { m_TESModel = egEnergyCorr::es2012a; } // mc12a : "crude" G4 fix; old geometry
324  else if (m_ESModel == "es2012c") { m_TESModel = egEnergyCorr::es2012c; } // mc12c : corrected G4; new geometry == final Run1 scheme
325  else if (m_ESModel == "es2012XX") { m_TESModel = egEnergyCorr::es2012XX; }
326  else if (m_ESModel == "es2015PRE") { m_TESModel = egEnergyCorr::es2015PRE; }
327  else if (m_ESModel == "es2015PRE_res_improved") { m_TESModel = egEnergyCorr::es2015PRE_res_improved; }
328  else if (m_ESModel == "es2015cPRE") { m_TESModel = egEnergyCorr::es2015cPRE; }
329  else if (m_ESModel == "es2015cPRE_res_improved") { m_TESModel = egEnergyCorr::es2015cPRE_res_improved; }
330  else if (m_ESModel == "es2015c_summer") { m_TESModel = egEnergyCorr::es2015c_summer; }
331  else if (m_ESModel == "es2016PRE") { m_TESModel = egEnergyCorr::es2016PRE; }
332  else if (m_ESModel == "es2016data_mc15c") { m_TESModel = egEnergyCorr::es2017; }
333  else if (m_ESModel == "es2016data_mc15c_summer") { m_TESModel = egEnergyCorr::es2017_summer; }
334  else if (m_ESModel == "es2016data_mc15c_summer_improved") { m_TESModel = egEnergyCorr::es2017_summer_improved; }
335  else if (m_ESModel == "es2016data_mc15c_final") { m_TESModel = egEnergyCorr::es2017_summer_final; }
336  else if (m_ESModel == "es2015_5TeV") { m_TESModel = egEnergyCorr::es2015_5TeV; }
337  else if (m_ESModel == "es2017_R21_PRE") { m_TESModel = egEnergyCorr::es2017_R21_PRE; }
338  else if (m_ESModel == "es2017_R21_v0") {m_TESModel = egEnergyCorr::es2017_R21_v0;}
339  else if (m_ESModel == "es2017_R21_v1") {m_TESModel = egEnergyCorr::es2017_R21_v1;}
340  else if (m_ESModel == "es2017_R21_ofc0_v1") {m_TESModel = egEnergyCorr::es2017_R21_ofc0_v1;}
341  else if (m_ESModel == "es2018_R21_v0") {m_TESModel = egEnergyCorr::es2018_R21_v0;}
342  else if (m_ESModel == "es2018_R21_v1") {m_TESModel = egEnergyCorr::es2018_R21_v1;}
343  else if (m_ESModel == "es2022_R22_PRE") {m_TESModel = egEnergyCorr::es2022_R22_PRE;}
344  else if (m_ESModel.empty()) {
345  ATH_MSG_ERROR("you must set ESModel property");
346  return StatusCode::FAILURE;
347  }
348  else {
349  ATH_MSG_ERROR("Cannot understand model " << m_ESModel);
350  return StatusCode::FAILURE;
351  }
352 
353  if (m_ResolutionType == "Gaussian") { m_TResolutionType = egEnergyCorr::Resolution::Gaussian; }
354  else if (m_ResolutionType == "SigmaEff80") { m_TResolutionType = egEnergyCorr::Resolution::SigmaEff80; }
355  else if (m_ResolutionType == "SigmaEff90") { m_TResolutionType = egEnergyCorr::Resolution::SigmaEff90; }
356  else {
357  ATH_MSG_ERROR("Cannot understand resolution " << m_ResolutionType);
358  return StatusCode::FAILURE;
359  }
360 
361  if (m_use_AFII!=-1) {
362  ATH_MSG_ERROR("Property useAFII is deprecated. It is now replaced with useFastSim, which should be explicitly configured");
363  return StatusCode::FAILURE;
364  }
365 
366  if (m_useFastSim == 1) { m_simulation = PATCore::ParticleDataType::Fast; }
367  else if (m_useFastSim == 0) { m_simulation = PATCore::ParticleDataType::Full; }
368  else {
369  ATH_MSG_ERROR("Property useFastSim should be explicitly configured");
370  return StatusCode::FAILURE;
371  }
372 
373  if(m_TESModel == egEnergyCorr::es2022_R22_PRE
374  && m_simulation == PATCore::ParticleDataType::Fast){
375  ATH_MSG_ERROR("Sample is FastSim but no AF3 calibration is available yet with es2022_R22_PRE recommendations. Please get in touch with the EGamma CP group in case you are using this");
376  return StatusCode::FAILURE;
377  }
378 
379  // configure decorrelation model, translate string property to internal class enum
380  /* S R SR
381  0. 0 0 0 WARNING Full, Full (this is the default without configuration)
382  1. 0 0 1 SR
383  2. 0 1 0 FATAL
384  3. 0 1 1 WARNING SR then R
385  4. 1 0 0 FATAL
386  5. 1 0 1 WARNING SR then S
387  6. 1 1 0 S, R
388  7. 1 1 1 FATAL
389  */
390  if (m_decorrelation_model_name.empty() and
391  m_decorrelation_model_scale_name.empty() and
392  m_decorrelation_model_resolution_name.empty()) {
393  // case 0
394  ATH_MSG_WARNING("no decorrelation model specified, assuming full model");
395  m_decorrelation_model_scale = ScaleDecorrelation::FULL;
396  m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
397  m_decorrelation_model_name = "FULL_v1";
398  }
399  else if (not m_decorrelation_model_name.empty() and
400  not m_decorrelation_model_scale_name.empty() and
401  not m_decorrelation_model_resolution_name.empty()) {
402  // case 7
403  ATH_MSG_FATAL("too many flags for the decorrelation model");
404  return StatusCode::FAILURE;
405  }
406  else {
407  // set scale decorrelation model
408  if (not m_decorrelation_model_scale_name.empty()) { // case 4, 5, 6, (7)
409  if (not m_decorrelation_model_name.empty()) { ATH_MSG_WARNING("flag decorrelation model ignored for scale decorrelation model"); } // case 5
410  if (m_decorrelation_model_scale_name == "1NP_v1") m_decorrelation_model_scale = ScaleDecorrelation::ONENP;
411  else if (m_decorrelation_model_scale_name == "FULL_ETACORRELATED_v1") m_decorrelation_model_scale = ScaleDecorrelation::FULL_ETA_CORRELATED;
412  else if (m_decorrelation_model_scale_name == "1NPCOR_PLUS_UNCOR") m_decorrelation_model_scale = ScaleDecorrelation::ONENP_PLUS_UNCONR;
413  else if (m_decorrelation_model_scale_name == "FULL_v1") m_decorrelation_model_scale = ScaleDecorrelation::FULL;
414  else {
415  ATH_MSG_FATAL("cannot understand the scale decorrelation model '" << m_decorrelation_model_scale_name << "'(typo?)");
416  return StatusCode::FAILURE;
417  }
418  }
419  else if (not m_decorrelation_model_name.empty()) { // case 1, 3
420  if (m_decorrelation_model_name == "1NP_v1") m_decorrelation_model_scale = ScaleDecorrelation::ONENP;
421  else if (m_decorrelation_model_name == "FULL_ETACORRELATED_v1") m_decorrelation_model_scale = ScaleDecorrelation::FULL_ETA_CORRELATED;
422  else if (m_decorrelation_model_name == "1NPCOR_PLUS_UNCOR") m_decorrelation_model_scale = ScaleDecorrelation::ONENP_PLUS_UNCONR;
423  else if (m_decorrelation_model_name == "FULL_v1") m_decorrelation_model_scale = ScaleDecorrelation::FULL;
424  else {
425  ATH_MSG_FATAL("cannot understand the decorrelation model '" << m_decorrelation_model_name << "'(typo?)");
426  return StatusCode::FAILURE;
427  }
428  }
429  else { // case 2, (7)
430  ATH_MSG_FATAL("not information how to initialize the scale decorrelation model");
431  return StatusCode::FAILURE;
432  }
433 
434  // set resolution decorralation model
435  if (not m_decorrelation_model_resolution_name.empty()) { // case 2, 3, 6, (7)
436  if (not m_decorrelation_model_name.empty()) { ATH_MSG_WARNING("flag decorrelation model ignored for resolution decorrelation model"); } // case 3
437  if (m_decorrelation_model_resolution_name == "1NP_v1") m_decorrelation_model_resolution = ResolutionDecorrelation::ONENP;
438  else if (m_decorrelation_model_resolution_name == "FULL_v1") m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
439  else {
440  ATH_MSG_FATAL("cannot understand the resolution decorrelation model '" << m_decorrelation_model_resolution_name << "'(typo?)");
441  return StatusCode::FAILURE;
442  }
443  }
444  else if (not m_decorrelation_model_name.empty()) { // case 1, 5
445  if (m_decorrelation_model_name == "1NP_v1") m_decorrelation_model_resolution = ResolutionDecorrelation::ONENP;
446  else if (m_decorrelation_model_name == "FULL_ETACORRELATED_v1") m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
447  else if (m_decorrelation_model_name == "1NPCOR_PLUS_UNCOR") m_decorrelation_model_resolution = ResolutionDecorrelation::ONENP;
448  else if (m_decorrelation_model_name == "FULL_v1") m_decorrelation_model_resolution = ResolutionDecorrelation::FULL;
449  else {
450  ATH_MSG_FATAL("cannot understand the decorrelation model '" << m_decorrelation_model_name << "'(typo?)");
451  return StatusCode::FAILURE;
452  }
453  }
454  }
455 
456 
457  // create correction tool
458  ATH_MSG_DEBUG("creating internal correction tool");
459  m_rootTool = std::make_unique<AtlasRoot::egammaEnergyCorrectionTool>();
460  if (!m_rootTool) {
461  ATH_MSG_ERROR("Cannot initialize underlying tool");
462  return StatusCode::FAILURE;
463  }
464  m_rootTool->setESModel(m_TESModel);
465 
466  m_rootTool->msg().setLevel(this->msg().level());
467  m_rootTool->initialize();
468 
469 
470  // configure MVA calibration
471  if (m_use_mva_calibration != 0)
472  {
473  ATH_MSG_DEBUG("creating MVA calibration tool (if needed)");
474  if (m_MVAfolder.empty()) { // automatically configure MVA tool
475  m_MVAfolder = egammaMVAToolFolder(m_TESModel);
476  }
477 
478  if (not m_MVAfolder.empty()) {
479 
480  // electron MVA tool
481  asg::AsgToolConfig config_mva_electron("egammaMVACalibTool/tool_mva_electron");
482  config_mva_electron.setPropertyFromString("folder", m_MVAfolder);
483  ATH_CHECK(config_mva_electron.setProperty("use_layer_corrected", true));;
484  ATH_CHECK(config_mva_electron.setProperty("ParticleType", xAOD::EgammaParameters::electron));
485 
486  // unconverted photon MVA tool
487  asg::AsgToolConfig config_mva_unconverted("egammaMVACalibTool/tool_mva_unconverted");
488  config_mva_unconverted.setPropertyFromString("folder", m_MVAfolder);
489  ATH_CHECK(config_mva_unconverted.setProperty("use_layer_corrected", true));
490  ATH_CHECK(config_mva_unconverted.setProperty("ParticleType", xAOD::EgammaParameters::unconvertedPhoton));
491 
492  // converted photon MVA tool
493  asg::AsgToolConfig config_mva_converted("egammaMVACalibTool/tool_mva_converted");
494  config_mva_converted.setPropertyFromString("folder", m_MVAfolder);
495  ATH_CHECK(config_mva_converted.setProperty("use_layer_corrected", true));
496  ATH_CHECK(config_mva_converted.setProperty("ParticleType", xAOD::EgammaParameters::convertedPhoton));
497 
498  // initialize the ServiceHandler egammaMVASvc
499  // make the name unique
500  std::ostringstream mva_service_name;
501  mva_service_name << "egammaMVASvc/service_mva_egamma_id" << (void const *)this;
502  asg::AsgServiceConfig config_mva_service(mva_service_name.str());
503  ATH_CHECK(config_mva_service.addPrivateTool("ElectronTool", config_mva_electron));
504  ATH_CHECK(config_mva_service.addPrivateTool("UnconvertedPhotonTool", config_mva_unconverted));
505  ATH_CHECK(config_mva_service.addPrivateTool("ConvertedPhotonTool", config_mva_converted));
506  ATH_CHECK(config_mva_service.makeService(m_MVACalibSvc));
507 
508  // m_MVACalibSvc->msg().setLevel(this->msg().level());
509  }
510  else {
511  m_use_mva_calibration = false;
512  }
513  }
514 
515  // configure layer recalibration tool
516  //For now: layer recalibration not applied to PRE release 21 (using run 1 based calibration applied at reco level)
517  // for following R21 recommendations, need to apply the run2/run1 layer calibration ratio
518  if (m_ESModel == "es2017_R21_PRE"){
519  ATH_MSG_INFO("Layer recalibration already applied at cell level");
520  m_useLayerCorrection = false;
521  }
522  else{
523  ATH_MSG_DEBUG("initializing layer recalibration tool (if needed)");
524  if (m_layer_recalibration_tune.empty()) { // automatically configure layer recalibration tool
525  m_layer_recalibration_tool = egammaLayerRecalibToolFactory(m_TESModel).release();
526  if (!m_layer_recalibration_tool) { ATH_MSG_INFO("not using layer recalibration"); }
527  }
528  else {
529  m_layer_recalibration_tool = new egammaLayerRecalibTool(m_layer_recalibration_tune);
530  }
531  if (m_layer_recalibration_tool) {
532  m_layer_recalibration_tool->msg().setLevel(this->msg().level());
533  m_layer_recalibration_tool->fixForMissingCells(m_fixForMissingCells);
534  }
535  }
536 
537  if (m_use_temp_correction201215 != AUTO) m_rootTool->use_temp_correction201215(m_use_temp_correction201215);
538  if (m_use_uA2MeV_2015_first2weeks_correction != AUTO) m_rootTool->use_uA2MeV_2015_first2weeks_correction(m_use_uA2MeV_2015_first2weeks_correction);
539  if (not m_use_full_statistical_error and m_decorrelation_model_scale == ScaleDecorrelation::FULL) { m_rootTool->useStatErrorScaling(true); }
540 
541  if (m_use_ep_combination) {
542  ATH_MSG_ERROR("ep combination not supported yet");
543  throw std::runtime_error("ep combination not supported yet");
544  }
545 
546  if (m_useIntermoduleCorrection == AUTO) { m_useIntermoduleCorrection = use_intermodule_correction(m_TESModel); }
547  if (m_usePhiUniformCorrection == AUTO) { m_usePhiUniformCorrection = use_phi_uniform_correction(m_TESModel); }
548  m_use_mapping_correction = not is_run2(m_TESModel);
549  if (m_useGainCorrection == AUTO) {
550  ATH_MSG_DEBUG("initializing gain tool");
551  m_gain_tool = gainToolFactory(m_TESModel).release();
552  m_useGainCorrection = bool(m_gain_tool);
553  }
554  else if (m_useGainCorrection == 1) {
555  m_useGainCorrection = 0;
556  ATH_MSG_ERROR("cannot instantiate gain tool for this model (you can only disable the gain tool, but not enable it)");
557  }
558 
559  //No scale correction for release 21 ==> obsolete
560  /*if (m_ESModel == "es2017_R21_PRE"){
561  m_doScaleCorrection = 0;
562  }
563  */
564 
565  ATH_MSG_INFO("ESModel: " << m_ESModel);
566  ATH_MSG_INFO("ResolutionType: " << m_ResolutionType);
567  ATH_MSG_INFO("layer correction = " << m_useLayerCorrection);
568  ATH_MSG_INFO("PS correction = " << m_usePSCorrection);
569  ATH_MSG_INFO("S12 correction = " << m_useS12Correction);
570  ATH_MSG_INFO("layer2 recalibration = " << m_useLayer2Recalibration);
571  ATH_MSG_INFO("intermodule correction = " << m_useIntermoduleCorrection);
572  ATH_MSG_INFO("phi uniformity correction = " << m_usePhiUniformCorrection);
573  ATH_MSG_INFO("gain correction = " << m_useGainCorrection);
574  ATH_MSG_INFO("smearing = " << m_doSmearing);
575  ATH_MSG_INFO("insitu scales = " << m_doScaleCorrection);
576  ATH_MSG_INFO("ep combination = " << m_use_ep_combination);
577  ATH_MSG_INFO("use MVA calibration = " << m_use_mva_calibration);
578  ATH_MSG_INFO("use temperature correction 2015 = " << m_use_temp_correction201215);
579  ATH_MSG_INFO("use uA2MeV correction 2015 1/2 week = " << m_use_uA2MeV_2015_first2weeks_correction);
580 
581  setupSystematics();
582 
583  applySystematicVariation(CP::SystematicSet()).ignore(); // this set the flags for the internal tool without systematics
584  CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
585  if ( registry.registerSystematics( *this ) != StatusCode::SUCCESS ) return StatusCode::FAILURE;
586 
587  return StatusCode::SUCCESS;
588 }
589 
590 
591 PATCore::ParticleType::Type EgammaCalibrationAndSmearingTool::xAOD2ptype(const xAOD::Egamma& particle) const
592 {
593  auto ptype = PATCore::ParticleType::Electron;
594  //no ForwardElectron ptype: consider them as Electron
595  if (xAOD::EgammaHelpers::isElectron(&particle) || particle.author() == xAOD::EgammaParameters::AuthorFwdElectron) { ptype = PATCore::ParticleType::Electron; }
596  else if (xAOD::EgammaHelpers::isPhoton(&particle)) {
597  if (xAOD::EgammaHelpers::isConvertedPhoton(&particle)) { ptype = PATCore::ParticleType::ConvertedPhoton; }
598  else { ptype = PATCore::ParticleType::UnconvertedPhoton; }
599  }
600  else {
601  ATH_MSG_ERROR("particle is not electron of photon");
602  throw std::runtime_error("particle is not electron or photon");
603  }
604  return ptype;
605 }
606 
607 double EgammaCalibrationAndSmearingTool::getResolution(const xAOD::Egamma& particle, bool withCT) const
608 {
609  const auto ptype = xAOD2ptype(particle);
610  const auto cl_etaCalo = xAOD::get_eta_calo(*particle.caloCluster(), particle.author());
611 
612  return m_rootTool->resolution(particle.e(), particle.caloCluster()->eta(),
613  cl_etaCalo, ptype,
614  withCT, false); // TODO: always for full simulation
615 }
616 
617 double
618 EgammaCalibrationAndSmearingTool::resolution(double energy, double cl_eta, double cl_etaCalo,
619  PATCore::ParticleType::Type ptype, bool withCT) const
620 {
621  return m_rootTool->resolution(energy, cl_eta, cl_etaCalo, ptype, withCT, false);
622 }
623 
624 
625 CP::CorrectionCode EgammaCalibrationAndSmearingTool::applyCorrection(xAOD::Egamma & input) const
626 {
627  // Retrieve the event information:
628  const xAOD::EventInfo* event_info = nullptr;
629  if (evtStore()->retrieve(event_info, "EventInfo").isFailure()) {
630  ATH_MSG_ERROR("No EventInfo object could be retrieved");
631  return CP::CorrectionCode::Error;
632  }
633  return applyCorrection(input, *event_info);
634 }
635 
636 
637 CP::CorrectionCode EgammaCalibrationAndSmearingTool::correctedCopy(const xAOD::Electron& input, xAOD::Electron*& output) const
638 {
639  // A sanity check:
640  if (output) ATH_MSG_WARNING( "Non-null pointer received. " "There's a possible memory leak!" );
641 
642  output = new xAOD::Electron();
643  output->makePrivateStore(input);
644  return applyCorrection(*output);
645 }
646 
647 CP::CorrectionCode EgammaCalibrationAndSmearingTool::correctedCopy(const xAOD::Photon& input, xAOD::Photon*& output) const
648 {
649  // A sanity check:
650  if (output) ATH_MSG_WARNING( "Non-null pointer received. " "There's a possible memory leak!" );
651 
652  output = new xAOD::Photon();
653  output->makePrivateStore(input);
654  return applyCorrection(*output);
655 }
656 
657 double EgammaCalibrationAndSmearingTool::getEnergy(const xAOD::Photon& input) const
658 {
659  xAOD::Photon* new_particle = nullptr;
660  ANA_CHECK_THROW(correctedCopy(input, new_particle));
661  const double e = new_particle->e();
662  delete new_particle;
663  return e;
664 }
665 
666 double EgammaCalibrationAndSmearingTool::getEnergy(const xAOD::Electron& input) const
667 {
668  xAOD::Electron* new_particle = nullptr;
669  ANA_CHECK_THROW(correctedCopy(input, new_particle));
670  const double e = new_particle->e();
671  delete new_particle;
672  return e;
673 }
674 
675 
676 CP::CorrectionCode EgammaCalibrationAndSmearingTool::applyCorrection(xAOD::Egamma & input, const xAOD::EventInfo& event_info) const
677 {
678  /*
679  * Here we check for each event the kind of data DATA vs FullSim
680  * The m_simulation flavour has already been configured
681  */
682  PATCore::ParticleDataType::DataType dataType = (event_info.eventType(xAOD::EventInfo::IS_SIMULATION)) ? m_simulation : PATCore::ParticleDataType::Data;
683 
684  // only used in simulation (for the smearing)
685  RandomNumber seed = m_set_seed_function(*this, input, event_info);
686 
687  static const SG::ConstAccessor<double> Es0Acc ("correctedcl_Es0");
688  static const SG::ConstAccessor<double> Es1Acc ("correctedcl_Es1");
689  static const SG::ConstAccessor<double> Es2Acc ("correctedcl_Es2");
690  static const SG::ConstAccessor<double> Es3Acc ("correctedcl_Es3");
691 
692  if (dataType == PATCore::ParticleDataType::Data and m_layer_recalibration_tool) {
693  // if data apply energy recalibration
694  ATH_MSG_DEBUG("applying energy recalibration before E0|E1|E2|E3 = "
695  << input.caloCluster()->energyBE(0) << "|"
696  << input.caloCluster()->energyBE(1) << "|"
697  << input.caloCluster()->energyBE(2) << "|"
698  << input.caloCluster()->energyBE(3));
699  const CP::CorrectionCode status_layer_recalibration = m_layer_recalibration_tool->applyCorrection(input, event_info);
700  if (status_layer_recalibration == CP::CorrectionCode::Error) { return CP::CorrectionCode::Error; }
701  ATH_MSG_DEBUG("eta|phi = " << input.eta() << "|" << input.phi());
702  if (status_layer_recalibration == CP::CorrectionCode::Ok) {
703  ATH_MSG_DEBUG("decoration E0|E1|E2|E3 = "
704  << Es0Acc(*input.caloCluster()) << "|"
705  << Es1Acc(*input.caloCluster()) << "|"
706  << Es2Acc(*input.caloCluster()) << "|"
707  << Es3Acc(*input.caloCluster()) << "|");
708  if (Es2Acc(*input.caloCluster()) == 0 and Es1Acc(*input.caloCluster()) == 0 and
709  Es3Acc(*input.caloCluster()) == 0 and Es0Acc(*input.caloCluster()) == 0 and
710  (std::abs(input.eta()) < 1.37 or (std::abs(input.eta()) > 1.55 and std::abs(input.eta()) < 2.47)))
711  {
712  ATH_MSG_WARNING("all layer energies are zero");
713  }
714  }
715  } else {
716  static const SG::AuxElement::Decorator<double> deco_E2("correctedcl_Es2");
717  static const SG::AuxElement::Decorator<double> deco_E3("correctedcl_Es3");
718  double addE2 = 0, addE3 = 0;
719  if (m_fixForMissingCells && event_info.runNumber() > m_Run2Run3runNumberTransition) {
720  unsigned short status =
721  xAOD::EgammaHelpers::energyInMissingCells(input,addE2,addE3);
722  if (status) {
723  ATH_MSG_WARNING("Fix for missing cells required"
724  " but some layer info is not available,"
725  " from L2 : " << status%2 << " from L3 : " << status/2);
726  }
727  }
728  // We do it all the time... otherwise :
729  // imagine you have a job with two tools, one which fixes, the other not.
730  // The one that fixes will create the decoration,
731  // that will be used all the time but the one that does not fix
732  // would have 0 as decoration without those lines...
733  deco_E2(*input.caloCluster()) = input.caloCluster()->energyBE(2) + addE2;
734  deco_E3(*input.caloCluster()) = input.caloCluster()->energyBE(3) + addE3;
735  }
736 
737  double energy = 0.;
738  // apply MVA calibration
739  if (!m_MVACalibSvc.empty()) {
740  if (input.author() != xAOD::EgammaParameters::AuthorFwdElectron) { // do not apply MVA calibration to fwd electrons
741  m_MVACalibSvc->getEnergy(*input.caloCluster(), input, energy).ignore(); // TODO check StatusCode
742  }
743  else { energy = input.e(); }
744  ATH_MSG_DEBUG("energy after MVA calibration = " << boost::format("%.2f") % energy);
745  }
746  else { energy = input.e(); }
747 
748  if ( m_TESModel == egEnergyCorr::es2011c ) {
749  // Crack calibation correction for es2011c (calibration hits calibration)
750  const auto ptype = xAOD2ptype(input);
751  const double etaden = ptype == PATCore::ParticleType::Electron ? static_cast<xAOD::Electron&>(input).trackParticle()->eta() : input.caloCluster()->eta();
752  energy *= m_rootTool->applyMCCalibration( input.caloCluster()->eta(), energy / cosh(etaden), ptype);
753  ATH_MSG_DEBUG("energy after crack calibration es2011c = " << boost::format("%.2f") % energy);
754  }
755 
756  // apply uniformity correction
757  if (dataType == PATCore::ParticleDataType::Data and m_useIntermoduleCorrection) {
758  energy = intermodule_correction(energy, input.caloCluster()->phi(), input.caloCluster()->eta());
759  ATH_MSG_DEBUG("energy after intermodule correction = " << boost::format("%.2f") % energy);
760  }
761 
762  if (dataType == PATCore::ParticleDataType::Data and m_usePhiUniformCorrection) {
763  energy *= correction_phi_unif(xAOD::get_eta_calo(*input.caloCluster(), input.author(), false),
764  xAOD::get_phi_calo(*input.caloCluster(), input.author(), false));
765  ATH_MSG_DEBUG("energy after uniformity correction = " << boost::format("%.2f") % energy);
766  }
767 
768  // apply gain correction
769  if (dataType == PATCore::ParticleDataType::Data and m_gain_tool)
770  {
771  const auto cl_eta = input.caloCluster()->eta();
772  const auto es2 = Es2Acc.isAvailable(*input.caloCluster()) ? Es2Acc(*input.caloCluster()) : input.caloCluster()->energyBE(2);
773  if ((std::abs(cl_eta) >= 1.52 || std::abs(cl_eta) <= 1.37) and std::abs(cl_eta) < 2.4)
774  energy = m_gain_tool->CorrectionGainTool(cl_eta, energy / GeV, es2 / GeV, xAOD2ptype(input)); // cl_eta ok, TODO: check corrected E2
775  ATH_MSG_DEBUG("energy after gain correction = " << boost::format("%.2f") % energy);
776  }
777 
778  const double eraw = ((Es0Acc.isAvailable(*input.caloCluster()) ? Es0Acc(*input.caloCluster()) : input.caloCluster()->energyBE(0)) +
779  (Es1Acc.isAvailable(*input.caloCluster()) ? Es1Acc(*input.caloCluster()) : input.caloCluster()->energyBE(1)) +
780  (Es2Acc.isAvailable(*input.caloCluster()) ? Es2Acc(*input.caloCluster()) : input.caloCluster()->energyBE(2)) +
781  (Es3Acc.isAvailable(*input.caloCluster()) ? Es3Acc(*input.caloCluster()) : input.caloCluster()->energyBE(3)));
782 
783 
784  unsigned int runNumber_for_tool = 0;
785  if (dataType == PATCore::ParticleDataType::Data) runNumber_for_tool = event_info.runNumber();
786  else {
787  if (m_user_random_run_number == 0) {
788  static const SG::AuxElement::Accessor<unsigned int> randomrunnumber_getter("RandomRunNumber");
789  if (randomrunnumber_getter.isAvailable(event_info)) { runNumber_for_tool = randomrunnumber_getter(event_info); }
790  else {
791  ATH_MSG_ERROR("Pileup tool not run before using ElectronPhotonFourMomentumCorrection! Assuming it is 2016. If you "
792  "want to force a specific period set the property randomRunNumber of the tool, e.g. in the job option: "
793  "tool.randomRunNumber = 123456 or "
794  "tool.randomRunNumber = EgammaCalibrationAndSmearingToolRunNumbersExample.run_2016");
795  runNumber_for_tool = EgammaCalibPeriodRunNumbersExample::run_2016;
796  }
797  }
798  else {
799  runNumber_for_tool = m_user_random_run_number;
800  }
801  }
802 
803  if (dataType == PATCore::ParticleDataType::Fast) ATH_MSG_DEBUG("is fast");
804  else if (dataType == PATCore::ParticleDataType::Full) ATH_MSG_DEBUG("is full");
805  else if (dataType == PATCore::ParticleDataType::Data) ATH_MSG_DEBUG("is data");
806 
807  // apply scale factors or systematics
808  energy = m_rootTool->getCorrectedEnergy(
809  runNumber_for_tool,
810  dataType,
811  xAOD2ptype(input),
812  input.caloCluster()->eta(),
813  xAOD::get_eta_calo(*input.caloCluster(), input.author(), false),
814  energy,
815  Es2Acc.isAvailable(*input.caloCluster()) ? Es2Acc(*input.caloCluster()) : input.caloCluster()->energyBE(2),
816  eraw,
817  seed,
818  oldtool_scale_flag_this_event(input, event_info),
819  oldtool_resolution_flag_this_event(input, event_info),
820  m_TResolutionType,
821  m_varSF);
822 
823  ATH_MSG_DEBUG("energy after scale/systematic correction = " << boost::format("%.2f") % energy);
824 
825  // TODO: this check should be done before systematics variations
826  const double new_energy2 = energy * energy;
827  const double m2 = input.m() * input.m();
828  const double p2 = new_energy2 > m2 ? new_energy2 - m2 : 0.;
829  input.setPt(sqrt(p2) / cosh(input.eta()));
830  ATH_MSG_DEBUG("after setting pt, energy = " << input.e());
831  return CP::CorrectionCode::Ok;
832 }
833 
834 
835 double EgammaCalibrationAndSmearingTool::getEnergy(xAOD::Egamma* p, const xAOD::EventInfo* event_info)
836 {
837  ANA_CHECK_THROW(applyCorrection(*p, *event_info));
838  ATH_MSG_DEBUG("returning " << p->e());
839  return p->e();
840 }
841 
842 
843 egEnergyCorr::Scale::Variation EgammaCalibrationAndSmearingTool::oldtool_scale_flag_this_event(const xAOD::Egamma& p, const xAOD::EventInfo& event_info) const
844 {
845  if (!event_info.eventType(xAOD::EventInfo::IS_SIMULATION)) return m_currentScaleVariation_data;
846  if (m_currentScalePredicate(p)) return m_currentScaleVariation_MC;
847  else return egEnergyCorr::Scale::None;
848 }
849 
850 egEnergyCorr::Resolution::Variation EgammaCalibrationAndSmearingTool::oldtool_resolution_flag_this_event(const xAOD::Egamma&, const xAOD::EventInfo& event_info) const
851 {
852  return event_info.eventType(xAOD::EventInfo::IS_SIMULATION) ? m_currentResolutionVariation_MC : m_currentResolutionVariation_data;
853 }
854 
855 double EgammaCalibrationAndSmearingTool::getElectronMomentum(const xAOD::Electron *el, const xAOD::EventInfo* event_info)
856 {
857  PATCore::ParticleDataType::DataType dataType = (event_info->eventType(xAOD::EventInfo::IS_SIMULATION)) ? m_simulation : PATCore::ParticleDataType::Data;
858 
859  const xAOD::TrackParticle* eTrack = el->trackParticle();
860 
861  // track momentum and eta
862  const float el_tracketa = eTrack->eta();
863  const float el_trackmomentum = eTrack->pt() * cosh(el->eta());
864 
865  return m_rootTool->getCorrectedMomentum(dataType,
866  PATCore::ParticleType::Electron,
867  el_trackmomentum,
868  el_tracketa,
869  oldtool_scale_flag_this_event(*el, *event_info),
870  m_varSF);
871 }
872 
873 bool EgammaCalibrationAndSmearingTool::isAffectedBySystematic( const CP::SystematicVariation& systematic ) const {
874  CP::SystematicSet sys = affectingSystematics();
875  return sys.find( systematic ) != sys.end();
876 }
877 
878 CP::SystematicSet EgammaCalibrationAndSmearingTool::affectingSystematics() const {
879  CP::SystematicSet affecting_systematics;
880  for (const auto& it : m_syst_description) { affecting_systematics.insert(it.first); }
881  for (const auto& it : m_syst_description_resolution) { affecting_systematics.insert(it.first); }
882 
883  return affecting_systematics;
884 }
885 
886 void EgammaCalibrationAndSmearingTool::setupSystematics() {
887  const EgammaPredicate always = [](const xAOD::Egamma&) { return true; };
888 
889  if (m_decorrelation_model_scale == ScaleDecorrelation::ONENP) {
890  // TODO: independet implementation of ALL UP looping on all the variations
891  m_syst_description[CP::SystematicVariation("EG_SCALE_ALL", +1)] = SysInfo{always, egEnergyCorr::Scale::AllUp};
892  m_syst_description[CP::SystematicVariation("EG_SCALE_ALL", -1)] = SysInfo{always, egEnergyCorr::Scale::AllDown};
893  // extra AF2 systematics in addition to the 1NP
894  if ( m_TESModel == egEnergyCorr::es2017_R21_v0 || m_TESModel == egEnergyCorr::es2017_R21_v1 || m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 || m_TESModel == egEnergyCorr::es2018_R21_v0 || m_TESModel == egEnergyCorr::es2018_R21_v1 || m_TESModel == egEnergyCorr::es2022_R22_PRE) {
895  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2",+1)] = SysInfo{always, egEnergyCorr::Scale::af2Up};
896  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2",-1)] = SysInfo{always, egEnergyCorr::Scale::af2Down};
897  }
898  }
899  else if (m_decorrelation_model_scale == ScaleDecorrelation::FULL_ETA_CORRELATED) {
900  // all the physical effects separately, considered as fully correlated in eta
901 
902  // common systematics for all the esmodels
903  #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
904  m_syst_description[CP::SystematicVariation(#name, +1)] = SysInfo{always, flagup}; \
905  m_syst_description[CP::SystematicVariation(#name, -1)] = SysInfo{always, flagdown};
906  #include "ElectronPhotonFourMomentumCorrection/systematics.def"
907  #undef SYSMACRO
908 
909  // Zee stat is not included in the macro list, add by hand
910  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT", +1)] = SysInfo{always, egEnergyCorr::Scale::ZeeStatUp};
911  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT", -1)] = SysInfo{always, egEnergyCorr::Scale::ZeeStatDown};
912 
913  // additional systematics for R22 OFC and MC21 pre and bulk
914  if (m_TESModel == egEnergyCorr::es2022_R22_PRE) {
915  m_syst_description[CP::SystematicVariation("EG_SCALE_OFC", +1)] = SysInfo{always, egEnergyCorr::Scale::OFCUp};
916  m_syst_description[CP::SystematicVariation("EG_SCALE_OFC", -1)] = SysInfo{always, egEnergyCorr::Scale::OFCDown};
917 
918  m_syst_description[CP::SystematicVariation("EG_SCALE_EXTRARUN3PRE", +1)] = SysInfo{always, egEnergyCorr::Scale::EXTRARUN3PREUp};
919  m_syst_description[CP::SystematicVariation("EG_SCALE_EXTRARUN3PRE", -1)] = SysInfo{always, egEnergyCorr::Scale::EXTRARUN3PREDown};
920  }
921 
922  // additional systematics for S12 run2
923  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or m_TESModel == egEnergyCorr::es2015PRE or
924  m_TESModel == egEnergyCorr::es2015cPRE or m_TESModel == egEnergyCorr::es2015c_summer or
925  m_TESModel == egEnergyCorr::es2016PRE or m_TESModel == egEnergyCorr::es2017 or
926  m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved
927  or m_TESModel == egEnergyCorr::es2015_5TeV) {
928  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE", +1)] = SysInfo{always, egEnergyCorr::Scale::LArCalibExtra2015PreUp};
929  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE", -1)] = SysInfo{always, egEnergyCorr::Scale::LArCalibExtra2015PreDown};
930  }
931 
932  // additional systematics for temperature run1->run2
933  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or m_TESModel == egEnergyCorr::es2015PRE or
934  m_TESModel == egEnergyCorr::es2015cPRE or m_TESModel == egEnergyCorr::es2015c_summer or
935  m_TESModel == egEnergyCorr::es2016PRE) {
936  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2015PRE", +1)] = SysInfo{always, egEnergyCorr::Scale::LArTemperature2015PreUp};
937  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2015PRE", -1)] = SysInfo{always, egEnergyCorr::Scale::LArTemperature2015PreDown};
938  }
939 
940  // additional systematic for S12 last eta bin run2
941  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2015_5TeV) {
942  m_syst_description[CP::SystematicVariation("EG_SCALE_S12EXTRALASTETABINRUN2", +1)] = SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up};
943  m_syst_description[CP::SystematicVariation("EG_SCALE_S12EXTRALASTETABINRUN2", -1)] = SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down};
944  }
945 
946  // additional systematic for PP0 region
947  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2015_5TeV or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE) {
948  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0", +1)] = SysInfo{always, egEnergyCorr::Scale::MatPP0Up};
949  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0", -1)] = SysInfo{always, egEnergyCorr::Scale::MatPP0Down};
950  }
951 
952  // systematic related to wtots1
953  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2015_5TeV or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE ) {
954  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", +1)] = SysInfo{always, egEnergyCorr::Scale::Wtots1Up};
955  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", -1)] = SysInfo{always, egEnergyCorr::Scale::Wtots1Down};
956  }
957 
958  // systematic for the scintillators
959  if (m_TESModel == egEnergyCorr::es2015cPRE or m_TESModel == egEnergyCorr::es2015c_summer or m_TESModel == egEnergyCorr::es2016PRE or m_TESModel == egEnergyCorr::es2017
960  or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2015_5TeV or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE) {
961  // scintillator systematics
962  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR", +1)] = SysInfo{always, egEnergyCorr::Scale::E4ScintillatorUp};
963  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR", -1)] = SysInfo{always, egEnergyCorr::Scale::E4ScintillatorDown};
964  }
965 
966  // additional systematic for temperature 2015->2016
967  if (m_TESModel == egEnergyCorr::es2016PRE) {
968  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2016PRE", +1)] = SysInfo{always, egEnergyCorr::Scale::LArTemperature2016PreUp};
969  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2016PRE", -1)] = SysInfo{always, egEnergyCorr::Scale::LArTemperature2016PreDown};
970  }
971 
972  //PS correlated barrel uncertainty
973  if (m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE){
974  m_syst_description[CP::SystematicVariation("EG_SCALE_PS_BARREL_B12", +1)] = SysInfo{always, egEnergyCorr::Scale::PSb12Up};
975  m_syst_description[CP::SystematicVariation("EG_SCALE_PS_BARREL_B12", -1)] = SysInfo{always, egEnergyCorr::Scale::PSb12Down};
976  }
977 
978  // topo clustr threshold systematics aded to release 21 recommendations
979  if ( m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE){
980  m_syst_description[CP::SystematicVariation("EG_SCALE_TOPOCLUSTER_THRES",+1)] = SysInfo{always, egEnergyCorr::Scale::topoClusterThresUp};
981  m_syst_description[CP::SystematicVariation("EG_SCALE_TOPOCLUSTER_THRES",-1)] = SysInfo{always, egEnergyCorr::Scale::topoClusterThresDown};
982  }
983 
984  // extra AF2 systematics for release 21 recommendations - Moriond 2018 - pending proper AF2 to FullSim correction with release 21
985  if ( m_TESModel == egEnergyCorr::es2017_R21_v0 || m_TESModel == egEnergyCorr::es2017_R21_v1 || m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 || m_TESModel == egEnergyCorr::es2018_R21_v0 || m_TESModel == egEnergyCorr::es2018_R21_v1 || m_TESModel == egEnergyCorr::es2022_R22_PRE){
986  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2",+1)] = SysInfo{always, egEnergyCorr::Scale::af2Up};
987  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2",-1)] = SysInfo{always, egEnergyCorr::Scale::af2Down};
988  }
989 
990 
991  }
992  else if (m_decorrelation_model_scale == ScaleDecorrelation::ONENP_PLUS_UNCONR) {
993  // qsum of all variations correlated 8/13 TeV + uncorrelated (additional systematics for 2015PRE or 2016)
994  // all the physical effects separately, considered as fully correlated in eta
995  // TODO: fix for es2017
996  #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
997  m_syst_description[CP::SystematicVariation(#name, +1)] = SysInfo{always, flagup}; \
998  m_syst_description[CP::SystematicVariation(#name, -1)] = SysInfo{always, flagdown};
999  #include "ElectronPhotonFourMomentumCorrection/systematics_1NPCOR_PLUS_UNCOR.def"
1000  #undef SYSMACRO
1001 
1002  // additional systematic for S12 last eta bin run2 - not needed anymore for last 20.7 model since it is part of bin per bin E1/E2 uncertainty in root file
1003  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved) {
1004  m_syst_description[CP::SystematicVariation("EG_SCALE_S12EXTRALASTETABINRUN2", +1)] = SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up};
1005  m_syst_description[CP::SystematicVariation("EG_SCALE_S12EXTRALASTETABINRUN2", -1)] = SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down};
1006  }
1007 
1008  }
1009  else if (m_decorrelation_model_scale == ScaleDecorrelation::FULL) {
1010  using pairvector = std::vector<std::pair<double, double>>;
1011  const pairvector decorrelation_bins_BE = {{0., 1.45}, {1.52, 2.5}};
1012  const std::vector<double> decorrelation_edges_TWELVE = {0., 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4};
1013  const std::vector<double> decorrelation_edges_MODULE = {0., 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.37, 1.52, 1.8};
1014  const std::vector<double> decorrelation_edges_MATERIAL = {0.0, 1.1, 1.5, 2.1, 2.5};
1015 
1016  std::vector<double> decorrelation_edges_S12;
1017  // for es2018_R21_v1 : 4 eta bins for muon E1/E2 uncertainty correlation
1018  if (m_TESModel== egEnergyCorr::es2018_R21_v1) {
1019  decorrelation_edges_S12.resize(5);
1020  decorrelation_edges_S12={0.,1.35,1.5,2.4,2.5};
1021  }
1022  // for previous run 2 muon calibration with 20.7, 5 eta bins for E1/E2 uncertainty correlation
1023  else {
1024  decorrelation_edges_S12.resize(6);
1025  decorrelation_edges_S12={0., 0.6, 1.4, 1.5, 2.4, 2.5};
1026  }
1027 
1028  if(m_TESModel != egEnergyCorr::es2017_summer_final and m_TESModel != egEnergyCorr::es2017_R21_v0 and m_TESModel != egEnergyCorr::es2017_R21_v1 and m_TESModel != egEnergyCorr::es2017_R21_ofc0_v1 and m_TESModel != egEnergyCorr::es2018_R21_v0 and m_TESModel != egEnergyCorr::es2018_R21_v1 and m_TESModel != egEnergyCorr::es2022_R22_PRE){
1029  #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
1030  if (bool(fullcorrelated)) { \
1031  m_syst_description[CP::SystematicVariation(#name, +1)] = SysInfo{always, flagup}; \
1032  m_syst_description[CP::SystematicVariation(#name, -1)] = SysInfo{always, flagdown}; \
1033  } \
1034  else { \
1035  int i = 0; \
1036  for (const auto& p : AbsEtaCaloPredicatesFactory(decorrelation)) { \
1037  m_syst_description[CP::SystematicVariation(#name "__ETABIN" + std::to_string(i), +1)] = SysInfo{p, flagup}; \
1038  m_syst_description[CP::SystematicVariation(#name "__ETABIN" + std::to_string(i), -1)] = SysInfo{p, flagdown}; \
1039  i += 1; \
1040  } \
1041  }
1042  #include "ElectronPhotonFourMomentumCorrection/systematics.def"
1043  #undef SYSMACRO
1044  }
1045  else{
1046  #define SYSMACRO(name, fullcorrelated, decorrelation, flagup, flagdown) \
1047  if (bool(fullcorrelated)) { \
1048  m_syst_description[CP::SystematicVariation(#name, +1)] = SysInfo{always, flagup}; \
1049  m_syst_description[CP::SystematicVariation(#name, -1)] = SysInfo{always, flagdown}; \
1050  } \
1051  else { \
1052  int i = 0; \
1053  for (const auto& p : AbsEtaCaloPredicatesFactory(decorrelation)) { \
1054  m_syst_description[CP::SystematicVariation(#name "__ETABIN" + std::to_string(i), +1)] = SysInfo{p, flagup}; \
1055  m_syst_description[CP::SystematicVariation(#name "__ETABIN" + std::to_string(i), -1)] = SysInfo{p, flagdown}; \
1056  i += 1; \
1057  } \
1058  }
1059  #include "ElectronPhotonFourMomentumCorrection/systematics_S12.def"
1060  #undef SYSMACRO
1061  }//else
1062 
1063  if (m_use_full_statistical_error) {
1064  // statistical error, decorrelate in *all* the bins
1065  int i = 0;
1066  const TAxis& axis_statistical_error(m_rootTool->get_ZeeStat_eta_axis());
1067  for (int ibin = 1; ibin <= axis_statistical_error.GetNbins(); ++ibin) {
1068  auto p = AbsEtaCaloPredicateFactory(axis_statistical_error.GetBinLowEdge(ibin),
1069  axis_statistical_error.GetBinLowEdge(ibin + 1));
1070  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT__ETABIN" + std::to_string(i), +1)] = SysInfo{p, egEnergyCorr::Scale::ZeeStatUp};
1071  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT__ETABIN" + std::to_string(i), -1)] = SysInfo{p, egEnergyCorr::Scale::ZeeStatDown};
1072  ++i;
1073  }
1074  }
1075  else {
1076  // return 1 variation only, fully correlated in eta, equal to the correct value
1077  // but scaled by sqrt(number of bins)
1078  // the scaling is done by the old tool
1079  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT", +1)] = SysInfo{always, egEnergyCorr::Scale::ZeeStatUp};
1080  m_syst_description[CP::SystematicVariation("EG_SCALE_ZEESTAT", -1)] = SysInfo{always, egEnergyCorr::Scale::ZeeStatDown};
1081  }
1082 
1083  if (m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1084  m_syst_description[CP::SystematicVariation("EG_SCALE_OFC", +1)] = SysInfo{always, egEnergyCorr::Scale::OFCUp};
1085  m_syst_description[CP::SystematicVariation("EG_SCALE_OFC", -1)] = SysInfo{always, egEnergyCorr::Scale::OFCDown};
1086  m_syst_description[CP::SystematicVariation("EG_SCALE_EXTRARUN3PRE", +1)] = SysInfo{always, egEnergyCorr::Scale::EXTRARUN3PREUp};
1087  m_syst_description[CP::SystematicVariation("EG_SCALE_EXTRARUN3PRE", -1)] = SysInfo{always, egEnergyCorr::Scale::EXTRARUN3PREDown};
1088  }
1089 
1090  // additional systematics for S12 run2
1091  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or m_TESModel == egEnergyCorr::es2015PRE or
1092  m_TESModel == egEnergyCorr::es2015cPRE or m_TESModel == egEnergyCorr::es2015c_summer or
1093  m_TESModel == egEnergyCorr::es2016PRE or m_TESModel == egEnergyCorr::es2017
1094  or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved
1095  or m_TESModel == egEnergyCorr::es2015_5TeV) {
1096  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN0", +1)] = SysInfo{AbsEtaCaloPredicateFactory({0, 1.45}), egEnergyCorr::Scale::LArCalibExtra2015PreUp};
1097  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN0", -1)] = SysInfo{AbsEtaCaloPredicateFactory({0, 1.45}), egEnergyCorr::Scale::LArCalibExtra2015PreDown};
1098  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN1", +1)] = SysInfo{AbsEtaCaloPredicateFactory({1.45, 2.47}), egEnergyCorr::Scale::LArCalibExtra2015PreUp};
1099  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN1", -1)] = SysInfo{AbsEtaCaloPredicateFactory({1.45, 2.47}), egEnergyCorr::Scale::LArCalibExtra2015PreDown};
1100  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN2", +1)] = SysInfo{AbsEtaCaloPredicateFactory({2.47, 3.2}), egEnergyCorr::Scale::LArCalibExtra2015PreUp};
1101  m_syst_description[CP::SystematicVariation("EG_SCALE_LARCALIB_EXTRA2015PRE__ETABIN2", -1)] = SysInfo{AbsEtaCaloPredicateFactory({2.47, 3.2}), egEnergyCorr::Scale::LArCalibExtra2015PreDown};
1102  }
1103 
1104  // additional systematics for temperature run1->run2
1105  if (m_TESModel == egEnergyCorr::es2015PRE_res_improved or m_TESModel == egEnergyCorr::es2015PRE or
1106  m_TESModel == egEnergyCorr::es2015cPRE or m_TESModel == egEnergyCorr::es2015c_summer or
1107  m_TESModel == egEnergyCorr::es2016PRE) {
1108  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN0", +1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]), egEnergyCorr::Scale::LArTemperature2015PreUp};
1109  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN0", -1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]), egEnergyCorr::Scale::LArTemperature2015PreDown};
1110  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN1", +1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]), egEnergyCorr::Scale::LArTemperature2015PreUp};
1111  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2015PRE__ETABIN1", -1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]), egEnergyCorr::Scale::LArTemperature2015PreDown};
1112  }
1113 
1114  // additional systematic for S12 last eta bin run2
1115  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2015_5TeV) {
1116  m_syst_description[CP::SystematicVariation("EG_SCALE_S12EXTRALASTETABINRUN2", +1)] = SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up};
1117  m_syst_description[CP::SystematicVariation("EG_SCALE_S12EXTRALASTETABINRUN2", -1)] = SysInfo{always, egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down};
1118  }
1119 
1120  // additional systematic for PP0 region
1121  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2015_5TeV or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1122  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN0", +1)] = SysInfo{AbsEtaCaloPredicateFactory(0, 1.5), egEnergyCorr::Scale::MatPP0Up};
1123  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN1", +1)] = SysInfo{AbsEtaCaloPredicateFactory(1.5, 2.5), egEnergyCorr::Scale::MatPP0Up};
1124  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN0", -1)] = SysInfo{AbsEtaCaloPredicateFactory(0, 1.5), egEnergyCorr::Scale::MatPP0Down};
1125  m_syst_description[CP::SystematicVariation("EG_SCALE_MATPP0__ETABIN1", -1)] = SysInfo{AbsEtaCaloPredicateFactory(1.5, 2.5), egEnergyCorr::Scale::MatPP0Down};
1126  }
1127 
1128  // systematic related to wtots1
1129  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2015_5TeV or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1130  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", +1)] = SysInfo{always, egEnergyCorr::Scale::Wtots1Up};
1131  m_syst_description[CP::SystematicVariation("EG_SCALE_WTOTS1", -1)] = SysInfo{always, egEnergyCorr::Scale::Wtots1Down};
1132  }
1133 
1134  // systematic for the scintillators
1135  if (m_TESModel == egEnergyCorr::es2015cPRE or m_TESModel == egEnergyCorr::es2015c_summer or m_TESModel == egEnergyCorr::es2016PRE or m_TESModel == egEnergyCorr::es2017
1136  or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2015_5TeV or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1137  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR__ETABIN0", +1)] = SysInfo{AbsEtaCaloPredicateFactory(1.4, 1.46), egEnergyCorr::Scale::E4ScintillatorUp};
1138  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR__ETABIN1", +1)] = SysInfo{AbsEtaCaloPredicateFactory(1.46, 1.52), egEnergyCorr::Scale::E4ScintillatorUp};
1139  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR__ETABIN2", +1)] = SysInfo{AbsEtaCaloPredicateFactory(1.52, 1.6), egEnergyCorr::Scale::E4ScintillatorUp};
1140  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR__ETABIN0", -1)] = SysInfo{AbsEtaCaloPredicateFactory(1.4, 1.46), egEnergyCorr::Scale::E4ScintillatorDown};
1141  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR__ETABIN1", -1)] = SysInfo{AbsEtaCaloPredicateFactory(1.46, 1.52), egEnergyCorr::Scale::E4ScintillatorDown};
1142  m_syst_description[CP::SystematicVariation("EG_SCALE_E4SCINTILLATOR__ETABIN2", -1)] = SysInfo{AbsEtaCaloPredicateFactory(1.52, 1.6), egEnergyCorr::Scale::E4ScintillatorDown};
1143 
1144  }
1145 
1146  // additional systematic for temperature 2015->2016
1147  if (m_TESModel == egEnergyCorr::es2016PRE) {
1148  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN0", +1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]), egEnergyCorr::Scale::LArTemperature2016PreUp};
1149  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN1", +1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]), egEnergyCorr::Scale::LArTemperature2016PreUp};
1150  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN0", -1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[0]), egEnergyCorr::Scale::LArTemperature2016PreDown};
1151  m_syst_description[CP::SystematicVariation("EG_SCALE_LARTEMPERATURE_EXTRA2016PRE__ETABIN1", -1)] = SysInfo{AbsEtaCaloPredicateFactory(decorrelation_bins_BE[1]), egEnergyCorr::Scale::LArTemperature2016PreDown};
1152  }
1153 
1154  //PS correlated barrel uncertainty
1155  if (m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE){
1156  m_syst_description[CP::SystematicVariation("EG_SCALE_PS_BARREL_B12", +1)] = SysInfo{always, egEnergyCorr::Scale::PSb12Up};
1157  m_syst_description[CP::SystematicVariation("EG_SCALE_PS_BARREL_B12", -1)] = SysInfo{always, egEnergyCorr::Scale::PSb12Down};
1158  }
1159 
1160  // topo clustr threshold systematics aded to release 21 recommendations
1161  if ( m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE){
1162  m_syst_description[CP::SystematicVariation("EG_SCALE_TOPOCLUSTER_THRES",+1)] = SysInfo{always, egEnergyCorr::Scale::topoClusterThresUp};
1163  m_syst_description[CP::SystematicVariation("EG_SCALE_TOPOCLUSTER_THRES",-1)] = SysInfo{always, egEnergyCorr::Scale::topoClusterThresDown};
1164  }
1165 
1166  // extra AF2 systematics for release 21 recommendations - Moriond 2018 - pending proper AF2 to FullSim correction with release 21
1167  if ( m_TESModel == egEnergyCorr::es2017_R21_v0 || m_TESModel == egEnergyCorr::es2017_R21_v1 || m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 || m_TESModel == egEnergyCorr::es2018_R21_v0 || m_TESModel == egEnergyCorr::es2018_R21_v1 || m_TESModel == egEnergyCorr::es2022_R22_PRE){
1168  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2",+1)] = SysInfo{always, egEnergyCorr::Scale::af2Up};
1169  m_syst_description[CP::SystematicVariation("EG_SCALE_AF2",-1)] = SysInfo{always, egEnergyCorr::Scale::af2Down};
1170  }
1171 
1172 
1173 
1174  }
1175  else {
1176  ATH_MSG_FATAL("scale decorrelation model invalid");
1177  }
1178 
1179  // resolution systematics
1180  if (m_decorrelation_model_resolution == ResolutionDecorrelation::ONENP) {
1181  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_ALL", +1)] = egEnergyCorr::Resolution::AllUp;
1182  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_ALL", -1)] = egEnergyCorr::Resolution::AllDown;
1183  }
1184  else if (m_decorrelation_model_resolution == ResolutionDecorrelation::FULL){
1185  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_ZSMEARING", +1)] = egEnergyCorr::Resolution::ZSmearingUp;
1186  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_ZSMEARING", -1)] = egEnergyCorr::Resolution::ZSmearingDown;
1187  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_SAMPLINGTERM", +1)] = egEnergyCorr::Resolution::SamplingTermUp;
1188  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_SAMPLINGTERM", -1)] = egEnergyCorr::Resolution::SamplingTermDown;
1189  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALID", +1)] = egEnergyCorr::Resolution::MaterialIDUp;
1190  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALID", -1)] = egEnergyCorr::Resolution::MaterialIDDown;
1191  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALCALO", +1)] = egEnergyCorr::Resolution::MaterialCaloUp;
1192  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALCALO", -1)] = egEnergyCorr::Resolution::MaterialCaloDown;
1193  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALGAP", +1)] = egEnergyCorr::Resolution::MaterialGapUp;
1194  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALGAP", -1)] = egEnergyCorr::Resolution::MaterialGapDown;
1195  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALCRYO", +1)] = egEnergyCorr::Resolution::MaterialCryoUp;
1196  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALCRYO", -1)] = egEnergyCorr::Resolution::MaterialCryoDown;
1197  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_PILEUP", +1)] = egEnergyCorr::Resolution::PileUpUp;
1198  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_PILEUP", -1)] = egEnergyCorr::Resolution::PileUpDown;
1199  if (m_TESModel == egEnergyCorr::es2017 or m_TESModel == egEnergyCorr::es2017_summer or m_TESModel == egEnergyCorr::es2017_summer_improved or m_TESModel == egEnergyCorr::es2017_summer_final or m_TESModel == egEnergyCorr::es2015_5TeV or m_TESModel == egEnergyCorr::es2017_R21_v0 or m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 or m_TESModel == egEnergyCorr::es2018_R21_v0 or m_TESModel == egEnergyCorr::es2018_R21_v1 or m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1200  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALIBL", +1)] = egEnergyCorr::Resolution::MaterialIBLUp;
1201  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALIBL", -1)] = egEnergyCorr::Resolution::MaterialIBLDown;
1202  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALPP0", +1)] = egEnergyCorr::Resolution::MaterialPP0Up;
1203  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_MATERIALPP0", -1)] = egEnergyCorr::Resolution::MaterialPP0Down;
1204  if (m_TESModel == egEnergyCorr::es2017_R21_v1 || m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 || m_TESModel == egEnergyCorr::es2018_R21_v0 || m_TESModel == egEnergyCorr::es2018_R21_v1 || m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1205  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_AF2", +1)] = egEnergyCorr::Resolution::af2Up;
1206  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_AF2", -1)] = egEnergyCorr::Resolution::af2Down;
1207  }
1208  if(m_TESModel == egEnergyCorr::es2022_R22_PRE) { //exta sys. for Run-3 pre-recommendations
1209  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_OFC", +1)] = egEnergyCorr::Resolution::OFCUp;
1210  m_syst_description_resolution[CP::SystematicVariation("EG_RESOLUTION_OFC", -1)] = egEnergyCorr::Resolution::OFCDown;
1211  }
1212  }
1213  }
1214  else {
1215  ATH_MSG_FATAL("resolution decorrelation model invalid");
1216  }
1217 
1218  // ep combination systematics
1219  if (m_use_ep_combination) {
1220  m_syst_description[CP::SystematicVariation("EL_SCALE_MOMENTUM", +1)] = SysInfo{always, egEnergyCorr::Scale::MomentumUp};
1221  m_syst_description[CP::SystematicVariation("EL_SCALE_MOMENTUM", -1)] = SysInfo{always, egEnergyCorr::Scale::MomentumDown};
1222  }
1223 }
1224 
1225 CP::SystematicSet EgammaCalibrationAndSmearingTool::recommendedSystematics() const {
1226  return affectingSystematics();
1227 }
1228 
1229 StatusCode EgammaCalibrationAndSmearingTool::applySystematicVariation(const CP::SystematicSet& systConfig) {
1230 
1231  // set the nominal one (no systematics)
1232  m_currentScaleVariation_MC = egEnergyCorr::Scale::None;
1233  m_currentScaleVariation_data = m_doScaleCorrection ? egEnergyCorr::Scale::Nominal : egEnergyCorr::Scale::None;
1234  m_currentResolutionVariation_MC = m_doSmearing ? egEnergyCorr::Resolution::Nominal : egEnergyCorr::Resolution::None;
1235  m_currentResolutionVariation_data = egEnergyCorr::Resolution::None;
1236  m_currentScalePredicate = [](const xAOD::Egamma&) { return true; };
1237 
1238  if (systConfig.empty()) return StatusCode::SUCCESS;
1239 
1240  // the following code allows only ONE systematic variation at a time (1 for scale, 1 for resolution)
1241 
1242  bool first_scale = true;
1243  bool first_resolution = true;
1244  for (const auto& it : systConfig) {
1245  const auto found_scale = m_syst_description.find(it);
1246  if (found_scale != m_syst_description.end()) {
1247  if (not first_scale) {
1248  ATH_MSG_ERROR("multiple scale variations not supported");
1249  throw std::runtime_error("multiple scale variations not supported");
1250  }
1251  first_scale = false;
1252  m_currentScaleVariation_MC = found_scale->second.effect;
1253  m_currentScalePredicate = found_scale->second.predicate;
1254  }
1255 
1256  const auto found_resolution = m_syst_description_resolution.find(it);
1257  if (found_resolution != m_syst_description_resolution.end()) {
1258  if (not first_resolution) {
1259  ATH_MSG_ERROR("multiple resolution variations not supported");
1260  throw std::runtime_error("multiple resolution variations not supported");
1261  }
1262  first_resolution = false;
1263  m_currentResolutionVariation_MC = found_resolution->second;
1264  }
1265  }
1266 
1267  return StatusCode::SUCCESS;
1268 }
1269 
1270 double EgammaCalibrationAndSmearingTool::intermodule_correction(double Ecl, double phi, double eta) const
1271 {
1272 
1273  //Intermodule Widening Correction: E_corr = E / (a' - b' * ((1 / (1 + exp((phi_mod - 2 * pi / 32) * c))) * (1 / (1 + exp((phi_mod - 2 * pi / 32) * (d))))))
1274  //(phi_min, phi_max) : [a' = a / a, b' = b / a, c, d]
1275 
1276  double Ecl_corr = 0.;
1277  int DivInt = 0;
1278  double pi = M_PI ;
1279 
1280  if ( m_TESModel == egEnergyCorr::es2017_summer_improved || m_TESModel == egEnergyCorr::es2017_summer_final || m_TESModel == egEnergyCorr::es2017_R21_v0 || m_TESModel == egEnergyCorr::es2017_R21_v1 || m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 || m_TESModel == egEnergyCorr::es2018_R21_v0 || m_TESModel == egEnergyCorr::es2018_R21_v1 || m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1281 
1282  double phi_mod = 0;
1283  if (phi < 0)
1284  phi_mod = fmod(phi, 2 * pi / 16.) + pi / 8.;
1285  else
1286  phi_mod = fmod(phi, 2 * pi / 16.);
1287 
1288  // The correction concerns only the barrel
1289  if(std::abs(eta) <= 1.37){
1290 
1291  if(phi< (-7 * pi / 8) && phi> (-1 * pi))
1292  Ecl_corr = Ecl / (1-0.1086 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 175.2759))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-189.3612))))));
1293  if(phi< (-6 * pi / 8) && phi> (-7 * pi / 8))
1294  Ecl_corr = Ecl / (1-0.0596 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 170.8305))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-233.3782))))));
1295  if(phi< (-5 * pi / 8) && phi> (-6 * pi / 8))
1296  Ecl_corr = Ecl / (1-0.0596 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 147.1451))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-139.3386))))));
1297  if(phi< (-4 * pi / 8) && phi> (-5 * pi / 8))
1298  Ecl_corr = Ecl / (1-0.0583 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 168.4644))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-246.2897))))));
1299  if(phi< (-3 * pi / 8) && phi> (-4 * pi / 8))
1300  Ecl_corr = Ecl / (1-0.0530 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 177.6703))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-198.3227))))));
1301  if(phi< (-2 * pi / 8) && phi> (-3 * pi / 8))
1302  Ecl_corr = Ecl / (1-0.0672 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 145.0693))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-242.1771))))));
1303  if(phi< (-1 * pi / 8) && phi> (-2 * pi / 8))
1304  Ecl_corr = Ecl / (1-0.0871 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 132.3303))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-166.1833))))));
1305  if(phi< (0 * pi / 8) && phi> (-1 * pi / 8))
1306  Ecl_corr = Ecl / (1-0.0948 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 127.6780))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-150.0700))))));
1307  if(phi< (1 * pi / 8) && phi> (0 * pi / 8))
1308  Ecl_corr = Ecl / (1-0.1166 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 172.0679))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-235.3293))))));
1309  if(phi< (2 * pi / 8) && phi> (1 * pi / 8))
1310  Ecl_corr = Ecl / (1-0.1172 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 190.3524))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-198.9400))))));
1311  if(phi< (3 * pi / 8) && phi> (2 * pi / 8))
1312  Ecl_corr = Ecl / (1-0.1292 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 158.0540))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-165.3893))))));
1313  if(phi< (4 * pi / 8) && phi> (3 * pi / 8))
1314  Ecl_corr = Ecl / (1-0.1557 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 162.2793))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-133.5131))))));
1315  if(phi< (5 * pi / 8) && phi> (4 * pi / 8))
1316  Ecl_corr = Ecl / (1-0.1659 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 180.5270))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-168.5074))))));
1317  if(phi< (6 * pi / 8) && phi> (5 * pi / 8))
1318  Ecl_corr = Ecl / (1-0.1123 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 128.2277))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-154.4455))))));
1319  if(phi< (7 * pi / 8) && phi> (6 * pi / 8))
1320  Ecl_corr = Ecl / (1-0.1394 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 192.1216))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-198.0727))))));
1321  if(phi< (8 * pi / 8) && phi> (7 * pi / 8))
1322  Ecl_corr = Ecl / (1-0.1001 * ((1 / (1 + exp((phi_mod- 2*pi/32.) * 199.1735))) * (1 / (1 + exp((phi_mod- 2*pi/32.) * (-176.4056))))));
1323  }
1324 
1325 
1326  // No correction for the EC
1327  else{
1328  Ecl_corr = Ecl;
1329  }
1330 
1331  }
1332 
1333  else {
1334 
1335  // Definitions of module folding into four quarters (top, left, bottom and right)
1336 
1337  DivInt = (int) (phi / ((2 * pi) / 16.));
1338  double phi_mod = phi - DivInt * (2 * pi / 16.);
1339 
1340 
1341  // Centring on the intermodule --> phi_mod will now be in [0,0.4]
1342  if (phi_mod < 0) phi_mod += pi / 8.;
1343 
1344  // The correction concerns only the barrel
1345  if(std::abs(eta) <= 1.4){
1346 
1347  // Top quarter
1348  if(phi < (3 * pi) / 4. && phi >= pi / 4.){
1349  Ecl_corr = Ecl / (1-0.131 * ((1 / (1 + exp((phi_mod-0.2) * 199.08))) * (1 / (1 + exp((phi_mod-0.2) * (-130.36))))));
1350  }
1351 
1352  // Right quarter
1353  if(phi < pi / 4. && phi >= -pi / 4.){
1354  Ecl_corr = Ecl / (1-0.0879 * ((1 / (1 + exp((phi_mod-0.2) * 221.01))) * (1 / (1 + exp((phi_mod-0.2) * (-149.51))))));
1355  }
1356  // Bottom quarter
1357  if(phi < -pi / 4. && phi >= (-3 * pi) / 4.){
1358  Ecl_corr = Ecl / (1-0.0605 * ((1 / (1 + exp((phi_mod-0.2) * 281.37))) * (1 / (1 + exp((phi_mod-0.2) * (-170.29))))));
1359  }
1360  // Left quarter
1361  if((phi < (-3 * pi) / 4.) || (phi >= (3 * pi) / 4.)){
1362  Ecl_corr = Ecl / (1-0.102 * ((1 / (1 + exp((phi_mod-0.2) * 235.37))) * (1 / (1 + exp((phi_mod-0.2) * (-219.04))))));
1363  }
1364  }
1365 
1366  // No correction for the EC
1367  else{
1368  Ecl_corr = Ecl;
1369  }
1370  }
1371 
1372  return Ecl_corr;
1373 
1374 }
1375 
1376 double EgammaCalibrationAndSmearingTool::correction_phi_unif(double eta, double phi) const
1377 {
1378  constexpr double PI = M_PI;
1379  double Fcorr = 1.0;
1380 
1381  if (m_use_mapping_correction) {
1382  // wrong mapping HV -> sectors in run1
1383  if (eta < -0.4 && eta > -0.6) {
1384  if (phi < (14 * PI / 32.) && phi > (13 * PI / 32.)) { Fcorr += 0.035; }
1385  else if (phi < (13 * PI / 32.) && phi > (12 * PI / 32.)) { Fcorr -= 0.035; }
1386  }
1387  }
1388 
1389  if ( m_TESModel == egEnergyCorr::es2017_summer_improved || m_TESModel == egEnergyCorr::es2017_summer_final || m_TESModel == egEnergyCorr::es2017_R21_v0 || m_TESModel == egEnergyCorr::es2017_R21_v1 or m_TESModel == egEnergyCorr::es2017_R21_ofc0_v1 || m_TESModel == egEnergyCorr::es2018_R21_v0 || m_TESModel == egEnergyCorr::es2018_R21_v1 || m_TESModel == egEnergyCorr::es2022_R22_PRE) {
1390 
1391  if(eta < 0.2 && eta > 0.) {
1392  if (phi < (-7 * 2 * PI / 32.) && phi > (-8 * 2 * PI / 32.)) { Fcorr = 1.016314; }
1393  }
1394 
1395  else if (eta < 0.6 && eta > 0.4) {
1396  if (phi < 0 && phi > (-2 * PI / 32.)) { Fcorr = 1.041591; }
1397  else if (phi < (-4 * 2 * PI / 32.) && phi > (-5 * 2 * PI / 32.)) { Fcorr = 1.067346; }
1398  }
1399 
1400  else if (eta < 0.8 && eta > 0.6) {
1401  if (phi < (7 * 2 * PI / 32.) && phi > (6 * 2 * PI / 32.)) { Fcorr = 1.027980; }
1402  }
1403 
1404  else if (eta < 1.4 && eta > 1.2) {
1405  if (phi < (-9 * 2 * PI / 32.) && phi > (-10 * 2 * PI / 32.)) { Fcorr = 1.020299; }
1406  else if (phi < (-11 * 2 * PI / 32.) && phi > (-12 * 2 * PI / 32.)) { Fcorr = 1.051426; }
1407  }
1408 
1409  else if (eta < 2.3 && eta > 2.1) {
1410  if (phi < (-12 * 2 * PI / 32.) && phi > (-13 * 2 * PI / 32.)) { Fcorr = 1.071695; }
1411  }
1412 
1413  else if(eta < 0. && eta > -0.2) {
1414  if (phi < (-12 * 2 * PI / 32.) && phi > (-13 * 2 * PI / 32.)) { Fcorr = 1.008227; }
1415  else if (phi < (-8 * 2 * PI / 32.) && phi > (-9 * 2 * PI / 32.)) { Fcorr = 1.013929; }
1416  }
1417 
1418  else if(eta < -0.2 && eta > -0.4) {
1419  if (phi < (-9 * 2 * PI / 32.) && phi > (-10 * 2 * PI / 32.)) { Fcorr = 1.015749; }
1420  }
1421 
1422  else if(eta < -1.2 && eta > -1.4) {
1423  if (phi < (-6 * 2 * PI / 32.) && phi > (-7 * 2 * PI / 32.)) { Fcorr = 1.064954; }
1424  }
1425 
1426  else if (eta < -1.6 && eta > -1.8 ) {
1427  if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) { Fcorr = 1.027448; }
1428  }
1429 
1430  else if(eta < -2.3 && eta > -2.5) {
1431  if (phi < (-8 * 2 * PI / 32.) && phi > (-9 * 2 * PI / 32.)) { Fcorr = 1.025882; }
1432  else if (phi < (5 * 2 * PI / 32.) && phi > (4 * 2 * PI / 32.)) { Fcorr = 1.036616; }
1433  else if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) { Fcorr = 1.053838; }
1434  else if (phi < (10 * 2 * PI / 32.) && phi > (9 * 2 * PI / 32.)) { Fcorr = 1.026856; }
1435  else if (phi < (11 * 2 * PI / 32.) && phi > (10 * 2 * PI / 32.)) { Fcorr = 0.994382; }
1436  }
1437 
1438  } // es2017_summer_improved end
1439 
1440  else{
1441  if (eta < 0.6 && eta > 0.4) {
1442  if (phi < 0 && phi > (-2 * PI / 32.)) { Fcorr = 1.028; }
1443  else if (phi < (-4 * 2 * PI / 32.) && phi > (-5 * 2 * PI / 32.)) { Fcorr = 1.044; }
1444  }
1445 
1446  else if (eta < 0.8 && eta > 0.6) {
1447  if (phi < (7 * 2 * PI / 32.) && phi > (6 * 2 * PI / 32.)) { Fcorr = 1.022; }
1448  }
1449 
1450  else if (eta < 1.4 && eta > 1.2) {
1451  if (phi < (-11 * 2 * PI / 32.) && phi > (-12 * 2 * PI / 32.)) { Fcorr = 1.038; }
1452  }
1453 
1454  else if (eta < 2.0 && eta > 1.9 ) {
1455  if (phi < (10 * 2 * PI / 32.) && phi > (9 * 2 * PI / 32.)) { Fcorr = 1.029; }
1456  }
1457 
1458  else if(eta < -1.2 && eta > -1.4) {
1459  if (phi < (-4 * 2 * PI / 32.) && phi > (-5 * 2 * PI / 32.)) { Fcorr = 1.048; }
1460  else if (phi < (-6 * 2 * PI / 32.) && phi > (-7 * 2 * PI / 32.)) { Fcorr = 1.048; }
1461  }
1462 
1463  else if (eta < -1.6 && eta > -1.8 ) {
1464  if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) { Fcorr = 1.024; }
1465  }
1466 
1467  else if(eta < -2.3 && eta > -2.5) {
1468  if (phi < (-8 * 2 * PI / 32.) && phi > (-9 * 2 * PI / 32.)) { Fcorr = 1.037; }
1469  else if (phi < (5 * 2 * PI / 32.) && phi > (4 * 2 * PI / 32.)) { Fcorr = 1.031; }
1470  else if (phi < (9 * 2 * PI / 32.) && phi > (8 * 2 * PI / 32.)) { Fcorr = 1.040; }
1471  else if (phi < (10 * 2 * PI / 32.) && phi > (9 * 2 * PI / 32.)) { Fcorr = 1.030; }
1472  else if (phi < (11 * 2 * PI / 32.) && phi > (10 * 2 * PI / 32.)) { Fcorr = 1.020; }
1473  }
1474  }
1475 
1476  return Fcorr;
1477 }
1478 
1479 } // namespace CP
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
python.Dso.registry
registry
Definition: Control/AthenaServices/python/Dso.py:159
CP::EgammaCalibrationAndSmearingTool::m_useFastSim
int m_useFastSim
Definition: EgammaCalibrationAndSmearingTool.h:142
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TrackParticle_v1.cxx:73
egEnergyCorr::Resolution::MaterialPP0Up
@ MaterialPP0Up
Definition: egammaEnergyCorrectionTool.h:83
CP::EgammaCalibrationAndSmearingTool::ScaleDecorrelation::ONENP
@ ONENP
egEnergyCorr::Scale::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:188
xAOD::EgammaHelpers::energyInMissingCells
unsigned short energyInMissingCells(const xAOD::Egamma &eg, double &e2, double &e3)
Get the energies in sampling 2 and 3 that are in cells rejected by the topo-cluster timing cut but th...
Definition: EgammaxAODHelpers.cxx:177
PATCore::ParticleType::UnconvertedPhoton
@ UnconvertedPhoton
Definition: PATCoreEnums.h:38
CP::EgammaCalibrationAndSmearingTool::getElectronMomentum
virtual double getElectronMomentum(const xAOD::Electron *, const xAOD::EventInfo *)
Definition: EgammaCalibrationAndSmearingTool.cxx:855
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:210
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
egEnergyCorr::Scale::LArCalibExtra2015PreDown
@ LArCalibExtra2015PreDown
Definition: egammaEnergyCorrectionTool.h:137
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17
xAOD::EgammaParameters::convertedPhoton
@ convertedPhoton
Definition: EgammaEnums.h:20
CP::EgammaCalibrationAndSmearingTool::isAffectedBySystematic
virtual bool isAffectedBySystematic(const CP::SystematicVariation &systematic) const override
Declare the interface that this class provides.
Definition: EgammaCalibrationAndSmearingTool.cxx:873
CP::EgammaCalibrationAndSmearingTool::ScaleDecorrelation::FULL
@ FULL
python.SystemOfUnits.m2
int m2
Definition: SystemOfUnits.py:92
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
egEnergyCorr::es2011d
@ es2011d
Definition: egammaEnergyCorrectionTool.h:212
CP::EgammaCalibrationAndSmearingTool::affectingSystematics
virtual CP::SystematicSet affectingSystematics() const override
the list of all systematics this tool can be affected by
Definition: EgammaCalibrationAndSmearingTool.cxx:878
egEnergyCorr::Scale::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:188
CP::EgammaCalibrationAndSmearingTool::m_ResolutionType
std::string m_ResolutionType
Definition: EgammaCalibrationAndSmearingTool.h:140
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
vtune_athena.format
format
Definition: vtune_athena.py:14
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
PATCore::ParticleType::Type
Type
Definition: PATCoreEnums.h:35
CP::EgammaCalibrationAndSmearingTool::EgammaCalibrationAndSmearingTool
EgammaCalibrationAndSmearingTool(const std::string &name)
Definition: EgammaCalibrationAndSmearingTool.cxx:266
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
CP::egammaLayerRecalibToolFactory
std::unique_ptr< egammaLayerRecalibTool > egammaLayerRecalibToolFactory(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:130
egEnergyCorr::Scale::LArTemperature2016PreUp
@ LArTemperature2016PreUp
Definition: egammaEnergyCorrectionTool.h:141
CP::EgammaCalibrationAndSmearingTool::m_use_ep_combination
bool m_use_ep_combination
Definition: EgammaCalibrationAndSmearingTool.h:153
CP::EgammaCalibrationAndSmearingTool::recommendedSystematics
virtual CP::SystematicSet recommendedSystematics() const override
the list of all systematics this tool recommends to use
Definition: EgammaCalibrationAndSmearingTool.cxx:1225
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
egEnergyCorr::Resolution::ZSmearingUp
@ ZSmearingUp
Definition: egammaEnergyCorrectionTool.h:71
egEnergyCorr::Scale::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:193
Egamma
Definition: ClusMomentumPlots.cxx:11
CP::EgammaCalibrationAndSmearingTool::getResolution
double getResolution(const xAOD::Egamma &particle, bool withCT=true) const override
Definition: EgammaCalibrationAndSmearingTool.cxx:607
xAOD::Egamma_v1::e
virtual double e() const override final
The total energy of the particle.
Definition: Egamma_v1.cxx:90
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TrackParticle_v1.cxx:77
NNPDF30NNLO.tune
tune
Definition: GeneratorFilters/share/common/NNPDF30NNLO.py:1
egEnergyCorr::Resolution::SigmaEff90
@ SigmaEff90
Definition: egammaEnergyCorrectionTool.h:103
CP::SystematicSet::empty
bool empty() const
returns: whether the set is empty
Definition: SystematicSet.h:67
egEnergyCorr::Scale::LArTemperature2015PreDown
@ LArTemperature2015PreDown
Definition: egammaEnergyCorrectionTool.h:138
PATCore::ParticleDataType::Fast
@ Fast
Definition: PATCoreEnums.h:22
egEnergyCorr::es2012cMedium
@ es2012cMedium
Definition: egammaEnergyCorrectionTool.h:219
CP::EgammaCalibrationAndSmearingTool::m_currentScaleVariation_data
egEnergyCorr::Scale::Variation m_currentScaleVariation_data
Definition: EgammaCalibrationAndSmearingTool.h:251
egEnergyCorr::es2017_R21_v1
@ es2017_R21_v1
Definition: egammaEnergyCorrectionTool.h:240
CP::EgammaCalibrationAndSmearingTool::ResolutionDecorrelation::ONENP
@ ONENP
CP::EgammaCalibrationAndSmearingTool::correctedCopy
virtual CP::CorrectionCode correctedCopy(const xAOD::Electron &, xAOD::Electron *&) const override
Definition: EgammaCalibrationAndSmearingTool.cxx:637
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_name
std::string m_decorrelation_model_name
Definition: EgammaCalibrationAndSmearingTool.h:131
egEnergyCorr::Scale::MatPP0Down
@ MatPP0Down
Definition: egammaEnergyCorrectionTool.h:174
skel.it
it
Definition: skel.GENtoEVGEN.py:423
CP::use_intermodule_correction
bool use_intermodule_correction(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:177
egEnergyCorr::es2015PRE_res_improved
@ es2015PRE_res_improved
Definition: egammaEnergyCorrectionTool.h:225
asg
Definition: DataHandleTestTool.h:28
egEnergyCorr::Resolution::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:86
CP::EgammaCalibrationAndSmearingTool::m_currentScalePredicate
EgammaPredicate m_currentScalePredicate
Definition: EgammaCalibrationAndSmearingTool.h:255
CP::SystematicSet
Class to wrap a set of SystematicVariations.
Definition: SystematicSet.h:31
M_PI
#define M_PI
Definition: ActiveFraction.h:11
egammaEnergyCorrectionTool.h
egEnergyCorr::Scale::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:119
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
egEnergyCorr::Resolution::Gaussian
@ Gaussian
Definition: egammaEnergyCorrectionTool.h:99
CP::EgammaCalibrationAndSmearingTool::m_gain_tool
egGain::GainTool * m_gain_tool
Definition: EgammaCalibrationAndSmearingTool.h:233
CP::EgammaCalibrationAndSmearingTool::m_doScaleCorrection
int m_doScaleCorrection
Definition: EgammaCalibrationAndSmearingTool.h:137
egEnergyCorr::Scale::EXTRARUN3PREDown
@ EXTRARUN3PREDown
Definition: egammaEnergyCorrectionTool.h:191
CP::EgammaCalibrationAndSmearingTool::~EgammaCalibrationAndSmearingTool
~EgammaCalibrationAndSmearingTool()
Definition: EgammaCalibrationAndSmearingTool.cxx:309
egEnergyCorr::Scale::ZeeStatUp
@ ZeeStatUp
Definition: egammaEnergyCorrectionTool.h:131
PI
const float PI
Definition: test_isolaitonTool.cxx:61
xAOD
ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.
Definition: ICaloAffectedTool.h:24
egEnergyCorr::es2011dMedium
@ es2011dMedium
Definition: egammaEnergyCorrectionTool.h:213
CP::EgammaCalibrationAndSmearingTool::m_simulation
PATCore::ParticleDataType::DataType m_simulation
Definition: EgammaCalibrationAndSmearingTool.h:144
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
CP::egammaMVAToolFolder
std::string egammaMVAToolFolder(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:83
SG::ConstAccessor< double >
egammaLayerRecalibTool::applyCorrection
CP::CorrectionCode applyCorrection(xAOD::Egamma &, const xAOD::EventInfo &event_info) const
Definition: egammaLayerRecalibTool.cxx:910
CP::EgammaCalibrationAndSmearingTool::m_use_mva_calibration
int m_use_mva_calibration
Definition: EgammaCalibrationAndSmearingTool.h:154
egEnergyCorr::Scale::Wtots1Up
@ Wtots1Up
Definition: egammaEnergyCorrectionTool.h:171
CP::EgammaCalibrationAndSmearingTool::RandomNumber
unsigned int RandomNumber
Definition: EgammaCalibrationAndSmearingTool.h:90
CP::EgammaCalibrationAndSmearingTool::m_use_temp_correction201215
int m_use_temp_correction201215
Definition: EgammaCalibrationAndSmearingTool.h:156
CP::EgammaCalibrationAndSmearingTool::getEnergy
double getEnergy(const xAOD::Photon &) const
Definition: EgammaCalibrationAndSmearingTool.cxx:657
xAOD::EgammaParameters::AuthorFwdElectron
const uint16_t AuthorFwdElectron
Electron reconstructed by the Forward cluster-based algorithm.
Definition: EgammaDefs.h:30
egEnergyCorr::ESModel
ESModel
Definition: egammaEnergyCorrectionTool.h:206
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:562
CP::SystematicVariation
Definition: SystematicVariation.h:47
CP::EgammaCalibrationAndSmearingTool::m_useGainCorrection
int m_useGainCorrection
Definition: EgammaCalibrationAndSmearingTool.h:152
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_scale_name
std::string m_decorrelation_model_scale_name
Definition: EgammaCalibrationAndSmearingTool.h:132
xAOD::EventInfo_v1::IS_SIMULATION
@ IS_SIMULATION
true: simulation, false: data
Definition: EventInfo_v1.h:151
egEnergyCorr::Resolution::PileUpUp
@ PileUpUp
Definition: egammaEnergyCorrectionTool.h:80
CP
Select isolated Photons, Electrons and Muons.
Definition: Control/xAODRootAccess/xAODRootAccess/TEvent.h:48
PATCore::ParticleDataType::Data
@ Data
Definition: PATCoreEnums.h:22
mapkey::sys
@ sys
Definition: TElectronEfficiencyCorrectionTool.cxx:42
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
pi
#define pi
Definition: TileMuonFitter.cxx:65
PATCore::ParticleDataType::DataType
DataType
Definition: PATCoreEnums.h:22
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
egEnergyCorr::Resolution::MaterialGapUp
@ MaterialGapUp
Definition: egammaEnergyCorrectionTool.h:77
egEnergyCorr::es2017_R21_v0
@ es2017_R21_v0
Definition: egammaEnergyCorrectionTool.h:239
egamma
Definition: egamma.h:58
ANA_CHECK_THROW
#define ANA_CHECK_THROW(EXP)
check whether the given expression was successful, throwing an exception on failure
Definition: Control/AthToolSupport/AsgMessaging/AsgMessaging/MessageCheck.h:339
CP::EgammaCalibrationAndSmearingTool::m_use_full_statistical_error
bool m_use_full_statistical_error
Definition: EgammaCalibrationAndSmearingTool.h:155
CP::EgammaCalibrationAndSmearingTool::oldtool_scale_flag_this_event
egEnergyCorr::Scale::Variation oldtool_scale_flag_this_event(const xAOD::Egamma &p, const xAOD::EventInfo &event_info) const
Definition: EgammaCalibrationAndSmearingTool.cxx:843
egEnergyCorr::Scale::MomentumUp
@ MomentumUp
Definition: egammaEnergyCorrectionTool.h:125
PATCore::ParticleDataType::Full
@ Full
Definition: PATCoreEnums.h:22
PATCore::ParticleType::ConvertedPhoton
@ ConvertedPhoton
Definition: PATCoreEnums.h:39
egEnergyCorr::es2015cPRE
@ es2015cPRE
Definition: egammaEnergyCorrectionTool.h:226
Egamma.h
CP::EgammaCalibrationAndSmearingTool::m_usePhiUniformCorrection
int m_usePhiUniformCorrection
Definition: EgammaCalibrationAndSmearingTool.h:151
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
egEnergyCorr::Scale::LArTemperature2015PreUp
@ LArTemperature2015PreUp
Definition: egammaEnergyCorrectionTool.h:138
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_resolution
ResolutionDecorrelation m_decorrelation_model_resolution
Definition: EgammaCalibrationAndSmearingTool.h:135
CP::EgammaCalibrationAndSmearingTool::m_user_random_run_number
int m_user_random_run_number
Definition: EgammaCalibrationAndSmearingTool.h:159
CP::EgammaCalibrationAndSmearingTool::m_useIntermoduleCorrection
int m_useIntermoduleCorrection
Definition: EgammaCalibrationAndSmearingTool.h:150
egEnergyCorr::Scale::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:193
CP::EgammaCalibrationAndSmearingTool::m_Run2Run3runNumberTransition
static const unsigned int m_Run2Run3runNumberTransition
Definition: EgammaCalibrationAndSmearingTool.h:128
CP::EgammaCalibrationAndSmearingTool::m_currentResolutionVariation_MC
egEnergyCorr::Resolution::Variation m_currentResolutionVariation_MC
Definition: EgammaCalibrationAndSmearingTool.h:252
CP::CorrectionCode::Error
@ Error
Some error happened during the object correction.
Definition: CorrectionCode.h:36
egEnergyCorr::Resolution::ZSmearingDown
@ ZSmearingDown
Definition: egammaEnergyCorrectionTool.h:71
EgammaxAODHelpers.h
CP::EgammaCalibrationAndSmearingTool::EgammaPredicate
std::function< bool(const xAOD::Egamma &)> EgammaPredicate
Definition: EgammaCalibrationAndSmearingTool.h:92
CP::EgammaCalibrationAndSmearingTool::m_MVACalibSvc
ServiceHandle< IegammaMVASvc > m_MVACalibSvc
Definition: EgammaCalibrationAndSmearingTool.h:228
egEnergyCorr::es2015_day0_3percent
@ es2015_day0_3percent
Definition: egammaEnergyCorrectionTool.h:222
egEnergyCorr::Resolution::MaterialPP0Down
@ MaterialPP0Down
Definition: egammaEnergyCorrectionTool.h:83
egEnergyCorr::es2010
@ es2010
Definition: egammaEnergyCorrectionTool.h:208
CP::EgammaCalibrationAndSmearingTool::m_currentScaleVariation_MC
egEnergyCorr::Scale::Variation m_currentScaleVariation_MC
Definition: EgammaCalibrationAndSmearingTool.h:250
CP::EgammaCalibrationAndSmearingTool::m_ESModel
std::string m_ESModel
Definition: EgammaCalibrationAndSmearingTool.h:130
xAOD::EgammaHelpers::isConvertedPhoton
bool isConvertedPhoton(const xAOD::Egamma *eg, bool excludeTRT=false)
is the object a converted photon
Definition: EgammaxAODHelpers.cxx:26
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
asg::AsgToolConfig
an object that can create a AsgTool
Definition: AsgToolConfig.h:22
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
UNDEFINED
@ UNDEFINED
Definition: sTGCenumeration.h:18
egEnergyCorr::Resolution::MaterialCryoUp
@ MaterialCryoUp
Definition: egammaEnergyCorrectionTool.h:77
egEnergyCorr::es2017_R21_PRE
@ es2017_R21_PRE
Definition: egammaEnergyCorrectionTool.h:237
SG::Decorator
Helper class to provide type-safe access to aux data.
Definition: Decorator.h:58
CP::EgammaCalibrationAndSmearingTool::AbsEtaCaloPredicateFactory
const EgammaPredicate AbsEtaCaloPredicateFactory(double eta_min, double eta_max) const
Definition: EgammaCalibrationAndSmearingTool.h:181
CP::EgammaCalibrationAndSmearingTool::resolution
virtual double resolution(double energy, double cl_eta, double cl_etaCalo, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron, bool withCT=false) const override
Definition: EgammaCalibrationAndSmearingTool.cxx:618
egEnergyCorr::es2015cPRE_res_improved
@ es2015cPRE_res_improved
Definition: egammaEnergyCorrectionTool.h:227
lumiFormat.i
int i
Definition: lumiFormat.py:92
CaloCluster.h
egEnergyCorr::Scale::topoClusterThresUp
@ topoClusterThresUp
Definition: egammaEnergyCorrectionTool.h:156
SystematicRegistry.h
CP::EgammaCalibrationAndSmearingTool::initialize
StatusCode initialize() override
Definition: EgammaCalibrationAndSmearingTool.cxx:315
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
CP::EgammaCalibrationAndSmearingTool::applySystematicVariation
virtual StatusCode applySystematicVariation(const CP::SystematicSet &systConfig) override
effects: configure this tool for the given list of systematic variations.
Definition: EgammaCalibrationAndSmearingTool.cxx:1229
CP::EgammaCalibrationAndSmearingTool::m_currentResolutionVariation_data
egEnergyCorr::Resolution::Variation m_currentResolutionVariation_data
Definition: EgammaCalibrationAndSmearingTool.h:253
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
CP::is_run2
bool is_run2(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:224
xAOD::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition: EgammaxAODHelpers.cxx:13
CP::EgammaCalibrationAndSmearingTool::m_TESModel
egEnergyCorr::ESModel m_TESModel
Definition: EgammaCalibrationAndSmearingTool.h:136
egEnergyCorr::Scale::MomentumDown
@ MomentumDown
Definition: egammaEnergyCorrectionTool.h:125
AsgToolConfig.h
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
egEnergyCorr::Resolution::Nominal
@ Nominal
Definition: egammaEnergyCorrectionTool.h:65
CP::EgammaCalibrationAndSmearingTool::m_varSF
double m_varSF
Definition: EgammaCalibrationAndSmearingTool.h:139
asg::AsgMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AsgMessaging.cxx:49
egEnergyCorr::es2012a
@ es2012a
Definition: egammaEnergyCorrectionTool.h:216
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
CP::EgammaCalibrationAndSmearingTool::SysInfo
Definition: EgammaCalibrationAndSmearingTool.h:241
egEnergyCorr::es2012cTight
@ es2012cTight
Definition: egammaEnergyCorrectionTool.h:220
ParticleImpl::phi
virtual double phi() const
phi in [-pi,pi[
Definition: ParticleImpl.h:524
egEnergyCorr::es2017_summer
@ es2017_summer
Definition: egammaEnergyCorrectionTool.h:231
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
egEnergyCorr::es2015c_summer
@ es2015c_summer
Definition: egammaEnergyCorrectionTool.h:228
egammaLayerRecalibTool.h
CP::EgammaCalibrationAndSmearingTool::m_usePSCorrection
int m_usePSCorrection
Definition: EgammaCalibrationAndSmearingTool.h:147
egEnergyCorr::Scale::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:177
ParticleImpl::eta
virtual double eta() const
pseudo rapidity
Definition: ParticleImpl.h:514
CP::EgammaCalibrationAndSmearingTool::m_use_mapping_correction
bool m_use_mapping_correction
Definition: EgammaCalibrationAndSmearingTool.h:158
egEnergyCorr::Scale::None
@ None
Definition: egammaEnergyCorrectionTool.h:116
Scale
void Scale(TH1 *h, double d=1)
Definition: comparitor.cxx:76
egEnergyCorr::Resolution::MaterialCryoDown
@ MaterialCryoDown
Definition: egammaEnergyCorrectionTool.h:77
Vertex.h
egEnergyCorr::UNDEFINED
@ UNDEFINED
Definition: egammaEnergyCorrectionTool.h:246
GainTool.h
CP::EgammaCalibrationAndSmearingTool::m_TResolutionType
egEnergyCorr::Resolution::resolutionType m_TResolutionType
Definition: EgammaCalibrationAndSmearingTool.h:141
egGain::GainTool::CorrectionGainTool
double CorrectionGainTool(double eta_input, double energy_input, double energy_layer2_input, PATCore::ParticleType::Type ptype=PATCore::ParticleType::Electron) const
Definition: GainTool.cxx:138
CP::EgammaCalibrationAndSmearingTool::oldtool_resolution_flag_this_event
egEnergyCorr::Resolution::Variation oldtool_resolution_flag_this_event(const xAOD::Egamma &p, const xAOD::EventInfo &event_info) const
Definition: EgammaCalibrationAndSmearingTool.cxx:850
egEnergyCorr::Scale::ZeeStatDown
@ ZeeStatDown
Definition: egammaEnergyCorrectionTool.h:131
CP::EgammaCalibrationAndSmearingTool::correction_phi_unif
double correction_phi_unif(double eta, double phi) const
Definition: EgammaCalibrationAndSmearingTool.cxx:1376
CP::EgammaCalibrationAndSmearingTool::m_doSmearing
int m_doSmearing
Definition: EgammaCalibrationAndSmearingTool.h:138
CP::GeV
const double GeV
Definition: EgammaCalibrationAndSmearingTool.cxx:43
CP::EgammaCalibrationAndSmearingTool::ResolutionDecorrelation::FULL
@ FULL
CP::EgammaCalibrationAndSmearingTool::AUTO
static const int AUTO
Definition: EgammaCalibrationAndSmearingTool.h:89
egEnergyCorr::Resolution::None
@ None
Definition: egammaEnergyCorrectionTool.h:62
merge.output
output
Definition: merge.py:17
CP::EgammaCalibrationAndSmearingTool::m_use_AFII
int m_use_AFII
Definition: EgammaCalibrationAndSmearingTool.h:143
CP::EgammaCalibrationAndSmearingTool::m_rootTool
std::unique_ptr< AtlasRoot::egammaEnergyCorrectionTool > m_rootTool
Definition: EgammaCalibrationAndSmearingTool.h:238
CP::EgammaCalibrationAndSmearingTool::m_useLayer2Recalibration
int m_useLayer2Recalibration
Definition: EgammaCalibrationAndSmearingTool.h:149
egEnergyCorr::Resolution::PileUpDown
@ PileUpDown
Definition: egammaEnergyCorrectionTool.h:80
egEnergyCorr::Scale::E4ScintillatorUp
@ E4ScintillatorUp
Definition: egammaEnergyCorrectionTool.h:147
egEnergyCorr::Scale::Variation
Variation
Definition: egammaEnergyCorrectionTool.h:113
CP::EgammaCalibrationAndSmearingTool::setupSystematics
void setupSystematics()
Definition: EgammaCalibrationAndSmearingTool.cxx:886
PathResolver.h
egEnergyCorr::Scale::LArCalibExtra2015PreUp
@ LArCalibExtra2015PreUp
Definition: egammaEnergyCorrectionTool.h:137
CP::SystematicSet::insert
void insert(const SystematicVariation &systematic)
description: insert a systematic into the set
Definition: SystematicSet.cxx:88
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
egEnergyCorr::Resolution::MaterialIBLUp
@ MaterialIBLUp
Definition: egammaEnergyCorrectionTool.h:83
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
egEnergyCorr::Resolution::Variation
Variation
Definition: egammaEnergyCorrectionTool.h:57
AsgServiceConfig.h
egEnergyCorr::es2016PRE
@ es2016PRE
Definition: egammaEnergyCorrectionTool.h:229
egEnergyCorr::es2017_summer_final
@ es2017_summer_final
Definition: egammaEnergyCorrectionTool.h:233
CP::EgammaCalibrationAndSmearingTool::xAOD2ptype
PATCore::ParticleType::Type xAOD2ptype(const xAOD::Egamma &particle) const
Definition: EgammaCalibrationAndSmearingTool.cxx:591
xAOD::get_phi_calo
float get_phi_calo(const xAOD::CaloCluster &cluster, int author, bool do_throw=false)
Definition: EgammaCalibrationAndSmearingTool.h:36
asg::AsgServiceConfig
an object that can create a AsgService
Definition: AsgServiceConfig.h:25
egEnergyCorr::Resolution::OFCUp
@ OFCUp
Definition: egammaEnergyCorrectionTool.h:89
CP::EgammaCalibrationAndSmearingTool::m_MVAfolder
std::string m_MVAfolder
Definition: EgammaCalibrationAndSmearingTool.h:239
egEnergyCorr::Scale::MatPP0Up
@ MatPP0Up
Definition: egammaEnergyCorrectionTool.h:174
egEnergyCorr::es2012XX
@ es2012XX
Definition: egammaEnergyCorrectionTool.h:223
xAOD::Electron_v1
Definition: Electron_v1.h:34
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Down
@ S12ExtraLastEtaBinRun2Down
Definition: egammaEnergyCorrectionTool.h:159
egEnergyCorr::es2012c
@ es2012c
Definition: egammaEnergyCorrectionTool.h:218
egEnergyCorr::Resolution::OFCDown
@ OFCDown
Definition: egammaEnergyCorrectionTool.h:89
EventInfo.h
egEnergyCorr::Scale::PSb12Down
@ PSb12Down
Definition: egammaEnergyCorrectionTool.h:153
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
CP::EgammaCalibrationAndSmearingTool::m_syst_description
std::map< CP::SystematicVariation, SysInfo > m_syst_description
Definition: EgammaCalibrationAndSmearingTool.h:246
egEnergyCorr::es2017
@ es2017
Definition: egammaEnergyCorrectionTool.h:230
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition: Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17
egEnergyCorr::es2018_R21_v1
@ es2018_R21_v1
Definition: egammaEnergyCorrectionTool.h:243
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
AthAnalysisHelper.h
CP::EgammaCalibrationAndSmearingTool::intermodule_correction
double intermodule_correction(double Ecl, double phi, double eta) const
Definition: EgammaCalibrationAndSmearingTool.cxx:1270
TrackParticle.h
egEnergyCorr::Resolution::SigmaEff80
@ SigmaEff80
Definition: egammaEnergyCorrectionTool.h:101
CP::EgammaCalibrationAndSmearingTool::m_set_seed_function
IdFunction m_set_seed_function
Definition: EgammaCalibrationAndSmearingTool.h:257
egEnergyCorr::Scale::PSb12Up
@ PSb12Up
Definition: egammaEnergyCorrectionTool.h:153
CP::EgammaCalibrationAndSmearingTool
Definition: EgammaCalibrationAndSmearingTool.h:81
egammaLayerRecalibTool
Definition: egammaLayerRecalibTool.h:306
CP::EgammaCalibrationAndSmearingTool::ScaleDecorrelation::ONENP_PLUS_UNCONR
@ ONENP_PLUS_UNCONR
egEnergyCorr::Scale::E4ScintillatorDown
@ E4ScintillatorDown
Definition: egammaEnergyCorrectionTool.h:147
CP::CorrectionCode::Ok
@ Ok
The correction was done successfully.
Definition: CorrectionCode.h:38
egEnergyCorr::Resolution::MaterialIDDown
@ MaterialIDDown
Definition: egammaEnergyCorrectionTool.h:77
CP::EgammaCalibrationAndSmearingTool::ScaleDecorrelation::FULL_ETA_CORRELATED
@ FULL_ETA_CORRELATED
CP::EgammaCalibrationAndSmearingTool::m_useLayerCorrection
int m_useLayerCorrection
Definition: EgammaCalibrationAndSmearingTool.h:146
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
egEnergyCorr::Resolution::MaterialIDUp
@ MaterialIDUp
Definition: egammaEnergyCorrectionTool.h:77
egEnergyCorr::Scale::Wtots1Down
@ Wtots1Down
Definition: egammaEnergyCorrectionTool.h:171
egEnergyCorr::es2017_summer_improved
@ es2017_summer_improved
Definition: egammaEnergyCorrectionTool.h:232
xAOD::Photon_v1
Definition: Photon_v1.h:37
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CP::SystematicRegistry
This module implements the central registry for handling systematic uncertainties with CP tools.
Definition: SystematicRegistry.h:25
correlationModel::model
model
Definition: AsgElectronEfficiencyCorrectionTool.cxx:46
egEnergyCorr::es2011dTight
@ es2011dTight
Definition: egammaEnergyCorrectionTool.h:214
xAOD::EgammaHelpers::isPhoton
bool isPhoton(const xAOD::Egamma *eg)
is the object a photon
Definition: EgammaxAODHelpers.cxx:22
egEnergyCorr::Resolution::MaterialCaloUp
@ MaterialCaloUp
Definition: egammaEnergyCorrectionTool.h:77
asg::AsgComponentConfig::setProperty
StatusCode setProperty(const std::string &name, const T &value)
set the given property
egEnergyCorr::Resolution::SamplingTermDown
@ SamplingTermDown
Definition: egammaEnergyCorrectionTool.h:74
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
CP::EgammaCalibrationAndSmearingTool::m_layer_recalibration_tool
egammaLayerRecalibTool * m_layer_recalibration_tool
Definition: EgammaCalibrationAndSmearingTool.h:234
CP::CorrectionCode
Return value from object correction CP tools.
Definition: CorrectionCode.h:31
EgammaDefs.h
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
asg::AsgComponentConfig::setPropertyFromString
void setPropertyFromString(const std::string &name, const std::string &value)
set a given property from a string value
Definition: AsgComponentConfig.cxx:133
CP::use_phi_uniform_correction
bool use_phi_uniform_correction(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:219
xAOD::get_eta_calo
float get_eta_calo(const xAOD::CaloCluster &cluster, int author, bool do_throw=false)
Definition: EgammaCalibrationAndSmearingTool.h:57
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_resolution_name
std::string m_decorrelation_model_resolution_name
Definition: EgammaCalibrationAndSmearingTool.h:133
egEnergyCorr::Resolution::MaterialGapDown
@ MaterialGapDown
Definition: egammaEnergyCorrectionTool.h:77
EgammaCalibPeriodRunNumbersExample::run_2016
const int run_2016
Definition: Interfaces/EgammaAnalysisInterfaces/EgammaAnalysisInterfaces/IEgammaCalibrationAndSmearingTool.h:21
egEnergyCorr::es2017_R21_ofc0_v1
@ es2017_R21_ofc0_v1
Definition: egammaEnergyCorrectionTool.h:241
CaloCondBlobAlgs_fillNoiseFromASCII.folder
folder
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:56
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
egEnergyCorr::Scale::EXTRARUN3PREUp
@ EXTRARUN3PREUp
Definition: egammaEnergyCorrectionTool.h:191
CP::gainToolFactory
std::unique_ptr< egGain::GainTool > gainToolFactory(egEnergyCorr::ESModel model)
Definition: EgammaCalibrationAndSmearingTool.cxx:45
SG::ConstAccessor::isAvailable
bool isAvailable(const ELT &e) const
Test to see if this variable exists in the store.
egEnergyCorr::Scale::LArTemperature2016PreDown
@ LArTemperature2016PreDown
Definition: egammaEnergyCorrectionTool.h:141
egEnergyCorr::es2022_R22_PRE
@ es2022_R22_PRE
Definition: egammaEnergyCorrectionTool.h:244
xAOD::Egamma_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: Egamma_v1.cxx:70
merge.status
status
Definition: merge.py:17
PATCore::ParticleType::Electron
@ Electron
Definition: PATCoreEnums.h:40
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
egammaLayerRecalibTool::fixForMissingCells
void fixForMissingCells(bool fix=true)
apply the fix for missing cells due to timing cut
Definition: egammaLayerRecalibTool.h:347
ConstAccessor.h
Helper class to provide constant type-safe access to aux data.
CP::EgammaCalibrationAndSmearingTool::applyCorrection
virtual CP::CorrectionCode applyCorrection(xAOD::Egamma &) const override
Definition: EgammaCalibrationAndSmearingTool.cxx:625
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
CP::EgammaCalibrationAndSmearingTool::m_syst_description_resolution
std::map< CP::SystematicVariation, egEnergyCorr::Resolution::Variation > m_syst_description_resolution
Definition: EgammaCalibrationAndSmearingTool.h:247
egEnergyCorr::Resolution::af2Up
@ af2Up
Definition: egammaEnergyCorrectionTool.h:86
egEnergyCorr::Scale::af2Down
@ af2Down
Definition: egammaEnergyCorrectionTool.h:177
EgammaCalibrationAndSmearingTool.h
egEnergyCorr::es2015_5TeV
@ es2015_5TeV
Definition: egammaEnergyCorrectionTool.h:235
egEnergyCorr::Resolution::AllUp
@ AllUp
Definition: egammaEnergyCorrectionTool.h:68
egEnergyCorr::Resolution::MaterialCaloDown
@ MaterialCaloDown
Definition: egammaEnergyCorrectionTool.h:77
egEnergyCorr::Scale::S12ExtraLastEtaBinRun2Up
@ S12ExtraLastEtaBinRun2Up
Definition: egammaEnergyCorrectionTool.h:159
TrackingPrimitives.h
CP::EgammaCalibrationAndSmearingTool::m_decorrelation_model_scale
ScaleDecorrelation m_decorrelation_model_scale
Definition: EgammaCalibrationAndSmearingTool.h:134
egEnergyCorr::es2018_R21_v0
@ es2018_R21_v0
Definition: egammaEnergyCorrectionTool.h:242
CP::EgammaCalibrationAndSmearingTool::m_useS12Correction
int m_useS12Correction
Definition: EgammaCalibrationAndSmearingTool.h:148
egEnergyCorr::es2015PRE
@ es2015PRE
Definition: egammaEnergyCorrectionTool.h:224
CP::EgammaCalibrationAndSmearingTool::m_layer_recalibration_tune
std::string m_layer_recalibration_tune
Definition: EgammaCalibrationAndSmearingTool.h:235
xAOD::EventInfo_v1::eventType
bool eventType(EventType type) const
Check for one particular bitmask value.
egEnergyCorr
Definition: egammaEnergyCorrectionTool.h:50
CP::SystematicRegistry::getInstance
static SystematicRegistry & getInstance()
Get the singleton instance of the registry for the curren thread.
Definition: SystematicRegistry.cxx:25
CP::EgammaCalibrationAndSmearingTool::m_use_uA2MeV_2015_first2weeks_correction
int m_use_uA2MeV_2015_first2weeks_correction
Definition: EgammaCalibrationAndSmearingTool.h:157
egEnergyCorr::Scale::topoClusterThresDown
@ topoClusterThresDown
Definition: egammaEnergyCorrectionTool.h:156
CP::EgammaCalibrationAndSmearingTool::m_fixForMissingCells
Gaudi::Property< bool > m_fixForMissingCells
Definition: EgammaCalibrationAndSmearingTool.h:161
egEnergyCorr::Resolution::MaterialIBLDown
@ MaterialIBLDown
Definition: egammaEnergyCorrectionTool.h:83
xAOD::EgammaParameters::unconvertedPhoton
@ unconvertedPhoton
Definition: EgammaEnums.h:19
egEnergyCorr::Resolution::AllDown
@ AllDown
Definition: egammaEnergyCorrectionTool.h:68
Generated on Tue Jul 2 2024 21:14:34 for ATLAS Offline Software by   doxygen 1.8.18