ATLAS Offline Software
GetLCSinglePionsPerf.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 //-----------------------------------------------------------------------
6 // File and Version Information:
7 // $Id: CheckSinglePionsReco.cxx,v 1.1.1.1 2008/11/04 08:56:11 menke Exp $
8 //
9 // Description: see CheckSinglePionsReco.h
10 //
11 // Environment:
12 // Software developed for the ATLAS Detector at CERN LHC
13 //
14 // Author List:
15 // Gennady Pospelov
16 //
17 //-----------------------------------------------------------------------
18 
19 //-----------------------
20 // This Class's Header --
21 //-----------------------
22 #include "CaloLocalHadCalib/GetLCSinglePionsPerf.h"
23 
24 #include <iterator>
25 #include <cmath>
26 
27 #include "AthenaKernel/errorcheck.h"
28 #include "GaudiKernel/ISvcLocator.h"
29 #include "GaudiKernel/StatusCode.h"
30 
31 #include "CaloEvent/CaloCell.h"
32 #include "CaloSimEvent/CaloCalibrationHit.h"
33 #include "CaloSimEvent/CaloCalibrationHitContainer.h"
34 #include "CaloDmDetDescr/CaloDmDescrManager.h"
35 #include "CaloIdentifier/CaloCell_ID.h"
36 #include "GeneratorObjects/McEventCollection.h"
37 #include <CLHEP/Vector/LorentzVector.h>
38 #include "CaloEvent/CaloCompositeKineBase.h"
39 #include "CaloEvent/CaloRecoStatus.h"
40 
41 #include "xAODCaloEvent/CaloCluster.h"
42 
43 
44 #include "TProfile.h"
45 #include "TProfile2D.h"
46 #include "TFile.h"
47 #include "TH1F.h"
48 #include "TVector3.h"
49 #include "TTree.h"
50 
51 
52 using CLHEP::HepLorentzVector;
53 using CLHEP::MeV;
54 
55 
56 /* ****************************************************************************
57 
58 **************************************************************************** */
59 GetLCSinglePionsPerf::GetLCSinglePionsPerf(const std::string& name, ISvcLocator* pSvcLocator)
60  : AthAlgorithm(name, pSvcLocator),
61  m_id_helper(nullptr),
62  m_calo_id(nullptr),
63  m_caloDmDescrManager(nullptr),
64  m_outputFileName("CheckSinglePionsReco.root"),
65  m_outputFile(nullptr),
66  m_distance_cut(1.5),
67  m_netabin(25), m_etamin(0.0), m_etamax(5.0),
68  m_deta(0),
69  m_nphibin(1), m_phimin(-M_PI), m_phimax(M_PI),
70  m_dphi(0),
71  m_nlogenerbin(22), m_logenermin(2.0), m_logenermax(6.4),
72  m_nlogenerbin2(3),
73  m_dlogener(0),
74  m_nnormtype(3),
75  m_ncluscoll(4),
76  m_ntagcases(3),
77  m_nmoments(0),
78  m_nmomsums(6),
79  m_truthPiEngFraction(0.1),
80  m_doEngRecOverTruth(true),
81  m_doEngTag(true),
82  m_doEngRecSpect(true),
83  m_doEngNoiseClus(true),
84  m_doClusMoments(true),
85  m_doRecoEfficiency(true),
86  m_useRecoEfficiency(false),
87  m_useGoodClus(false),
88  m_doCalibHitsValidation(true),
89  m_mc_ener(0),
90  m_mc_eta(0),
91  m_mc_phi(0),
92  m_mc_etabin(0),
93  m_mc_enerbin(0),
94  m_mc_phibin(0)
95 {
96  // collection name where cluster always have moments
97  declareProperty("ClusterBasicCollName",m_clusterBasicCollName);
98 
99  // collections names after different correction steps
100  declareProperty("ClusterCollectionNames",m_clusterCollNames);
101 
102  // distance cut for clusters to calcuate engReco
103  declareProperty("DistanceCut",m_distance_cut);
104 
105  // Name of output file to save histograms in
106  declareProperty("OutputFileName",m_outputFileName);
107 
108  // Names of CalibrationHitContainers to use
109  declareProperty("CalibrationHitContainerNames",m_CalibrationHitContainerNames);
110  declareProperty("DMCalibrationHitContainerNames",m_DMCalibrationHitContainerNames);
111 
112  // to create different types of validation histograms
113  declareProperty("doEngRecOverTruth",m_doEngRecOverTruth);
114  declareProperty("doEngTag",m_doEngTag);
115  declareProperty("doEngRecSpect",m_doEngRecSpect);
116  declareProperty("doEngNoiseClus",m_doEngNoiseClus);
117  declareProperty("doClusMoments",m_doClusMoments);
118  declareProperty("doRecoEfficiency",m_doRecoEfficiency);
119  declareProperty("useRecoEfficiency",m_useRecoEfficiency);
120  declareProperty("useGoodClus",m_useGoodClus);
121 
122  declareProperty("etamin",m_etamin);
123  declareProperty("etamax",m_etamax);
124  declareProperty("netabin",m_netabin);
125 
126  declareProperty("phimin",m_phimin);
127  declareProperty("phimax",m_phimax);
128  declareProperty("nphibin",m_nphibin);
129 
130  declareProperty("logenermin",m_logenermin);
131  declareProperty("logenermax",m_logenermax);
132  declareProperty("nlogenerbin",m_nlogenerbin);
133 
134  declareProperty("doCalibHitsValidation",m_doCalibHitsValidation);
135 // Only use clusters that contain at least m_truthPiEngFraction % of the true pion energy
136  declareProperty("usePionClustersOnly",m_usePionClusters);
137 
138  // dead material identifier description manager
139  m_caloDmDescrManager = CaloDmDescrManager::instance();
140 
141  m_validMoments.resize(0);
142  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_TOT"),xAOD::CaloCluster::ENG_CALIB_TOT));
143  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_OUT_L"),xAOD::CaloCluster::ENG_CALIB_OUT_L));
144  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TOT"),xAOD::CaloCluster::ENG_CALIB_DEAD_TOT));
145  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EMB0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0));
146  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILE0"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0));
147  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILEG3"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3));
148  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EME0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EME0));
149  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_HEC0"),xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0));
150  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_FCAL"),xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL));
151  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_LEAKAGE"),xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE));
152  m_validMoments.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_UNCLASS"),xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS));
153 
154  m_nmoments = m_validMoments.size();
155 
156 }
157 
158 
159 
160 /* ****************************************************************************
161 
162 **************************************************************************** */
163 GetLCSinglePionsPerf::~GetLCSinglePionsPerf()
164 {
165 
166 }
167 
168 
169 
170 /* ****************************************************************************
171 
172 **************************************************************************** */
173 StatusCode GetLCSinglePionsPerf::initialize()
174 {
175  ATH_CHECK( detStore()->retrieve(m_calo_id,"CaloCell_ID") );
176  ATH_CHECK( detStore()->retrieve(m_id_helper) );
177 
178 
179  m_deta = (m_etamax - m_etamin)/m_netabin;
180  m_dphi = (m_phimax - m_phimin)/m_nphibin;
181  m_dlogener = (m_logenermax - m_logenermin)/m_nlogenerbin;
182 
183  m_outputFile = new TFile(m_outputFileName.c_str(),"RECREATE");
184  m_outputFile->cd();
185 
186  // defining histograms
187  char hname[256];
188  float h_eta_min = -5.0;
189  float h_eta_max=5.0;
190  int h_nch_eta = 50;
191  if(m_etamin != 0.0) {
192  h_eta_min = m_etamin;
193  h_eta_max = m_etamax;
194  }
195  const int n_logener_bins = m_nlogenerbin*2;
196  double *xbins = new double[n_logener_bins+1];
197  const double inv_n_logener_bins = 1. / static_cast<double> (n_logener_bins);
198  for(int i_bin=0; i_bin<=n_logener_bins; i_bin++) {
199  xbins[i_bin] = pow(10,m_logenermin+i_bin*(m_logenermax-m_logenermin)*inv_n_logener_bins);
200  }
201  m_ncluscoll = m_clusterCollNames.size();
202 
203  /* **************************************************************************
204  histograms to check classification performance
205  *************************************************************************** */
206  if(m_doEngTag) {
207  // as a function of pion eta for several energy bins
208  m_engTag_vs_eta.resize(m_ntagcases);
209  for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
210  m_engTag_vs_eta[i_tag].resize(m_nlogenerbin, nullptr);
211  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
212  sprintf(hname, "hp_engTag_vs_eta_tag%d_ener%d",i_tag, i_ener);
213  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
214  hp->GetXaxis()->SetTitle("#eta");
215  hp->GetYaxis()->SetTitle("E_{class}/E_{tot}");
216  m_engTag_vs_eta[i_tag][i_ener] = hp;
217  } // i_ener
218  } // i_tag
219  // as a function of pion energy for several eta bins
220  m_engTag_vs_ebeam.resize(m_ntagcases);
221  for(int i_tag=0; i_tag<m_ntagcases; i_tag++){
222  m_engTag_vs_ebeam[i_tag].resize(m_netabin, nullptr);
223  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
224  sprintf(hname, "hp_engTag_vs_ebeam_tag%d_eta%d",i_tag, i_eta);
225  TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
226  hp->GetXaxis()->SetTitle("E_{#pi}, MeV");
227  hp->GetYaxis()->SetTitle("E_{class}/E_{tot}");
228  m_engTag_vs_ebeam[i_tag][i_eta] = hp;
229  }
230  }
231  } // m_doEngTag
232 
233 
234  /* **************************************************************************
235  histograms to check reconstructed energy after each step of local hadronic
236  calibration, reco energy is defined as a sum of clusters energies within certain
237  angle around particle direction
238  *************************************************************************** */
239  if(m_doEngRecOverTruth) {
240  // as a function of pion eta for several energy bins
241  m_engRecOverTruth_vs_eta.resize(m_ncluscoll);
242  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
243  m_engRecOverTruth_vs_eta[i_coll].resize(m_nnormtype);
244  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
245  m_engRecOverTruth_vs_eta[i_coll][i_norm].resize(m_nlogenerbin, nullptr);
246  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
247  double ylow(0), yup(0);
248  if(i_norm != kLEVEL_PARTICLE) {
249  ylow = 0.0;
250  yup = 100.0;
251  }
252  sprintf(hname, "hp_engRecOverTruth_vs_eta_coll%d_norm%d_ener%d",i_coll, i_norm, i_ener);
253  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max, ylow, yup);
254  hp->GetXaxis()->SetTitle("#eta");
255  if(i_norm==kLEVEL_PARTICLE) {
256  hp->GetYaxis()->SetTitle("E_{reco}/E_{#pi}");
257  }else{
258  hp->GetYaxis()->SetTitle("E_{reco}/E_{calib}");
259  }
260  m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener] = hp;
261  } // i_ener
262  } // i_norm
263  } // i_coll
264  // as a function of pion energy for several eta bins
265  m_engRecOverTruth_vs_ebeam.resize(m_ncluscoll);
266  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
267  m_engRecOverTruth_vs_ebeam[i_coll].resize(m_nnormtype);
268  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
269  m_engRecOverTruth_vs_ebeam[i_coll][i_norm].resize(m_netabin, nullptr);
270  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
271  double ylow(0), yup(0);
272  if(i_norm != kLEVEL_PARTICLE) {
273  ylow = 0.0;
274  yup = 100.0;
275  }
276  sprintf(hname, "hp_m_engRecOverTruth_vs_ebeam_coll%d_norm%d_eta%d",i_coll, i_norm, i_eta);
277  TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins, ylow, yup);
278  hp->GetXaxis()->SetTitle("E_{#pi}, MeV");
279  if(i_norm==kLEVEL_PARTICLE) {
280  hp->GetYaxis()->SetTitle("E_{reco}/E_{#pi}");
281  }else{
282  hp->GetYaxis()->SetTitle("E_{reco}/E_{calib}");
283  }
284  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta] = hp;
285  } // i_eta
286  } // i_norm
287  } // i_coll
288  } // m_doEngRecOverTruth
289 
290 
291  /* **************************************************************************
292  histograms to save reco and noise clusters energy spectras
293  *************************************************************************** */
294  if(m_doEngRecSpect) {
295  m_engRecSpect.resize(m_ncluscoll);
296  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
297  m_engRecSpect[i_coll].resize(m_nlogenerbin);
298  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
299  m_engRecSpect[i_coll][i_ener].resize(m_netabin, nullptr);
300  for(int i_eta=0; i_eta<m_netabin; i_eta++){
301  sprintf(hname, "hp_engRecSpect_coll%d_ener%d_eta%d",i_coll, i_ener, i_eta);
302  TH1F *h1 = new TH1F(hname, hname, 110, -0.2, 2.0);
303  h1->GetXaxis()->SetTitle("E_{reco}/E_{#pi}");
304  m_engRecSpect[i_coll][i_ener][i_eta] = h1;
305  } // i_eta
306  } // i_ener
307  } // i_coll
308  // energy spectra of incident pions
309  m_engPionSpect.resize(m_nlogenerbin);
310  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
311  m_engPionSpect[i_ener].resize(m_netabin, nullptr);
312  for(int i_eta=0; i_eta<m_netabin; i_eta++){
313  sprintf(hname, "hp_engPionSpect_ener%d_eta%d",i_ener, i_eta);
314  double x1 = pow(10,m_logenermin+i_ener*m_dlogener);
315  double x2 = pow(10,m_logenermin+(i_ener+1)*m_dlogener);
316  TH1F *h1 = new TH1F(hname, hname, 20, x1, x2);
317  h1->GetXaxis()->SetTitle("E_{#pi}, MeV");
318  m_engPionSpect[i_ener][i_eta] = h1;
319  } // i_eta
320  } // i_ener
321  } // m_doEngRecSpect
322 
323  /* **************************************************************************
324  histograms to save noise clusters spectras
325  *************************************************************************** */
326  if(m_doEngNoiseClus) {
327  // noise clusters spectras
328  m_engNoiseClusSpect.resize(m_ncluscoll);
329  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
330  m_engNoiseClusSpect[i_coll].resize(m_netabin, nullptr);
331  for(int i_eta=0; i_eta<m_netabin; i_eta++){
332  sprintf(hname, "hp_engNoiseClusSpect_coll%d_eta%d",i_coll, i_eta);
333  TH1F *h1 = new TH1F(hname, hname, 100, -2000., 2000.);
334  h1->GetXaxis()->SetTitle("E_{clus}, MeV");
335  m_engNoiseClusSpect[i_coll][i_eta] = h1;
336  } // i_eta
337  } // i_coll
338  // average
339  m_engNoiseClus_vs_eta.resize(m_ncluscoll, nullptr);
340  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
341  sprintf(hname, "hp_engNoiseClus_vs_eta_coll%d",i_coll);
342  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
343  hp->GetXaxis()->SetTitle("#eta");
344  hp->GetYaxis()->SetTitle("E_{clus}, MeV");
345  m_engNoiseClus_vs_eta[i_coll] = hp;
346  //hp->SetErrorOption("s");
347  }
348  } // m_doEngNoiseClus
349 
350  /* **************************************************************************
351  histograms to save cluster moments
352  *************************************************************************** */
353  if(m_doClusMoments) {
354  m_clusMoment_vs_eta.resize(m_nmoments);
355  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
356  m_clusMoment_vs_eta[i_mom].resize(m_nmomsums);
357  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
358  m_clusMoment_vs_eta[i_mom][i_sum].resize(m_nlogenerbin, nullptr);
359  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
360  sprintf(hname, "hp_clusMoment_vs_eta_mom%d_sum%d_ener%d",i_mom, i_sum, i_ener);
361  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
362  hp->GetXaxis()->SetTitle("#eta");
363  hp->GetYaxis()->SetTitle("Mom_{cls}/Mom_{sum}");
364  hp->SetTitle(m_validMoments[i_mom].first.c_str());
365  m_clusMoment_vs_eta[i_mom][i_sum][i_ener] = hp;
366  } // i_ener
367  } // i_sum
368  } // i_mom
369 
370  m_clusMoment_vs_ebeam.resize(m_nmoments);
371  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
372  m_clusMoment_vs_ebeam[i_mom].resize(m_nmomsums);
373  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
374  m_clusMoment_vs_ebeam[i_mom][i_sum].resize(m_netabin, nullptr);
375  for(int i_eta=0; i_eta<m_netabin; i_eta++){
376  sprintf(hname, "hp_clusMoment_vs_ebeam_mom%d_sum%d_eta%d",i_mom, i_sum, i_eta);
377  TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
378  hp->GetXaxis()->SetTitle("E_{#pi}");
379  hp->GetYaxis()->SetTitle("Mom_{cls}/Mom_{sum}");
380  hp->SetTitle(m_validMoments[i_mom].first.c_str());
381  m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta] = hp;
382  } // i_eta
383  } // i_sum
384  } // i_mom
385 
386  } // m_doClusMoments
387 
388 
389  /* **************************************************************************
390  histograms to save reconstruction efficiency
391  *************************************************************************** */
392  if(m_doRecoEfficiency) {
393  // as a function of eta for several energy bins
394  for(int i_eff=0; i_eff<2; i_eff++){ // 0-reconstructed, 1-all events
395  m_RecoEfficiency_vs_eta[i_eff].resize(m_nlogenerbin, nullptr);
396  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
397  sprintf(hname, "hp_m_RecoEfficiency_eff%d_ener%d", i_eff, i_ener);
398  TH1F *h1 = new TH1F(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
399  h1->GetXaxis()->SetTitle("#eta");
400  h1->GetYaxis()->SetTitle("Efficiency");
401  m_RecoEfficiency_vs_eta[i_eff][i_ener] = h1;
402  } // i_eta
403  } // i_eff
404  // as a function of energy for several eta bins
405  for(int i_eff=0; i_eff<2; i_eff++){ // 0-reconstructed, 1-all events
406  m_RecoEfficiency_vs_ebeam[i_eff].resize(m_netabin, nullptr);
407  for(int i_eta=0; i_eta<m_netabin; i_eta++){
408  sprintf(hname, "hp_m_RecoEfficiency_eff%d_eta%d", i_eff, i_eta);
409  TH1F *h1 = new TH1F(hname, hname, n_logener_bins, xbins);
410  h1->GetXaxis()->SetTitle("E_{#pi}, MeV");
411  h1->GetYaxis()->SetTitle("Efficiency");
412  m_RecoEfficiency_vs_ebeam[i_eff][i_eta] = h1;
413  } // i_eta
414  } // i_eff
415  }
416 
417  /* **************************************************************************
418  histograms to check calibration hits machinery
419  *************************************************************************** */
420  if(m_doCalibHitsValidation) {
421  m_SumCalibHitOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
422  m_DefaultCalculatorOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
423  m_SumCalibHitAssignedOverEbeam_vs_eta.resize(m_nlogenerbin2, nullptr);
424  m_SumCalibHitAssignedOverEbeam_vs_etaphi.resize(m_nlogenerbin2, nullptr);
425  for(int i_ener=0; i_ener<m_nlogenerbin2; i_ener++){
426  sprintf(hname, "hp_SumCalibHitOverEbeam_vs_eta_ener%d", i_ener);
427  TProfile *hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
428  hp->GetXaxis()->SetTitle("#eta");
429  hp->GetYaxis()->SetTitle("#sum E_{calib}/E_{#pi}");
430  m_SumCalibHitOverEbeam_vs_eta[i_ener] = hp;
431  sprintf(hname, "hp_DefaultCalculatorOverEbeam_vs_eta_ener%d", i_ener);
432  hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
433  hp->GetXaxis()->SetTitle("#eta");
434  hp->GetYaxis()->SetTitle("#sum E_{DefCalc}/E_{#pi}");
435  m_DefaultCalculatorOverEbeam_vs_eta[i_ener] = hp;
436  sprintf(hname, "hp_SumCalibHitAssignedOverEbeam_vs_eta_ener%d", i_ener);
437  hp = new TProfile(hname, hname, h_nch_eta, h_eta_min, h_eta_max);
438  hp->GetXaxis()->SetTitle("#eta");
439  hp->GetYaxis()->SetTitle("#sum E_{assigned}/E_{#pi}");
440  m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener] = hp;
441  sprintf(hname, "hp_SumCalibHitAssignedOverEbeam_vs_etaphi_ener%d", i_ener);
442  TProfile2D *hp2 = new TProfile2D(hname, hname, 25, h_eta_min, h_eta_max, 25, -M_PI, M_PI);
443  hp2->GetXaxis()->SetTitle("#eta");
444  hp2->GetYaxis()->SetTitle("#phi");
445  hp2->GetZaxis()->SetTitle("#sum E_{assigned}/E_{#pi}");
446  m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener] = hp2;
447  } // i_ener
448 
449 // m_SumCalibHitOverEbeam_vs_ebeam.resize(m_netabin, 0);
450 // // m_DefaultCalculatorOverEbeam_vs_ebeam.resize(m_netabin, 0);
451 // for(int i_eta=0; i_eta<m_netabin; i_eta++){
452 // sprintf(hname, "hp_SumCalibHitOverEbeam_vs_ebeam_eta%d", i_eta);
453 // TProfile *hp = new TProfile(hname, hname, n_logener_bins, xbins);
454 // hp->GetXaxis()->SetTitle("#eta");
455 // hp->GetYaxis()->SetTitle("#sum E_{calib}/E_{#pi}");
456 // m_SumCalibHitOverEbeam_vs_ebeam[i_eta] = hp;
457 // // sprintf(hname, "hp_DefaultCalculatorOverEbeam_vs_ebeam_eta%d", i_eta);
458 // // hp = new TProfile(hname, hname, n_logener_bins, xbins);
459 // // hp->GetXaxis()->SetTitle("#eta");
460 // // hp->GetYaxis()->SetTitle("#sum E_{DefCalc}/E_{#pi}");
461 // // m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta] = hp;
462 // } // i_eta
463  } // m_doCalibHitsValidation
464 
465 
466  delete [] xbins;
467 
468  ATH_CHECK( m_clusterBasicCollName.initialize() );
469  ATH_CHECK( m_clusterCollNames.initialize() );
470  ATH_CHECK( m_CalibrationHitContainerNames.initialize() );
471  ATH_CHECK( m_DMCalibrationHitContainerNames.initialize() );
472 
473  return StatusCode::SUCCESS;
474 }
475 
476 
477 
478 /* ****************************************************************************
479 writing histograms into the file
480 **************************************************************************** */
481 StatusCode GetLCSinglePionsPerf::finalize()
482 {
483  ATH_MSG_INFO( "Writing out histograms" );
484 
485  // ereco over truth after each step of calibration
486  if(m_doEngRecOverTruth) {
487  m_outputFile->cd();
488  m_outputFile->mkdir("engRecOverTruth");
489  m_outputFile->cd("engRecOverTruth");
490  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
491  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
492  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
493  if(m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener]) m_engRecOverTruth_vs_eta[i_coll][i_norm][i_ener]->Write();
494  } // i_ener
495  } // i_norm
496  } // i_coll
497  //
498  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
499  for(int i_norm=0; i_norm<m_nnormtype; i_norm++){
500  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
501  if(m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta]) m_engRecOverTruth_vs_ebeam[i_coll][i_norm][i_eta]->Write();
502  } // i_eta
503  } // i_norm
504  } // i_coll
505  } // m_doEngRecOverTruth
506 
507  // classification performance
508  if(m_doEngTag) {
509  m_outputFile->cd();
510  m_outputFile->mkdir("engTag");
511  m_outputFile->cd("engTag");
512  for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
513  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
514  if(m_engTag_vs_eta[i_tag][i_ener]) m_engTag_vs_eta[i_tag][i_ener]->Write();
515  } // i_ener
516  } // i_tag
517  // as a function of pion energy for several eta bins
518  for(int i_tag=0; i_tag<m_ntagcases; i_tag++){
519  for(int i_eta=0; i_eta<m_netabin; i_eta++) {
520  if(m_engTag_vs_ebeam[i_tag][i_eta]) m_engTag_vs_ebeam[i_tag][i_eta]->Write();
521  }
522  }
523  } // m_doEngTag
524 
525  // reco energy spactras
526  if(m_doEngRecSpect) {
527  m_outputFile->cd();
528  m_outputFile->mkdir("engRecSpect");
529  m_outputFile->cd("engRecSpect");
530  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
531  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
532  for(int i_eta=0; i_eta<m_netabin; i_eta++){
533  if(m_engRecSpect[i_coll][i_ener][i_eta]) m_engRecSpect[i_coll][i_ener][i_eta]->Write();
534  } // i_eta
535  } // i_ener
536  } // i_coll
537  // pione energy spectra
538  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
539  for(int i_eta=0; i_eta<m_netabin; i_eta++){
540  if(m_engPionSpect[i_ener][i_eta]) m_engPionSpect[i_ener][i_eta]->Write();
541  } // i_eta
542  } // i_ener
543  } // m_doEngRecSpect
544 
545  // noise clusters spectra
546  if(m_doEngNoiseClus) {
547  m_outputFile->cd();
548  m_outputFile->mkdir("engNoiseClus");
549  m_outputFile->cd("engNoiseClus");
550  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
551  for(int i_eta=0; i_eta<m_netabin; i_eta++){
552  if(m_engNoiseClusSpect[i_coll][i_eta]) m_engNoiseClusSpect[i_coll][i_eta]->Write();
553  } // i_eta
554  } // i_coll
555  // average noise
556  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
557  if(m_engNoiseClus_vs_eta[i_coll]) m_engNoiseClus_vs_eta[i_coll] -> Write();
558  }
559  } // m_doEngRecSpect
560 
561  if(m_doClusMoments) {
562  m_outputFile->cd();
563  m_outputFile->mkdir("clusMoment");
564  m_outputFile->cd("clusMoment");
565  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
566  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
567  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
568  if(m_clusMoment_vs_eta[i_mom][i_sum][i_ener]) m_clusMoment_vs_eta[i_mom][i_sum][i_ener]->Write();
569  } // i_ener
570  } // i_sum
571  } // i_mom
572  for(int i_mom=0; i_mom<m_nmoments; i_mom++){
573  for(int i_sum=0; i_sum<m_nmomsums; i_sum++){
574  for(int i_eta=0; i_eta<m_netabin; i_eta++){
575  if(m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta]) m_clusMoment_vs_ebeam[i_mom][i_sum][i_eta]->Write();
576  } // i_eta
577  } // i_sum
578  } // i_mom
579 
580  } // m_doClusMoments
581 
582  if(m_doRecoEfficiency) {
583  m_outputFile->cd();
584  m_outputFile->mkdir("RecoEff");
585  m_outputFile->cd("RecoEff");
586  for(int i_ener=0; i_ener<m_nlogenerbin; i_ener++){
587  if(m_RecoEfficiency_vs_eta[0][i_ener] && m_RecoEfficiency_vs_eta[1][i_ener]) {
588  m_RecoEfficiency_vs_eta[0][i_ener]->Write();
589  m_RecoEfficiency_vs_eta[1][i_ener]->Write();
590  }
591  } // i_eta
592  for(int i_eta=0; i_eta<m_netabin; i_eta++){
593  if(m_RecoEfficiency_vs_ebeam[0][i_eta] && m_RecoEfficiency_vs_ebeam[1][i_eta]) {
594  m_RecoEfficiency_vs_ebeam[0][i_eta]->Write();
595  m_RecoEfficiency_vs_ebeam[1][i_eta]->Write();
596  }
597  } // i_eta
598  } // m_doRecoEfficiency
599 
600  /* **************************************************************************
601  histograms to check calibration hits machinery
602  *************************************************************************** */
603  if(m_doCalibHitsValidation) {
604  m_outputFile->cd();
605  m_outputFile->mkdir("CalibHitsValidation");
606  m_outputFile->cd("CalibHitsValidation");
607  for(int i_ener=0; i_ener<m_nlogenerbin2; i_ener++){
608  if(m_SumCalibHitOverEbeam_vs_eta[i_ener]) m_SumCalibHitOverEbeam_vs_eta[i_ener]->Write();
609  if(m_DefaultCalculatorOverEbeam_vs_eta[i_ener]) m_DefaultCalculatorOverEbeam_vs_eta[i_ener]->Write();
610  if(m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener]) m_SumCalibHitAssignedOverEbeam_vs_eta[i_ener]->Write();
611  if(m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener]) m_SumCalibHitAssignedOverEbeam_vs_etaphi[i_ener]->Write();
612  } // i_ener
613 // for(int i_eta=0; i_eta<m_netabin; i_eta++){
614 // if(m_SumCalibHitOverEbeam_vs_ebeam[i_eta]) m_SumCalibHitOverEbeam_vs_ebeam[i_eta]->Write();
615 // // if(m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta]) m_DefaultCalculatorOverEbeam_vs_ebeam[i_eta]->Write();
616 // } // i_eta
617 
618  } // m_doCalibHitsValidation
619 
620  /* ********************************************
621  writing tree with histogram parameters
622  ******************************************** */
623  m_outputFile->cd();
624  m_outputFile->mkdir("Parameters");
625  m_outputFile->cd("Parameters");
626  TTree *tree = new TTree("ParamTree","ParamTree");
627  tree->Branch("m_netabin",&m_netabin,"m_netabin/I");
628  tree->Branch("m_etamin",&m_etamin,"m_etamin/F");
629  tree->Branch("m_etamax",&m_etamax,"m_etamax/F");
630  tree->Branch("m_nphibin",&m_nphibin,"m_nphibin/I");
631  tree->Branch("m_phimin",&m_phimin,"m_phimin/F");
632  tree->Branch("m_phimax",&m_phimax,"m_phimax/F");
633  tree->Branch("m_nlogenerbin",&m_nlogenerbin,"m_nlogenerbin/I");
634  tree->Branch("m_logenermin",&m_logenermin,"m_logenermin/F");
635  tree->Branch("m_logenermax",&m_logenermax,"m_logenermax/F");
636  tree->Branch("m_nnormtype",&m_nnormtype,"m_nnormtype/I");
637  tree->Branch("m_ncluscoll",&m_ncluscoll,"m_ncluscoll/I");
638  tree->Branch("m_ntagcases",&m_ntagcases,"m_ntagcases/I");
639  tree->Branch("m_nmoments",&m_nmoments,"m_nmoments/I");
640  tree->Branch("m_nmomsums",&m_nmomsums,"m_nmomsums/I");
641  tree->Fill();
642  tree->Write();
643 
644  m_outputFile->Close();
645 
646  return StatusCode::SUCCESS;
647 }
648 
649 
650 
651 /* ****************************************************************************
652 
653 **************************************************************************** */
654 StatusCode GetLCSinglePionsPerf::execute()
655 {
656  const EventContext& ctx = getContext();
657 
658  /* ********************************************
659  reading particles
660  ******************************************** */
661  const McEventCollection* truthEvent=nullptr;
662  ATH_CHECK( evtStore()->retrieve(truthEvent, "TruthEvent") );
663 
664  if( truthEvent->at(0)->particles_empty() ){
665  ATH_MSG_ERROR( "No particles in McEventCollection" );
666  return StatusCode::FAILURE;
667  }
668 #ifdef HEPMC3
669  const HepMC::ConstGenParticlePtr& gen=truthEvent->at(0)->particles().front();
670 #else
671  HepMC::GenEvent::particle_const_iterator pit = truthEvent->at(0)->particles_begin();
672  const HepMC::GenParticle *gen = (*pit);
673 #endif
674  m_mc_eta = gen->momentum().pseudoRapidity();
675  m_mc_phi = gen->momentum().phi();
676  m_mc_ener = gen->momentum().e();
677 
678  // energy and eta bins for particle
679  m_mc_enerbin = int( (log10(m_mc_ener) - m_logenermin)/m_dlogener);
680  m_mc_etabin = int((fabs(m_mc_eta)-m_etamin)/m_deta);
681  m_mc_phibin = int((m_mc_phi-m_phimin)/m_dphi);
682 
683  if(m_mc_etabin <0 || m_mc_etabin >= m_netabin || m_mc_enerbin <0 || m_mc_enerbin >= m_nlogenerbin || m_mc_phibin !=0) return StatusCode::SUCCESS;
684 
685  SG::ReadHandle<xAOD::CaloClusterContainer> clusColl (m_clusterBasicCollName, ctx);
686  if(clusColl->empty()) {
687  ATH_MSG_WARNING( "Empty ClusterContainer " << m_clusterBasicCollName );
688  return StatusCode::SUCCESS;
689  }
690 
691  // check that we have at least one meaningfull cluster
692  if(m_doRecoEfficiency) {
693  bool PionWasReconstructed = false;
694  float engClusCalibThs = 1.0*MeV;
695  HepLorentzVector hlv_pion(1,0,0,1);
696  hlv_pion.setREtaPhi(1./cosh(m_mc_eta),m_mc_eta,m_mc_phi);
697  for (const xAOD::CaloCluster* theCluster : *clusColl) {
698  double mx_calib_tot;
699  if( !theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ) {
700  ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent" );
701  }
702  double mx_dens, mx_center_lambda;
703  if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA, mx_center_lambda))
704  mx_center_lambda = 0;
705  if (!theCluster->retrieveMoment(xAOD::CaloCluster::FIRST_ENG_DENS, mx_dens))
706  mx_dens = 0;
707 
708  HepLorentzVector hlv_cls(1,0,0,1);
709  hlv_cls.setREtaPhi(1./cosh(theCluster->eta()), theCluster->eta(), theCluster->phi());
710  double r = hlv_pion.angle(hlv_cls.vect());
711  if(r < m_distance_cut*angle_mollier_factor(m_mc_eta)
712  && mx_calib_tot > engClusCalibThs
713  && theCluster->size() > 1
714  && mx_dens > 0
715  && mx_center_lambda != 0.0 ) {
716  PionWasReconstructed = true;
717  break;
718  }
719  }
720  if(PionWasReconstructed){
721  m_RecoEfficiency_vs_ebeam[0][m_mc_etabin]->Fill(m_mc_ener);
722  m_RecoEfficiency_vs_eta[0][m_mc_enerbin]->Fill(m_mc_eta);
723  }
724  m_RecoEfficiency_vs_ebeam[1][m_mc_etabin]->Fill(m_mc_ener);
725  m_RecoEfficiency_vs_eta[1][m_mc_enerbin]->Fill(m_mc_eta);
726  if(m_useRecoEfficiency && !PionWasReconstructed) return StatusCode::SUCCESS;
727  }
728 
729  if(m_doEngRecSpect) {
730  m_engPionSpect[m_mc_enerbin][m_mc_etabin]->Fill(m_mc_ener);
731  }
732 
733  if(m_doEngRecOverTruth || m_doEngTag || m_doEngRecSpect || m_doEngNoiseClus){
734  fill_reco (*clusColl, ctx);
735  }
736 
737  if(m_doClusMoments) {
738  fill_moments (*clusColl, ctx);
739  }
740 
741  if(m_doCalibHitsValidation) {
742  fill_calibhits (*clusColl, ctx);
743  }
744 
745  return StatusCode::SUCCESS;
746 }
747 
748 
749 
750 /* ****************************************************************************
751 + average reconstructed energy after different steps of calibration, energy spectras
752 + classification performance
753 + noise clusters
754 **************************************************************************** */
755 int GetLCSinglePionsPerf::fill_reco (const xAOD::CaloClusterContainer& clusColl,
756  const EventContext& ctx)
757 {
758  /* ********************************************
759  reading cluster collections for each calibration level
760  ******************************************** */
761  std::vector<const xAOD::CaloClusterContainer *> clusCollVector;
762  for (const SG::ReadHandleKey<xAOD::CaloClusterContainer> & k : m_clusterCollNames) {
763  SG::ReadHandle<xAOD::CaloClusterContainer> pColl (k, ctx);
764  clusCollVector.push_back(pColl.cptr());
765  }
766 
767  HepLorentzVector hlv_pion(1,0,0,1);
768  hlv_pion.setREtaPhi(1./cosh(m_mc_eta),m_mc_eta,m_mc_phi);
769 
770  std::vector<double > engClusSum; // for 4 collections
771  engClusSum.resize(m_ncluscoll, 0.0);
772  std::vector<double > engClusSumPresOnly; // for 4 collections
773  engClusSumPresOnly.resize(m_ncluscoll, 0.0);
774 
775  double engClusSumCalib(0);
776  double engClusSumCalibPresOnly(0);
777  double engClusSumTrueOOC(0);
778  double engClusSumTrueDM(0);
779  std::vector<double> engClusSumCalibTagged;
780  engClusSumCalibTagged.resize(m_ntagcases, 0.0);
781 
782  int nGoodClus = 0;
783  unsigned int iClus = -1;
784  for (const xAOD::CaloCluster* theCluster : clusColl) {
785  ++iClus;
786  double mx_calib_tot;
787  if( !theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ) {
788  ATH_MSG_ERROR( "Moment ENG_CALIB_TOT is absent" );
789  }
790  double mx_calib_emb0 = 0;
791  double mx_calib_eme0 = 0;
792  double mx_calib_tileg3 = 0;
793  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
794  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
795  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
796  ATH_MSG_ERROR( "One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent" );
797  }
798  double mx_calib_out = 0;
799  double mx_calib_dead_tot = 0;
800  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_out)
801  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT, mx_calib_dead_tot) ){
802  ATH_MSG_ERROR( "One of the moment ENG_CALIB_OUT_L, ENG_CALIB_DEAD_TOT is absent" );
803  }
804 
805  double mx_dens, mx_center_lambda;
806  if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA, mx_center_lambda))
807  mx_center_lambda = 0;
808  if (!theCluster->retrieveMoment(xAOD::CaloCluster::FIRST_ENG_DENS, mx_dens))
809  mx_dens = 0;
810 
811  bool clusIsGood(true);//Fabian
812  if(m_useGoodClus){
813  if(theCluster->size() <= 1 || mx_dens <=0 || mx_center_lambda ==0 || ( m_usePionClusters && mx_calib_tot <= m_truthPiEngFraction * m_mc_ener )) {
814  clusIsGood = false;
815  }
816  }
817 
818  HepLorentzVector hlv_cls(1,0,0,1);
819  hlv_cls.setREtaPhi(1./cosh(theCluster->eta()), theCluster->eta(), theCluster->phi());
820  double r = hlv_pion.angle(hlv_cls.vect());
821 
822  if((!m_usePionClusters && r < m_distance_cut*angle_mollier_factor(m_mc_eta)) ||
823  ( ( m_usePionClusters && r < m_distance_cut*angle_mollier_factor(m_mc_eta)) && clusIsGood ) ) {
824 
825  theCluster = clusCollVector[kTOPO]->at(iClus); // this collection has RecoStatus
826  CaloRecoStatus recoStatus = theCluster->recoStatus();
827 
828  if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDEM) ) {
829  engClusSumCalibTagged[kTAGEM] += mx_calib_tot;
830  }else if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDHAD) ) {
831  engClusSumCalibTagged[kTAGHAD] += mx_calib_tot;
832  }else if(recoStatus.checkStatus(CaloRecoStatus::TAGGEDUNKNOWN) ) {
833  engClusSumCalibTagged[kTAGUNK] += mx_calib_tot;
834  }else{
835  ATH_MSG_ERROR("CheckSinglePionsReco::execute() -> Error! Unkown classification status " << recoStatus.getStatusWord());
836  }
837 
838  if(clusIsGood){
839  nGoodClus++;
840  engClusSumCalib += mx_calib_tot;
841  engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
842  engClusSumTrueOOC += mx_calib_out;
843  engClusSumTrueDM += mx_calib_dead_tot;
844  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
845  theCluster = clusCollVector[i_coll]->at(iClus);
846  engClusSum[i_coll] += theCluster->e();
847  engClusSumPresOnly[i_coll] += (theCluster->eSample(CaloSampling::PreSamplerB)+theCluster->eSample(CaloSampling::PreSamplerE)+theCluster->eSample(CaloSampling::TileGap3));
848  }
849  }
850 
851  }else{
852  if(m_doEngNoiseClus){
853  // to save noise clusters
854  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
855  theCluster = clusCollVector[i_coll]->at(iClus);
856  m_engNoiseClusSpect[i_coll][m_mc_etabin]->Fill(theCluster->e());
857  m_engNoiseClus_vs_eta[i_coll]->Fill(theCluster->eta(), theCluster->e());
858  }
859  } // m_doEngNoiseClus
860  } // r
861  // xxx
862  } // iclus
863 
864  if(nGoodClus == 0) return 0;
865 
866  /* ********************************************
867  filling histograms for ereco over truth after each step of calibration
868  ******************************************** */
869  if(m_doEngRecOverTruth){
870  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++) {
871  // with respect to the initial pion energy
872  int i_norm = 0;
873  double enom = engClusSum[i_coll];
874  if(i_coll != kTOPO) {
875  enom = enom - engClusSumPresOnly[i_coll];
876  }
877  if(m_mc_ener != 0.0) {
878  m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/m_mc_ener);
879  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/m_mc_ener);
880  }
881  // with respect to the calibration level
882  i_norm = 1;
883  double edenom = engClusSumCalib - engClusSumCalibPresOnly; // for em or had
884  if(i_coll == kTOPO_OOC){ // ooc
885  edenom += engClusSumTrueOOC;
886  }else if(i_coll == kTOPO){ // dm
887  edenom += (engClusSumTrueOOC + engClusSumTrueDM);
888  }
889  if(edenom != 0.0) {
890  m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/edenom);
891  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/edenom);
892  }
893  // with respect to the calibration level with "ideal" previous step
894  i_norm = 2;
895  enom = engClusSum[i_coll] - engClusSumPresOnly[i_coll];
896  if(i_coll == kTOPO_OOC){ // ooc
897  double engClusSumRecoOOC = engClusSum[kTOPO_OOC] - engClusSum[kTOPO_W];
898  enom = engClusSumCalib - engClusSumCalibPresOnly + engClusSumRecoOOC;
899  }else if(i_coll == kTOPO){ // dm
900  double engClusSumRecoDM = engClusSum[kTOPO] - (engClusSum[kTOPO_OOC]-engClusSumPresOnly[kTOPO_OOC]);
901  enom = (engClusSumCalib - engClusSumCalibPresOnly) + engClusSumTrueOOC + engClusSumRecoDM;
902  }
903  if(edenom != 0.0) {
904  m_engRecOverTruth_vs_eta[i_coll][i_norm][m_mc_enerbin]->Fill(m_mc_eta, enom/edenom);
905  m_engRecOverTruth_vs_ebeam[i_coll][i_norm][m_mc_etabin]->Fill(m_mc_ener, enom/edenom);
906  }
907  } // i_coll
908  } // m_doEngRecOverTruth
909 
910  /* ********************************************
911  filling histograms with classification results
912  ******************************************** */
913  if(m_doEngTag) {
914  if(engClusSumCalib!=0.0) {
915  const double inv_engClusSumCalib = 1. / engClusSumCalib;
916  for(int i_tag=0; i_tag<m_ntagcases; i_tag++) {
917  m_engTag_vs_eta[i_tag][m_mc_enerbin]->Fill(m_mc_eta, engClusSumCalibTagged[i_tag]*inv_engClusSumCalib);
918  m_engTag_vs_ebeam[i_tag][m_mc_etabin]->Fill(m_mc_ener, engClusSumCalibTagged[i_tag]*inv_engClusSumCalib);
919  }
920  }
921  } // m_doEngTag
922 
923  /* ********************************************
924  filling histograms for reco energy spectras
925  ******************************************** */
926  if(m_doEngRecSpect){
927  for(int i_coll=0; i_coll<m_ncluscoll; i_coll++){
928  double enom = engClusSum[i_coll];
929  if(i_coll != kTOPO) {
930  enom = enom - engClusSumPresOnly[i_coll];
931  }
932  m_engRecSpect[i_coll][m_mc_enerbin][m_mc_etabin]->Fill(enom/m_mc_ener);
933  }
934  } // m_doEngRecSpect
935 
936  return 0;
937 }
938 
939 
940 
941 /* ****************************************************************************
942 to check moments assignment
943 **************************************************************************** */
944 int GetLCSinglePionsPerf::fill_moments (const xAOD::CaloClusterContainer& clusColl,
945  const EventContext& ctx)
946 {
947  ATH_MSG_DEBUG("GetLCSinglePionsPerf::fill_moments got cont. size: "<<clusColl.size());
948  /* ********************************************
949  reading calibration containers
950  ******************************************** */
951  std::vector<const CaloCalibrationHitContainer *> v_cchc;
952  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_CalibrationHitContainerNames) {
953  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
954  v_cchc.push_back(cchc.cptr());
955  }
956 
957  std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
958  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_DMCalibrationHitContainerNames) {
959  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
960  v_dmcchc.push_back(cchc.cptr());
961  }
962 
963  // calculate total calibration energy int active+inactive hits
964  double engCalibTot = 0.0;
965  std::vector<double > engCalibTotSmp;
966  engCalibTotSmp.resize(CaloSampling::Unknown, 0.0);
967  for (const CaloCalibrationHitContainer* cchc : v_cchc) {
968  //loop over cells in calibration container
969  for (const CaloCalibrationHit* hit : *cchc) {
970  Identifier myId = hit->cellID();
971  if(!myId.is_valid()) {
972  ATH_MSG_WARNING("Error! Bad identifier " << myId << " in container '" << cchc->Name() << "',"
973  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
974  continue;
975  }
976  if(!m_id_helper->is_lar(myId) && !m_id_helper->is_tile(myId)) {
977  ATH_MSG_WARNING("Error! Bad identifier (nor lar or tile) " << myId << " in container '" << cchc->Name() << "',"
978  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
979  continue;
980  }
981 
982  CaloSampling::CaloSample nsmp = CaloSampling::CaloSample(m_calo_id->calo_sample(myId));
983  engCalibTot += hit->energyTotal();
984  engCalibTotSmp[nsmp] += hit->energyTotal();
985  }
986  }
987 
988 
989  double engCalibDeadTot = 0.0;
990  std::vector<double > engCalibDeadTotInArea;
991  engCalibDeadTotInArea.resize(CaloDmDescrArea::DMA_MAX,0.0);
992  for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
993  //loop over cells in calibration container
994  for (const CaloCalibrationHit* hit : *dmcchc) {
995  Identifier myId = hit->cellID();
996  if(!myId.is_valid()) {
997  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier " << myId << " in container '" << dmcchc->Name() << "',"
998  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
999  continue;
1000  }
1001  if(!m_id_helper->is_lar_dm(myId) && !m_id_helper->is_tile_dm(myId)) {
1002  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier (nor lar_dm or tile_dm) " << myId << " in container '" << dmcchc->Name() << "',"
1003  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1004  continue;
1005  }
1006  engCalibDeadTot += hit->energyTotal();
1007  //
1008  CaloDmDescrElement* myCDDE(nullptr);
1009  myCDDE = m_caloDmDescrManager->get_element(myId);
1010  if( !myCDDE ) {
1011  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Absent DM description element!");
1012  continue;
1013  }
1014  int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
1015  engCalibDeadTotInArea[nDmArea] += hit->energyTotal();
1016  engCalibDeadTotInArea[CaloDmDescrArea::DMA_ALL] += hit->energyTotal();
1017  }
1018  }
1019 // double engCalibDeadTotWithPres = engCalibDeadTot + engCalibTotSmp[CaloSampling::PreSamplerB]
1020 // + engCalibTotSmp[CaloSampling::PreSamplerE]
1021 // + engCalibTotSmp[CaloSampling::TileGap3];
1022 
1023  /* ********************************************
1024  reading clusters moments
1025  ******************************************** */
1026  double engClusSumCalib(0);
1027  double engClusSumCalibPresOnly(0);
1028  std::vector<std::vector<double > > clsMoments; // [iClus][m_nmoments]
1029  clsMoments.resize(clusColl.size());
1030  std::vector<double > clsMomentsSum; // [m_nmoments]
1031  clsMomentsSum.resize(m_nmoments,0.0);
1032 
1033  // retrieving cluster moments
1034  unsigned int iClus = -1;
1035  for (const xAOD::CaloCluster* theCluster : clusColl) {
1036  ++iClus;
1037  clsMoments[iClus].resize(m_validMoments.size(),0.0);
1038  int iMoment=0;
1039  for(moment_name_vector::const_iterator im=m_validMoments.begin(); im!=m_validMoments.end(); ++im, ++iMoment){
1040  double mx;
1041  if( theCluster->retrieveMoment((*im).second, mx) ) {
1042  clsMoments[iClus][iMoment] = mx;
1043  }else{
1044  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Can't retrieve moment " << (*im).first << " " << (*im).second);
1045  }
1046  clsMomentsSum[iMoment] += clsMoments[iClus][iMoment];
1047  }
1048  double mx;
1049  if(theCluster->retrieveMoment( xAOD::CaloCluster::ENG_CALIB_TOT, mx ) ){
1050  engClusSumCalib += mx;
1051  }else{
1052  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Can't retrieve moment xAOD::CaloCluster::ENG_CALIB_TOT ");
1053  }
1054  double mx_calib_emb0, mx_calib_eme0, mx_calib_tileg3;
1055  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
1056  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
1057  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
1058  ATH_MSG_WARNING("One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent");
1059  }else{
1060  engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
1061  }
1062  } // iClus
1063 
1064  double engCalibDeadTotWithPres = engCalibDeadTot + engClusSumCalibPresOnly;
1065 
1066  // DM energy before barrel presampler, inside it, and between presampler and strips
1067  double eng_calib_dead_emb0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB0]
1068  + engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB1]
1069  + engCalibTotSmp[CaloSampling::PreSamplerB];
1070  // DM energy between barrel and tile
1071  double eng_calib_dead_tile0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EMB3_TILE0];
1072  // DM energy before scintillator and inside scintillator
1073  double eng_calib_dead_tileg3 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_SCN]
1074  + engCalibTotSmp[CaloSampling::TileGap3];
1075  // DM energy beforee endcap presampler, inside it and between presampler and strips
1076  double eng_calib_dead_eme0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME0]
1077  + engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME12]
1078  + engCalibTotSmp[CaloSampling::PreSamplerE];
1079  // DM energy between emec and hec
1080  double eng_calib_dead_hec0 = engCalibDeadTotInArea[CaloDmDescrArea::DMA_EME3_HEC0];
1081  // DM energy before FCAL and between HEC and FCAL
1082  double eng_calib_dead_fcal = engCalibDeadTotInArea[CaloDmDescrArea::DMA_FCAL0]
1083  + engCalibDeadTotInArea[CaloDmDescrArea::DMA_HEC_FCAL];
1084  // DM leakage behind the calorimeter
1085  double eng_calib_dead_leakage = engCalibDeadTotInArea[CaloDmDescrArea::DMA_LEAK];
1086  // the rest of DM energy which remains unclassified
1087  double eng_calib_dead_unclass = engCalibDeadTotWithPres - eng_calib_dead_emb0 - eng_calib_dead_tile0
1088  - eng_calib_dead_tileg3 - eng_calib_dead_eme0 - eng_calib_dead_hec0 - eng_calib_dead_fcal
1089  - eng_calib_dead_leakage;
1090 
1091  // filling histograms
1092  int iMoment=0;
1093  for(moment_name_vector::const_iterator im=m_validMoments.begin(); im!=m_validMoments.end(); ++im, ++iMoment){
1094  double xnorm = 0.0;
1095  switch ( (*im).second ) {
1096  case xAOD::CaloCluster::ENG_CALIB_TOT:
1097  xnorm = clsMomentsSum[iMoment];
1098  break;
1099  case xAOD::CaloCluster::ENG_CALIB_OUT_T:
1100  xnorm = engCalibTot - engClusSumCalib;
1101  break;
1102  case xAOD::CaloCluster::ENG_CALIB_OUT_L:
1103  xnorm = engCalibTot - engClusSumCalib;
1104  break;
1105  case xAOD::CaloCluster::ENG_CALIB_OUT_M:
1106  xnorm = engCalibTot - engClusSumCalib;
1107  break;
1108  case xAOD::CaloCluster::ENG_CALIB_DEAD_TOT:
1109  xnorm = engCalibDeadTotWithPres;
1110  break;
1111  case xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0:
1112  xnorm = eng_calib_dead_emb0;
1113  break;
1114  case xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0:
1115  xnorm = eng_calib_dead_tile0;
1116  break;
1117  case xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3:
1118  xnorm = eng_calib_dead_tileg3;
1119  break;
1120  case xAOD::CaloCluster::ENG_CALIB_DEAD_EME0:
1121  xnorm = eng_calib_dead_eme0;
1122  break;
1123  case xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0:
1124  xnorm = eng_calib_dead_hec0;
1125  break;
1126  case xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL:
1127  xnorm = eng_calib_dead_fcal;
1128  break;
1129  case xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE:
1130  xnorm = eng_calib_dead_leakage;
1131  break;
1132  case xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS:
1133  xnorm = eng_calib_dead_unclass;
1134  break;
1135  default:
1136  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Not implemented for " << (*im).first << " " << (*im).second);
1137  break;
1138  }
1139  if(m_doClusMoments && xnorm > m_mc_ener*0.0001) {
1140  // moments assigned to first 3 maximum clusters
1141  const double inv_xnorm = 1. / xnorm;
1142  for(unsigned int i_cls=0; i_cls<clusColl.size(); i_cls++){
1143  m_clusMoment_vs_eta[iMoment][i_cls][m_mc_enerbin]->Fill(m_mc_eta, clsMoments[i_cls][iMoment]*inv_xnorm);
1144  m_clusMoment_vs_ebeam[iMoment][i_cls][m_mc_etabin]->Fill(m_mc_ener, clsMoments[i_cls][iMoment]*inv_xnorm);
1145  if(i_cls>=2) break;
1146  }
1147  // sum of moments assigned to clusters wrt total sum of moment
1148  m_clusMoment_vs_eta[iMoment][kMOM_SUMCLS][m_mc_enerbin]->Fill(m_mc_eta, clsMomentsSum[iMoment]/xnorm);
1149  m_clusMoment_vs_ebeam[iMoment][kMOM_SUMCLS][m_mc_etabin]->Fill(m_mc_ener, clsMomentsSum[iMoment]/xnorm);
1150  // unassigned energy wrt pion energy
1151  m_clusMoment_vs_eta[iMoment][kMOM_MISS][m_mc_enerbin]->Fill(m_mc_eta, (xnorm-clsMomentsSum[iMoment])/m_mc_ener);
1152  m_clusMoment_vs_ebeam[iMoment][kMOM_MISS][m_mc_etabin]->Fill(m_mc_ener, (xnorm-clsMomentsSum[iMoment])/m_mc_ener);
1153  // unassigned energy wrt pion energy
1154  m_clusMoment_vs_eta[iMoment][kMOM_MCENER][m_mc_enerbin]->Fill(m_mc_eta, xnorm/m_mc_ener);
1155  m_clusMoment_vs_ebeam[iMoment][kMOM_MCENER][m_mc_etabin]->Fill(m_mc_ener, xnorm/m_mc_ener);
1156  }
1157  } // i_mom
1158 
1159  return 0;
1160 }
1161 
1162 
1163 
1164 /* ****************************************************************************
1165 calibration hits validation
1166 **************************************************************************** */
1167 int GetLCSinglePionsPerf::fill_calibhits (const xAOD::CaloClusterContainer& clusColl,
1168  const EventContext& ctx)
1169 {
1170  /* ********************************************
1171  reading calibration containers
1172  ******************************************** */
1173  std::vector<const CaloCalibrationHitContainer *> v_cchc;
1174  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_CalibrationHitContainerNames) {
1175  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
1176  v_cchc.push_back(cchc.cptr());
1177  }
1178 
1179  std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
1180  for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& k : m_DMCalibrationHitContainerNames) {
1181  SG::ReadHandle<CaloCalibrationHitContainer> cchc (k, ctx);
1182  v_dmcchc.push_back(cchc.cptr());
1183  }
1184 
1185  // calculate total calibration energy int active+inactive hits
1186  double engCalibTot = 0.0;
1187  for (const CaloCalibrationHitContainer* cchc : v_cchc) {
1188  //loop over cells in calibration container
1189  for (const CaloCalibrationHit* hit : *cchc) {
1190  Identifier myId = hit->cellID();
1191  if(!myId.is_valid()) {
1192  ATH_MSG_ERROR("Error! Bad identifier " << myId << " in container '" << cchc->Name() << "',"
1193  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1194  continue;
1195  }
1196  if(!m_id_helper->is_lar(myId) && !m_id_helper->is_tile(myId)) {
1197  ATH_MSG_ERROR("Error! Bad identifier (nor lar or tile) " << myId << " in container '" << cchc->Name() << "',"
1198  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1199  continue;
1200  }
1201  engCalibTot += hit->energyTotal();
1202  }
1203  }
1204 
1205  // calibration energy in dead material
1206  double engCalibDeadTot = 0.0;
1207  double engDefaultCalculator = 0.0;
1208  for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
1209  //loop over cells in calibration container
1210  for (const CaloCalibrationHit* hit : *dmcchc) {
1211  Identifier myId = hit->cellID();
1212  if(!myId.is_valid()) {
1213  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier " << myId << " in container '" << dmcchc->Name() << "',"
1214  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1215  continue;
1216  }
1217  if(!m_id_helper->is_lar_dm(myId) && !m_id_helper->is_tile_dm(myId)) {
1218  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Bad dead material identifier (nor lar_dm or tile_dm) " << myId << " in container '" << dmcchc->Name() << "',"
1219  << " AtlasDetectorID says '" << m_id_helper->show_to_string(myId) << "'");
1220  continue;
1221  }
1222  engCalibDeadTot += hit->energyTotal();
1223  //
1224  CaloDmDescrElement* myCDDE(nullptr);
1225  myCDDE = m_caloDmDescrManager->get_element(myId);
1226  if( !myCDDE ) {
1227  ATH_MSG_ERROR("GetLCSinglePionsPerf::fill_moments() -> Error! Absent DM description element!");
1228  continue;
1229  }
1230  int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
1231  if(nDmArea == CaloDmDescrArea::DMA_DEFCALC) engDefaultCalculator += hit->energyTotal();
1232  }
1233  }
1234 
1235  // calibration energy assigned to one or another cluster
1236  // retrieving cluster moments
1237  double engCalibAssigned = 0.0;
1238  double engClusSumCalibPresOnly = 0.0;
1239  for (const xAOD::CaloCluster* theCluster : clusColl) {
1240  double mx_calib_tot, mx_calib_ooc, mx_calib_dm;
1241 // if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot)
1242 // || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_ooc)
1243 // || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT mx_calib_dm)){
1244 // ATH_MSG_ERROR("One of the moment ENG_CALIB_TOT, ENG_CALIB_OUT_L, ENG_CALIB_DEAD_TOT is absent");
1245 // }
1246  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TOT, mx_calib_tot) ){
1247  ATH_MSG_WARNING("Moment ENG_CALIB_TOT is absent");
1248  }
1249  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_OUT_L, mx_calib_ooc) ){
1250  ATH_MSG_WARNING("Moment ENG_CALIB_OUT_L is absent" );
1251  }
1252  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT, mx_calib_dm) ){
1253  ATH_MSG_WARNING("Moment ENG_CALIB_DEAD_TOT is absent");
1254  }
1255  engCalibAssigned += (mx_calib_tot + mx_calib_ooc + mx_calib_dm);
1256 
1257  double mx_calib_emb0, mx_calib_eme0, mx_calib_tileg3;
1258  if( !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EMB0, mx_calib_emb0)
1259  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_EME0, mx_calib_eme0)
1260  || !theCluster->retrieveMoment(xAOD::CaloCluster::ENG_CALIB_TILEG3, mx_calib_tileg3)){
1261  ATH_MSG_WARNING("One of the moment ENG_CALIB_EMB0, ENG_CALIB_EME0, ENG_CALIB_TILEG3 is absent");
1262  }else{
1263  engClusSumCalibPresOnly += (mx_calib_emb0+mx_calib_eme0+mx_calib_tileg3);
1264  }
1265 
1266  } // iClus
1267  // energy in presamplers is included already in the dead material
1268  engCalibAssigned -= engClusSumCalibPresOnly;
1269 
1270  int n_enerbin = int( (log10(m_mc_ener) - m_logenermin)/ ((m_logenermax - m_logenermin)/m_nlogenerbin2));
1271  // sum of moments assigned to clusters wrt total sum of moment
1272  m_SumCalibHitOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, (engCalibTot+engCalibDeadTot)/m_mc_ener);
1273 // m_SumCalibHitOverEbeam_vs_ebeam[m_mc_etabin]->Fill(m_mc_ener, (engCalibTot+engCalibDeadTot)/m_mc_ener);
1274  m_SumCalibHitAssignedOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, engCalibAssigned/m_mc_ener);
1275  m_SumCalibHitAssignedOverEbeam_vs_etaphi[n_enerbin]->Fill(m_mc_eta, m_mc_phi, engCalibAssigned/m_mc_ener);
1276 
1277  m_DefaultCalculatorOverEbeam_vs_eta[n_enerbin]->Fill(m_mc_eta, engDefaultCalculator/m_mc_ener);
1278 // m_DefaultCalculatorOverEbeam_vs_ebeam[m_mc_etabin]->Fill(m_mc_ener, engDefaultCalculator/m_mc_ener);
1279 
1280  return 0;
1281 }
1282 
1283 
1284 
1285 /* ****************************************************************************
1286 
1287 **************************************************************************** */
1288 double GetLCSinglePionsPerf::angle_mollier_factor(double x)
1289 {
1290  double eta = fabs(x);
1291  double ff;
1292  if(eta<1.6){
1293  ff = atan(5.0*1.7/(200.0*cosh(eta)));
1294  }else if(eta<3.2){
1295  ff = atan(5.0*1.6/(420./tanh(eta)));
1296  }else{
1297  ff = atan(5.0*0.95/(505./tanh(eta)));
1298  }
1299  return ff*(1./atan(5.0*1.7/200.0));
1300 }
1301 
1302 
1303 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
GetLCSinglePionsPerf::m_netabin
int m_netabin
Definition: GetLCSinglePionsPerf.h:72
GetLCSinglePionsPerf::m_dphi
float m_dphi
Definition: GetLCSinglePionsPerf.h:79
GetLCSinglePionsPerf::m_ncluscoll
int m_ncluscoll
Definition: GetLCSinglePionsPerf.h:86
GetLCSinglePionsPerf::execute
virtual StatusCode execute()
Definition: GetLCSinglePionsPerf.cxx:654
CaloDmDescrArea::DMA_EMB3_TILE0
@ DMA_EMB3_TILE0
Definition: CaloDmDescrArea.h:28
beamspotman.r
def r
Definition: beamspotman.py:676
CaloCalibrationHitContainer
Definition: CaloCalibrationHitContainer.h:25
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
GetLCSinglePionsPerf::m_engTag_vs_eta
std::vector< std::vector< TProfile * > > m_engTag_vs_eta
Definition: GetLCSinglePionsPerf.h:108
GetLCSinglePionsPerf::m_clusMoment_vs_ebeam
std::vector< std::vector< std::vector< TProfile * > > > m_clusMoment_vs_ebeam
Definition: GetLCSinglePionsPerf.h:119
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_UNCLASS
@ ENG_CALIB_DEAD_UNCLASS
Attached Calibration Hit energy in dead material in unclassified areas of the detector.
Definition: CaloCluster_v1.h:246
GetLCSinglePionsPerf::fill_calibhits
int fill_calibhits(const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
Definition: GetLCSinglePionsPerf.cxx:1167
GetLCSinglePionsPerf::m_outputFile
TFile * m_outputFile
Definition: GetLCSinglePionsPerf.h:65
GetLCSinglePionsPerf::m_nnormtype
int m_nnormtype
Definition: GetLCSinglePionsPerf.h:85
CaloCalibrationHit.h
GetLCSinglePionsPerf::m_mc_phi
double m_mc_phi
Definition: GetLCSinglePionsPerf.h:133
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
CaloRecoStatus::TAGGEDUNKNOWN
@ TAGGEDUNKNOWN
Definition: CaloRecoStatus.h:41
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
CaloDmDescrManager::get_element
CaloDmDescrElement * get_element(const Identifier &cellId) const
Definition: CaloDmDescrManager.cxx:107
GetLCSinglePionsPerf::m_clusMoment_vs_eta
std::vector< std::vector< std::vector< TProfile * > > > m_clusMoment_vs_eta
Definition: GetLCSinglePionsPerf.h:118
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
AtlasDetectorID::is_lar
bool is_lar(Identifier id) const
Definition: AtlasDetectorID.h:689
GetLCSinglePionsPerf::m_mc_eta
double m_mc_eta
Definition: GetLCSinglePionsPerf.h:132
GetLCSinglePionsPerf::m_SumCalibHitOverEbeam_vs_eta
std::vector< TProfile * > m_SumCalibHitOverEbeam_vs_eta
Definition: GetLCSinglePionsPerf.h:124
dqt_zlumi_pandas.hname
string hname
Definition: dqt_zlumi_pandas.py:279
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
GetLCSinglePionsPerf::m_logenermax
float m_logenermax
Definition: GetLCSinglePionsPerf.h:82
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
GetLCSinglePionsPerf::m_engNoiseClusSpect
std::vector< std::vector< TH1F * > > m_engNoiseClusSpect
Definition: GetLCSinglePionsPerf.h:115
CaloDmDescrArea::DMA_EMB1
@ DMA_EMB1
Definition: CaloDmDescrArea.h:26
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_LEAKAGE
@ ENG_CALIB_DEAD_LEAKAGE
Attached Calibration Hit energy in dead material behind calorimeters.
Definition: CaloCluster_v1.h:243
GetLCSinglePionsPerf::m_doEngNoiseClus
bool m_doEngNoiseClus
Definition: GetLCSinglePionsPerf.h:96
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
GetLCSinglePionsPerf::m_truthPiEngFraction
float m_truthPiEngFraction
Definition: GetLCSinglePionsPerf.h:92
CaloDmDescrArea::DMA_SCN
@ DMA_SCN
Definition: CaloDmDescrArea.h:29
tree
TChain * tree
Definition: tile_monitor.h:30
python.SystemOfUnits.MeV
int MeV
Definition: SystemOfUnits.py:154
GetLCSinglePionsPerf::moment_name_pair
std::pair< std::string, xAOD::CaloCluster::MomentType > moment_name_pair
Definition: GetLCSinglePionsPerf.h:50
GetLCSinglePionsPerf::kTAGUNK
@ kTAGUNK
Definition: GetLCSinglePionsPerf.h:54
GetLCSinglePionsPerf::m_doClusMoments
bool m_doClusMoments
Definition: GetLCSinglePionsPerf.h:97
M_PI
#define M_PI
Definition: ActiveFraction.h:11
xAOD::CaloCluster_v1::ENG_CALIB_TILEG3
@ ENG_CALIB_TILEG3
Calibration Hit energy inside the cluster scintillator.
Definition: CaloCluster_v1.h:222
GetLCSinglePionsPerf::GetLCSinglePionsPerf
GetLCSinglePionsPerf(const std::string &name, ISvcLocator *pSvcLocator)
Definition: GetLCSinglePionsPerf.cxx:59
python.atlas_oh.im
im
Definition: atlas_oh.py:167
CaloCell.h
xAOD::CaloCluster_v1::ENG_CALIB_OUT_M
@ ENG_CALIB_OUT_M
Attached Calibration Hit energy outside clusters but inside the calorimeter with medium matching (Ang...
Definition: CaloCluster_v1.h:200
xAOD::CaloCluster_v1::CENTER_LAMBDA
@ CENTER_LAMBDA
Shower depth at Cluster Centroid.
Definition: CaloCluster_v1.h:136
GetLCSinglePionsPerf::m_etamax
float m_etamax
Definition: GetLCSinglePionsPerf.h:74
GetLCSinglePionsPerf::m_nlogenerbin2
int m_nlogenerbin2
Definition: GetLCSinglePionsPerf.h:83
fitman.mx
mx
Definition: fitman.py:520
GetLCSinglePionsPerf::m_ntagcases
int m_ntagcases
Definition: GetLCSinglePionsPerf.h:87
GetLCSinglePionsPerf::m_dlogener
float m_dlogener
Definition: GetLCSinglePionsPerf.h:84
GetLCSinglePionsPerf::m_doCalibHitsValidation
bool m_doCalibHitsValidation
Definition: GetLCSinglePionsPerf.h:101
xAOD::CaloCluster_v1::ENG_CALIB_EMB0
@ ENG_CALIB_EMB0
Calibration Hit energy inside the cluster barrel presampler.
Definition: CaloCluster_v1.h:218
GetLCSinglePionsPerf::m_mc_etabin
int m_mc_etabin
Definition: GetLCSinglePionsPerf.h:134
GetLCSinglePionsPerf::finalize
virtual StatusCode finalize()
Definition: GetLCSinglePionsPerf.cxx:481
GetLCSinglePionsPerf::m_engPionSpect
std::vector< std::vector< TH1F * > > m_engPionSpect
Definition: GetLCSinglePionsPerf.h:113
CaloCell_Base_ID::calo_sample
int calo_sample(const Identifier id) const
returns an int taken from Sampling enum and describing the subCalo to which the Id belongs.
Definition: CaloCell_Base_ID.cxx:141
CaloDmDescrArea::DMA_EME12
@ DMA_EME12
Definition: CaloDmDescrArea.h:33
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_TILE0
@ ENG_CALIB_DEAD_TILE0
Attached Calibration Hit energy in dead material between EMB3 and TILE0.
Definition: CaloCluster_v1.h:230
GetLCSinglePionsPerf::~GetLCSinglePionsPerf
virtual ~GetLCSinglePionsPerf()
Definition: GetLCSinglePionsPerf.cxx:163
SG::ReadHandleKey< xAOD::CaloClusterContainer >
read_hist_ntuple.h1
h1
Definition: read_hist_ntuple.py:21
GetLCSinglePionsPerf::m_doEngRecOverTruth
bool m_doEngRecOverTruth
Definition: GetLCSinglePionsPerf.h:93
x
#define x
GetLCSinglePionsPerf::angle_mollier_factor
static double angle_mollier_factor(double x)
Definition: GetLCSinglePionsPerf.cxx:1288
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
GetLCSinglePionsPerf::m_engTag_vs_ebeam
std::vector< std::vector< TProfile * > > m_engTag_vs_ebeam
Definition: GetLCSinglePionsPerf.h:109
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
CaloCalibrationHitContainer.h
master.gen
gen
Definition: master.py:32
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
GetLCSinglePionsPerf::kTOPO_W
@ kTOPO_W
Definition: GetLCSinglePionsPerf.h:53
CaloCell_ID.h
GetLCSinglePionsPerf::m_distance_cut
double m_distance_cut
Definition: GetLCSinglePionsPerf.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
CaloDmDescrManager::instance
static const CaloDmDescrManager * instance()
Definition: CaloDmDescrManager.cxx:67
GetLCSinglePionsPerf::kMOM_MISS
@ kMOM_MISS
Definition: GetLCSinglePionsPerf.h:55
CaloDmDescrArea::DMA_LEAK
@ DMA_LEAK
Definition: CaloDmDescrArea.h:44
GetLCSinglePionsPerf::kTAGEM
@ kTAGEM
Definition: GetLCSinglePionsPerf.h:54
GetLCSinglePionsPerf::kMOM_MCENER
@ kMOM_MCENER
Definition: GetLCSinglePionsPerf.h:55
CaloDmDescrArea::DMA_EMB0
@ DMA_EMB0
Definition: CaloDmDescrArea.h:25
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
GetLCSinglePionsPerf::m_logenermin
float m_logenermin
Definition: GetLCSinglePionsPerf.h:81
GetLCSinglePionsPerf::m_clusterCollNames
SG::ReadHandleKeyArray< xAOD::CaloClusterContainer > m_clusterCollNames
Definition: GetLCSinglePionsPerf.h:63
GetLCSinglePionsPerf::m_phimax
float m_phimax
Definition: GetLCSinglePionsPerf.h:78
GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_eta
std::vector< TProfile * > m_SumCalibHitAssignedOverEbeam_vs_eta
Definition: GetLCSinglePionsPerf.h:128
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
GetLCSinglePionsPerf::m_id_helper
const AtlasDetectorID * m_id_helper
Definition: GetLCSinglePionsPerf.h:58
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
GetLCSinglePionsPerf::m_useRecoEfficiency
bool m_useRecoEfficiency
Definition: GetLCSinglePionsPerf.h:99
McEventCollection.h
GetLCSinglePionsPerf::kLEVEL_PARTICLE
@ kLEVEL_PARTICLE
Definition: GetLCSinglePionsPerf.h:56
CaloDmDescrManager.h
GetLCSinglePionsPerf::m_deta
float m_deta
Definition: GetLCSinglePionsPerf.h:75
CaloSampling::CaloSample
CaloSample
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:22
CaloCluster.h
D3PDSizeSummary.ff
ff
Definition: D3PDSizeSummary.py:305
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
GetLCSinglePionsPerf::fill_moments
int fill_moments(const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
Definition: GetLCSinglePionsPerf.cxx:944
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
xAOD::CaloCluster_v1::ENG_CALIB_TOT
@ ENG_CALIB_TOT
Calibration Hit energy inside the cluster.
Definition: CaloCluster_v1.h:195
GetLCSinglePionsPerf::m_validMoments
moment_name_vector m_validMoments
Definition: GetLCSinglePionsPerf.h:68
CaloDmDescrArea::DMA_DEFCALC
@ DMA_DEFCALC
Definition: CaloDmDescrArea.h:45
GetLCSinglePionsPerf::initialize
virtual StatusCode initialize()
Definition: GetLCSinglePionsPerf.cxx:173
GetLCSinglePionsPerf::m_RecoEfficiency_vs_ebeam
std::vector< TH1F * > m_RecoEfficiency_vs_ebeam[2]
Definition: GetLCSinglePionsPerf.h:122
CaloCompositeKineBase.h
AtlasDetectorID::is_tile_dm
bool is_tile_dm(Identifier id) const
Definition: AtlasDetectorID.h:748
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_FCAL
@ ENG_CALIB_DEAD_FCAL
Attached Calibration Hit energy in dead material before FCAL, between FCAL and HEC.
Definition: CaloCluster_v1.h:241
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
CaloDmDescrArea::DMA_FCAL0
@ DMA_FCAL0
Definition: CaloDmDescrArea.h:43
GetLCSinglePionsPerf::m_engNoiseClus_vs_eta
std::vector< TProfile * > m_engNoiseClus_vs_eta
Definition: GetLCSinglePionsPerf.h:116
GetLCSinglePionsPerf::m_phimin
float m_phimin
Definition: GetLCSinglePionsPerf.h:77
CaloDmDescrElement
Definition: CaloDmDescrManager.h:33
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
GetLCSinglePionsPerf::m_useGoodClus
bool m_useGoodClus
Definition: GetLCSinglePionsPerf.h:100
McEventCollection
This defines the McEventCollection, which is really just an ObjectVector of McEvent objects.
Definition: McEventCollection.h:33
xAOD::CaloCluster_v1::FIRST_ENG_DENS
@ FIRST_ENG_DENS
First Moment in E/V.
Definition: CaloCluster_v1.h:143
GetLCSinglePionsPerf::m_nlogenerbin
int m_nlogenerbin
Definition: GetLCSinglePionsPerf.h:80
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
GetLCSinglePionsPerf::m_outputFileName
std::string m_outputFileName
Definition: GetLCSinglePionsPerf.h:64
CaloDmDescrArea::DMA_HEC_FCAL
@ DMA_HEC_FCAL
Definition: CaloDmDescrArea.h:40
AthAlgorithm
Definition: AthAlgorithm.h:47
CaloRecoStatus::checkStatus
virtual bool checkStatus(const StatusIndicator &statusIndicator) const
Check status.
Definition: CaloRecoStatus.h:117
GetLCSinglePionsPerf::m_etamin
float m_etamin
Definition: GetLCSinglePionsPerf.h:73
CaloDmDescrArea::DMA_EME3_HEC0
@ DMA_EME3_HEC0
Definition: CaloDmDescrArea.h:37
HepMC::ConstGenParticlePtr
const GenParticle * ConstGenParticlePtr
Definition: GenParticle.h:38
CaloCalibrationHit
Class to store calorimeter calibration hit.
Definition: CaloCalibrationHit.h:23
xAOD::CaloCluster_v1::ENG_CALIB_EME0
@ ENG_CALIB_EME0
Calibration Hit energy inside the cluster endcap presampler.
Definition: CaloCluster_v1.h:220
CaloRecoStatus.h
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CaloDmDescrArea::DMA_EME0
@ DMA_EME0
Definition: CaloDmDescrArea.h:31
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_HEC0
@ ENG_CALIB_DEAD_HEC0
Attached Calibration Hit energy in dead material between EME3 and HEC0.
Definition: CaloCluster_v1.h:238
errorcheck.h
Helpers for checking error return status codes and reporting errors.
GetLCSinglePionsPerf::m_nphibin
int m_nphibin
Definition: GetLCSinglePionsPerf.h:76
CaloDmDescrArea::DMA_MAX
@ DMA_MAX
Definition: CaloDmDescrArea.h:47
GetLCSinglePionsPerf::m_mc_ener
double m_mc_ener
Definition: GetLCSinglePionsPerf.h:131
GetLCSinglePionsPerf::m_usePionClusters
bool m_usePionClusters
Definition: GetLCSinglePionsPerf.h:102
CaloRecoStatus::TAGGEDEM
@ TAGGEDEM
Definition: CaloRecoStatus.h:38
GetLCSinglePionsPerf::m_engRecSpect
std::vector< std::vector< std::vector< TH1F * > > > m_engRecSpect
Definition: GetLCSinglePionsPerf.h:111
LArCellBinning.xbins
int xbins
Definition: LArCellBinning.py:163
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_TILEG3
@ ENG_CALIB_DEAD_TILEG3
Attached Calibration Hit energy in dead material before scintillator.
Definition: CaloCluster_v1.h:232
GetLCSinglePionsPerf::m_engRecOverTruth_vs_eta
std::vector< std::vector< std::vector< TProfile * > > > m_engRecOverTruth_vs_eta
Definition: GetLCSinglePionsPerf.h:105
GetLCSinglePionsPerf::m_DMCalibrationHitContainerNames
SG::ReadHandleKeyArray< CaloCalibrationHitContainer > m_DMCalibrationHitContainerNames
Definition: GetLCSinglePionsPerf.h:67
GetLCSinglePionsPerf::m_CalibrationHitContainerNames
SG::ReadHandleKeyArray< CaloCalibrationHitContainer > m_CalibrationHitContainerNames
Definition: GetLCSinglePionsPerf.h:66
GetLCSinglePionsPerf::m_calo_id
const CaloCell_ID * m_calo_id
Definition: GetLCSinglePionsPerf.h:59
GetLCSinglePionsPerf::kMOM_SUMCLS
@ kMOM_SUMCLS
Definition: GetLCSinglePionsPerf.h:55
GetLCSinglePionsPerf::kTAGHAD
@ kTAGHAD
Definition: GetLCSinglePionsPerf.h:54
AtlasDetectorID::is_lar_dm
bool is_lar_dm(Identifier id) const
LAr/Tile dead material:
Definition: AtlasDetectorID.h:736
GetLCSinglePionsPerf::m_DefaultCalculatorOverEbeam_vs_eta
std::vector< TProfile * > m_DefaultCalculatorOverEbeam_vs_eta
Definition: GetLCSinglePionsPerf.h:126
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_TOT
@ ENG_CALIB_DEAD_TOT
Attached Calibration Hit energy in dead material.
Definition: CaloCluster_v1.h:224
GetLCSinglePionsPerf::m_SumCalibHitAssignedOverEbeam_vs_etaphi
std::vector< TProfile2D * > m_SumCalibHitAssignedOverEbeam_vs_etaphi
Definition: GetLCSinglePionsPerf.h:129
GetLCSinglePionsPerf::kTOPO
@ kTOPO
Definition: GetLCSinglePionsPerf.h:53
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:574
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
DeMoScan.first
bool first
Definition: DeMoScan.py:536
GetLCSinglePionsPerf.h
GetLCSinglePionsPerf::m_doEngTag
bool m_doEngTag
Definition: GetLCSinglePionsPerf.h:94
CaloRecoStatus::getStatusWord
virtual const store_type & getStatusWord() const
retrieve the entire status word
Definition: CaloRecoStatus.h:112
GetLCSinglePionsPerf::m_nmoments
int m_nmoments
Definition: GetLCSinglePionsPerf.h:88
GetLCSinglePionsPerf::fill_reco
int fill_reco(const xAOD::CaloClusterContainer &clusColl, const EventContext &ctx)
Definition: GetLCSinglePionsPerf.cxx:755
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
CaloRecoStatus::TAGGEDHAD
@ TAGGEDHAD
Definition: CaloRecoStatus.h:39
xAOD::CaloCluster_v1::ENG_CALIB_OUT_L
@ ENG_CALIB_OUT_L
Attached Calibration Hit energy outside clusters but inside the calorimeter with loose matching (Angl...
Definition: CaloCluster_v1.h:196
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_EME0
@ ENG_CALIB_DEAD_EME0
Attached Calibration Hit energy in dead material before EME0, between EME0 and EME1.
Definition: CaloCluster_v1.h:235
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
xAOD::CaloCluster_v1::ENG_CALIB_OUT_T
@ ENG_CALIB_OUT_T
Attached Calibration Hit energy outside clusters but inside the calorimeter with tight matching (Angl...
Definition: CaloCluster_v1.h:204
GetLCSinglePionsPerf::m_RecoEfficiency_vs_eta
std::vector< TH1F * > m_RecoEfficiency_vs_eta[2]
Definition: GetLCSinglePionsPerf.h:121
GetLCSinglePionsPerf::m_nmomsums
int m_nmomsums
Definition: GetLCSinglePionsPerf.h:89
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
GetLCSinglePionsPerf::m_doEngRecSpect
bool m_doEngRecSpect
Definition: GetLCSinglePionsPerf.h:95
CaloDmDescrArea::DMA_ALL
@ DMA_ALL
Definition: CaloDmDescrArea.h:24
GetLCSinglePionsPerf::m_mc_phibin
int m_mc_phibin
Definition: GetLCSinglePionsPerf.h:136
GetLCSinglePionsPerf::m_engRecOverTruth_vs_ebeam
std::vector< std::vector< std::vector< TProfile * > > > m_engRecOverTruth_vs_ebeam
Definition: GetLCSinglePionsPerf.h:106
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
CaloRecoStatus
reconstruction status indicator
Definition: CaloRecoStatus.h:12
GetLCSinglePionsPerf::m_clusterBasicCollName
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_clusterBasicCollName
Definition: GetLCSinglePionsPerf.h:62
GetLCSinglePionsPerf::m_mc_enerbin
int m_mc_enerbin
Definition: GetLCSinglePionsPerf.h:135
xAOD::CaloCluster_v1::ENG_CALIB_DEAD_EMB0
@ ENG_CALIB_DEAD_EMB0
Attached Calibration Hit energy in dead material before EMB0, between EMB0 and EMB1.
Definition: CaloCluster_v1.h:227
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
GetLCSinglePionsPerf::m_doRecoEfficiency
bool m_doRecoEfficiency
Definition: GetLCSinglePionsPerf.h:98
fitman.k
k
Definition: fitman.py:528
GenParticle
@ GenParticle
Definition: TruthClasses.h:30
CaloDmDescrManager::get_dm_area
int get_dm_area(const Identifier &cellId) const
Definition: CaloDmDescrManager.cxx:147
GetLCSinglePionsPerf::kTOPO_OOC
@ kTOPO_OOC
Definition: GetLCSinglePionsPerf.h:53
GetLCSinglePionsPerf::m_caloDmDescrManager
const CaloDmDescrManager * m_caloDmDescrManager
Definition: GetLCSinglePionsPerf.h:60
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Fri Jan 10 2025 21:10:43 for ATLAS Offline Software by   doxygen 1.8.18