Belle II Software  release-08-01-10
ECLDataAnalysisModule.cc
1 /**************************************************************************
2  * basf2 (Belle II Analysis Software Framework) *
3  * Author: The Belle II Collaboration *
4  * *
5  * See git log for contributors and copyright holders. *
6  * This file is licensed under LGPL-3.0, see LICENSE.md. *
7  **************************************************************************/
8 
9 /* Own header. */
10 #include <ecl/modules/eclDataAnalysis/ECLDataAnalysisModule.h>
11 
12 /* ECL headers. */
13 #include <ecl/dataobjects/ECLCalDigit.h>
14 #include <ecl/dataobjects/ECLConnectedRegion.h>
15 #include <ecl/dataobjects/ECLDigit.h>
16 #include <ecl/dataobjects/ECLHit.h>
17 #include <ecl/dataobjects/ECLLocalMaximum.h>
18 #include <ecl/dataobjects/ECLPidLikelihood.h>
19 #include <ecl/dataobjects/ECLShower.h>
20 #include <ecl/dataobjects/ECLSimHit.h>
21 
22 /* Basf2 headers. */
23 #include <framework/dataobjects/EventMetaData.h>
24 #include <framework/datastore/RelationVector.h>
25 #include <framework/gearbox/Const.h>
26 #include <framework/logging/Logger.h>
27 #include <mdst/dataobjects/ECLCluster.h>
28 #include <mdst/dataobjects/EventLevelClusteringInfo.h>
29 #include <mdst/dataobjects/MCParticle.h>
30 #include <mdst/dataobjects/Track.h>
31 
32 /* ROOT headers. */
33 #include <TFile.h>
34 #include <TMath.h>
35 #include <TTree.h>
36 
37 using namespace std;
38 using namespace Belle2;
39 
40 //-----------------------------------------------------------------
41 // Register the Module
42 //-----------------------------------------------------------------
43 
44 REG_MODULE(ECLDataAnalysis);
45 
46 //-----------------------------------------------------------------
47 // Implementation
48 //-----------------------------------------------------------------
49 
50 ECLDataAnalysisModule::ECLDataAnalysisModule()
51  : Module(),
52  m_rootFilePtr(0),
53  m_writeToRoot(1),
54  m_doTracking(0),
55  m_eclSimHits(eclSimHitArrayName()),
56  m_eclHits(eclHitArrayName()),
57  m_eclDigits(eclDigitArrayName()),
58  m_eclCalDigits(eclCalDigitArrayName()),
59  m_eclConnectedRegions(eclConnectedRegionArrayName()),
60  m_eclShowers(eclShowerArrayName()),
61  m_eclClusters(eclClusterArrayName()),
62  m_eclLocalMaximums(eclLocalMaximumArrayName()),
63  m_eclPureDigits(eclPureDigitArrayName()),
64  m_eclPureCalDigits(eclPureCalDigitArrayName()),
65  m_eclPureConnectedRegions(eclPureConnectedRegionArrayName()),
66  m_eclPureShowers(eclPureShowerArrayName()),
67  m_eclPureClusters(eclPureClusterArrayName()),
68  m_eclPureLocalMaximums(eclPureLocalMaximumArrayName()),
69  m_tree(0),
70  m_iExperiment(0),
71  m_iRun(0),
72  m_iEvent(0),
73 //Digit
74  m_eclDigitMultip(0),
75  m_eclDigitIdx(0),
76  m_eclDigitToMC(0),
77  m_eclDigitCellId(0),
78  m_eclDigitAmp(0),
79  m_eclDigitTimeFit(0),
80  m_eclDigitFitQuality(0),
81  m_eclDigitToCalDigit(0),
82 //CalDigit
83  m_eclCalDigitMultip(0),
84  m_eclCalDigitIdx(0),
85  m_eclCalDigitToMC1(0),
86  m_eclCalDigitToMC1PDG(0),
87  m_eclCalDigitToMCWeight1(0),
88  m_eclCalDigitToMC2(0),
89  m_eclCalDigitToMC2PDG(0),
90  m_eclCalDigitToMCWeight2(0),
91  m_eclCalDigitToMC3(0),
92  m_eclCalDigitToMC3PDG(0),
93  m_eclCalDigitToMCWeight3(0),
94  m_eclCalDigitToMC4(0),
95  m_eclCalDigitToMC4PDG(0),
96  m_eclCalDigitToMCWeight4(0),
97  m_eclCalDigitToMC5(0),
98  m_eclCalDigitToMC5PDG(0),
99  m_eclCalDigitToMCWeight5(0),
100  m_eclCalDigitToBkgWeight(0),
101  m_eclCalDigitSimHitSum(0),
102  m_eclCalDigitToShower(0),
103  m_eclCalDigitCellId(0),
104  m_eclCalDigitAmp(0),
105  m_eclCalDigitTimeFit(0),
106  m_eclCalDigitFitQuality(0),
107  m_eclCalDigitToCR(0),
108  m_eclCalDigitToLM(0),
109 //Connected Region
110  m_eclCRIdx(0),
111  m_eclCRIsTrack(0),
112  m_eclCRLikelihoodMIPNGamma(0),
113  m_eclCRLikelihoodChargedHadron(0),
114  m_eclCRLikelihoodElectronNGamma(0),
115  m_eclCRLikelihoodNGamma(0),
116  m_eclCRLikelihoodNeutralHadron(0),
117  m_eclCRLikelihoodMergedPi0(0),
118 //Local Maxima
119  m_eclLMMultip(0),
120  m_eclLMId(0),
121  m_eclLMType(0),
122  m_eclLMCellId(0),
123 //SimHit
124  m_eclSimHitMultip(0),
125  m_eclSimHitIdx(0),
126  m_eclSimHitToMC(0),
127  m_eclSimHitCellId(0),
128  m_eclSimHitPdg(0),
129  m_eclSimHitEnergyDep(0),
130  m_eclSimHitFlightTime(0),
131  m_eclSimHitX(0),
132  m_eclSimHitY(0),
133  m_eclSimHitZ(0),
134  m_eclSimHitPx(0),
135  m_eclSimHitPy(0),
136  m_eclSimHitPz(0),
137 //Hit
138  m_eclHitMultip(0),
139  m_eclHitIdx(0),
140  m_eclHitToMC(0),
141  m_eclHitToDigit(0),
142  m_eclHitToDigitAmp(0),
143  m_eclHitToPureDigit(0),
144  m_eclHitToPureDigitAmp(0),
145  m_eclHitCellId(0),
146  m_eclHitEnergyDep(0),
147  m_eclHitTimeAve(0),
148 //Cluster
149  m_eclClusterMultip(0),
150  m_eclClusterTrueMultip(0),
151  m_eclClusterGammaMultip(0),
152  m_eclClusterIdx(0),
153  m_eclClusterToMC1(0),
154  m_eclClusterToMCWeight1(0),
155  m_eclClusterToMC1PDG(0),
156  m_eclClusterToMC2(0),
157  m_eclClusterToMCWeight2(0),
158  m_eclClusterToMC2PDG(0),
159  m_eclClusterToMC3(0),
160  m_eclClusterToMCWeight3(0),
161  m_eclClusterToMC3PDG(0),
162  m_eclClusterToMC4(0),
163  m_eclClusterToMCWeight4(0),
164  m_eclClusterToMC4PDG(0),
165  m_eclClusterToMC5(0),
166  m_eclClusterToMCWeight5(0),
167  m_eclClusterToMC5PDG(0),
168  m_eclClusterToBkgWeight(0),
169  m_eclClusterSimHitSum(0),
170  m_eclClusterToShower(0),
171  m_eclClusterEnergy(0),
172  m_eclClusterEnergyError(0),
173  m_eclClusterTheta(0),
174  m_eclClusterThetaError(0),
175  m_eclClusterPhi(0),
176  m_eclClusterPhiError(0),
177  m_eclClusterR(0),
178  m_eclClusterEnergyDepSum(0),
179  m_eclClusterTiming(0),
180  m_eclClusterTimingError(0),
181  m_eclClusterE9oE21(0),
182  m_eclClusterHighestE(0),
183  m_eclClusterCellId(0),
184  m_eclClusterNofCrystals(0),
185  m_eclClusterCrystalHealth(0),
186  m_eclClusterIsTrack(0),
187  m_eclClusterClosestTrackDist(0),
188  m_eclClusterDeltaL(0),
189  m_eclClusterAbsZernike40(0),
190  m_eclClusterAbsZernike51(0),
191  m_eclClusterZernikeMVA(0),
192  m_eclClusterE1oE9(0),
193  m_eclClusterSecondMoment(0),
194  m_eclClusterLAT(0),
195  m_eclClusterDeltaTime99(0),
196  m_eclClusterDetectorRegion(0),
197  m_eclClusterHasNPhotonHypothesis(0),
198  m_eclClusterHasNeutralHadronHypothesis(0),
199 
200 //PureDigits
201  m_eclPureDigitMultip(0),
202  m_eclPureDigitIdx(0),
203  m_eclPureDigitToMC(0),
204  m_eclPureDigitCellId(0),
205  m_eclPureDigitAmp(0),
206  m_eclPureDigitTimeFit(0),
207  m_eclPureDigitFitQuality(0),
208  m_eclPureDigitToCluster(0),
209 //PureCalDigit
210  m_eclPureCalDigitMultip(0),
211  m_eclPureCalDigitIdx(0),
212  m_eclPureCalDigitToMC1(0),
213  m_eclPureCalDigitToMC1PDG(0),
214  m_eclPureCalDigitToMCWeight1(0),
215  m_eclPureCalDigitToMC2(0),
216  m_eclPureCalDigitToMC2PDG(0),
217  m_eclPureCalDigitToMCWeight2(0),
218  m_eclPureCalDigitToMC3(0),
219  m_eclPureCalDigitToMC3PDG(0),
220  m_eclPureCalDigitToMCWeight3(0),
221  m_eclPureCalDigitToMC4(0),
222  m_eclPureCalDigitToMC4PDG(0),
223  m_eclPureCalDigitToMCWeight4(0),
224  m_eclPureCalDigitToMC5(0),
225  m_eclPureCalDigitToMC5PDG(0),
226  m_eclPureCalDigitToMCWeight5(0),
227  m_eclPureCalDigitToBkgWeight(0),
228  m_eclPureCalDigitSimHitSum(0),
229  m_eclPureCalDigitToShower(0),
230  m_eclPureCalDigitCellId(0),
231  m_eclPureCalDigitAmp(0),
232  m_eclPureCalDigitTimeFit(0),
233  m_eclPureCalDigitFitQuality(0),
234  m_eclPureCalDigitToCR(0),
235  m_eclPureCalDigitToLM(0),
236 //Connected Region
237  m_eclPureCRIdx(0),
238  m_eclPureCRIsTrack(0),
239  m_eclPureCRLikelihoodMIPNGamma(0),
240  m_eclPureCRLikelihoodChargedHadron(0),
241  m_eclPureCRLikelihoodElectronNGamma(0),
242  m_eclPureCRLikelihoodNGamma(0),
243  m_eclPureCRLikelihoodNeutralHadron(0),
244  m_eclPureCRLikelihoodMergedPi0(0),
245 //Local Maxima
246  m_eclPureLMMultip(0),
247  m_eclPureLMId(0),
248  m_eclPureLMType(0),
249  m_eclPureLMCellId(0),
250 //PureCluster
251  m_eclPureClusterMultip(0),
252  m_eclPureClusterIdx(0),
253  m_eclPureClusterToMC1(0),
254  m_eclPureClusterToMCWeight1(0),
255  m_eclPureClusterToMC1PDG(0),
256  m_eclPureClusterToMC2(0),
257  m_eclPureClusterToMCWeight2(0),
258  m_eclPureClusterToMC2PDG(0),
259  m_eclPureClusterToMC3(0),
260  m_eclPureClusterToMCWeight3(0),
261  m_eclPureClusterToMC3PDG(0),
262  m_eclPureClusterToMC4(0),
263  m_eclPureClusterToMCWeight4(0),
264  m_eclPureClusterToMC4PDG(0),
265  m_eclPureClusterToMC5(0),
266  m_eclPureClusterToMCWeight5(0),
267  m_eclPureClusterToMC5PDG(0),
268  m_eclPureClusterToBkgWeight(0),
269  m_eclPureClusterEnergy(0),
270  m_eclPureClusterEnergyError(0),
271  m_eclPureClusterTheta(0),
272  m_eclPureClusterThetaError(0),
273  m_eclPureClusterPhi(0),
274  m_eclPureClusterPhiError(0),
275  m_eclPureClusterR(0),
276  m_eclPureClusterEnergyDepSum(0),
277  m_eclPureClusterTiming(0),
278  m_eclPureClusterTimingError(0),
279  m_eclPureClusterE9oE21(0),
280  m_eclPureClusterHighestE(0),
281  m_eclPureClusterCellId(0),
282  m_eclPureClusterLat(0),
283  m_eclPureClusterNofCrystals(0),
284  m_eclPureClusterCrystalHealth(0),
285  m_eclPureClusterIsTrack(0),
286  m_eclPureClusterDeltaL(0),
287  m_eclPureClusterClosestTrackDist(0),
288  m_eclPureClusterAbsZernike40(0),
289  m_eclPureClusterAbsZernike51(0),
290  m_eclPureClusterZernikeMVA(0),
291  m_eclPureClusterSecondMoment(0),
292  m_eclPureClusterE1oE9(0),
293  m_eclPureClusterDeltaTime99(0),
294  m_eclPureClusterDetectorRegion(0),
295  m_eclPureClusterHasNPhotonHypothesis(0),
296  m_eclPureClusterHasNeutralHadronHypothesis(0),
297 
298 //Shower
299  m_eclShowerMultip(0),
300  m_eclShowerIdx(0),
301  m_eclShowerToMC1(0),
302  m_eclShowerToMCWeight1(0),
303  m_eclShowerToMC1PDG(0),
304  m_eclShowerToMC1Moth(0),
305  m_eclShowerToMC1MothPDG(0),
306  m_eclShowerToMC1GMoth(0),
307  m_eclShowerToMC1GMothPDG(0),
308  m_eclShowerToMC2(0),
309  m_eclShowerToMCWeight2(0),
310  m_eclShowerToMC2PDG(0),
311  m_eclShowerToMC2Moth(0),
312  m_eclShowerToMC2MothPDG(0),
313  m_eclShowerToMC2GMoth(0),
314  m_eclShowerToMC2GMothPDG(0),
315  m_eclShowerToMC3(0),
316  m_eclShowerToMCWeight3(0),
317  m_eclShowerToMC3PDG(0),
318  m_eclShowerToMC3Moth(0),
319  m_eclShowerToMC3MothPDG(0),
320  m_eclShowerToMC3GMoth(0),
321  m_eclShowerToMC3GMothPDG(0),
322  m_eclShowerToMC4(0),
323  m_eclShowerToMCWeight4(0),
324  m_eclShowerToMC4PDG(0),
325  m_eclShowerToMC4Moth(0),
326  m_eclShowerToMC4MothPDG(0),
327  m_eclShowerToMC4GMoth(0),
328  m_eclShowerToMC4GMothPDG(0),
329  m_eclShowerToMC5(0),
330  m_eclShowerToMCWeight5(0),
331  m_eclShowerToMC5PDG(0),
332  m_eclShowerToMC5Moth(0),
333  m_eclShowerToMC5MothPDG(0),
334  m_eclShowerToMC5GMoth(0),
335  m_eclShowerToMC5GMothPDG(0),
336  m_eclShowerToBkgWeight(0),
337  m_eclShowerToLM1(0),
338  m_eclShowerToLM2(0),
339  m_eclShowerToLM3(0),
340  m_eclShowerToLM4(0),
341  m_eclShowerToLM5(0),
342  m_eclShowerSimHitSum(0),
343  m_eclShowerUncEnergy(0),
344  m_eclShowerEnergy(0),
345  m_eclShowerTheta(0),
346  m_eclShowerPhi(0),
347  m_eclShowerR(0),
348  m_eclShowerNHits(0),
349  m_eclShowerE9oE21(0),
350  m_eclShowerTime(0),
351  m_eclShowerT99(0),
352  m_eclShowerConnectedRegionId(0),
353  m_eclShowerHypothesisId(0),
354  m_eclShowerCentralCellId(0),
355  m_eclShowerEnergyError(0),
356  m_eclShowerThetaError(0),
357  m_eclShowerPhiError(0),
358  m_eclShowerTimeResolution(0),
359  m_eclShowerHighestEnergy(0),
360  m_eclShowerLateralEnergy(0),
361  m_eclShowerMinTrkDistance(0),
362  m_eclShowerTrkDepth(0),
363  m_eclShowerShowerDepth(0),
364  m_eclShowerAbsZernike40(0),
365  m_eclShowerAbsZernike51(0),
366  m_eclShowerZernikeMVA(0),
367  m_eclShowerSecondMoment(0),
368  m_eclShowerE1oE9(0),
369  m_eclShowerIsTrack(0),
370  m_eclShowerIsCluster(0),
371  m_eclShowerMCVtxInEcl(0),
372  m_eclShowerMCFlightMatch(0),
373  m_eclShowerMCFFlightMatch(0),
374  m_eclShowerHighestE1mE2(0),
375  m_eclShowerNumberOfCrystalsForEnergy(0),
376 //MC
377  m_mcMultip(0),
378  m_mcIdx(0),
379  m_mcPdg(0),
380  m_mcMothPdg(0),
381  m_mcGMothPdg(0),
382  m_mcGGMothPdg(0),
383  m_mcEnergy(0),
384  m_mcPx(0),
385  m_mcPy(0),
386  m_mcPz(0),
387  m_mcDecayVtxX(0),
388  m_mcDecayVtxY(0),
389  m_mcDecayVtxZ(0),
390  m_mcProdVtxX(0),
391  m_mcProdVtxY(0),
392  m_mcProdVtxZ(0),
393  m_mcSecondaryPhysProc(0),
394 //Tracks
395  m_trkMultip(0),
396  m_trkPdg(0),
397  m_trkIdx(0),
398  m_trkCharge(0),
399  m_trkPx(0),
400  m_trkPy(0),
401  m_trkPz(0),
402  m_trkP(0),
403  m_trkTheta(0),
404  m_trkPhi(0),
405  m_trkX(0),
406  m_trkY(0),
407  m_trkZ(0),
408 //PID
409  m_eclpidtrkIdx(0),
410  m_eclpidEnergy(0),
411  m_eclpidEop(0),
412  m_eclpidE9E21(0),
413  m_eclpidNCrystals(0),
414  m_eclpidNClusters(0),
415  m_eclLogLikeEl(0),
416  m_eclLogLikeMu(0),
417  m_eclLogLikePi(0)
418 
419 {
420  //Set module properties
421  setDescription("This module produces an ntuple with ECL-related quantities starting from mdst");
422  addParam("writeToRoot", m_writeToRoot,
423  "set true if you want to save the informations in a root file named by parameter 'rootFileName'", bool(true));
424  addParam("rootFileName", m_rootFileName,
425  "fileName used for root file where info are saved. Will be ignored if parameter 'writeToRoot' is false (standard)",
426  string("eclDataAnalysis"));
427  addParam("doTracking", m_doTracking, "set true if you want to save the informations from TrackFitResults'rootFileName'",
428  bool(false));
429  addParam("doHits", m_doHits, "set true if you want to save the Hit and SimHit informations'", bool(false));
430  addParam("doDigits", m_doDigits, "set true if you want to save the Digits and CalDigits informations'", bool(false));
431  addParam("doPureCsI", m_doPureCsI, "set true if you want to save the informations for upgrade option'", bool(false));
432 
433 }
434 
435 ECLDataAnalysisModule::~ECLDataAnalysisModule()
436 {
437 }
438 
439 
440 void ECLDataAnalysisModule::initialize()
441 {
442 
443  B2INFO("[ECLDataAnalysis Module]: Starting initialization of ECLDataAnalysis Module.");
444 
445  m_eventLevelClusteringInfo.registerInDataStore();
446 
447  m_eclSimHits.registerInDataStore(eclSimHitArrayName());
448  m_eclHits.registerInDataStore(eclHitArrayName());
449 
450  m_eclDigits.registerInDataStore(eclDigitArrayName());
451  m_eclCalDigits.registerInDataStore(eclCalDigitArrayName());
452  m_eclConnectedRegions.registerInDataStore(eclConnectedRegionArrayName());
453  m_eclShowers.registerInDataStore(eclShowerArrayName());
454  m_eclClusters.registerInDataStore(eclClusterArrayName());
455  m_eclLocalMaximums.registerInDataStore(eclLocalMaximumArrayName());
456 
457  m_eclCalDigits.registerRelationTo(m_mcParticles);
458  m_eclDigits.registerRelationTo(m_mcParticles);
459  m_eclShowers.registerRelationTo(m_mcParticles);
460  m_eclClusters.registerRelationTo(m_mcParticles);
461 
462  if (m_doPureCsI == 1) {
463  m_eclPureDigits.registerInDataStore(eclPureDigitArrayName());
464  m_eclPureCalDigits.registerInDataStore(eclPureCalDigitArrayName());
465  m_eclPureConnectedRegions.registerInDataStore(eclPureConnectedRegionArrayName());
466  m_eclPureShowers.registerInDataStore(eclPureShowerArrayName());
467  m_eclPureClusters.registerInDataStore(eclPureClusterArrayName());
468  m_eclPureLocalMaximums.registerInDataStore(eclPureLocalMaximumArrayName());
469 
470  m_eclPureCalDigits.registerRelationTo(m_mcParticles);
471  m_eclPureDigits.registerRelationTo(m_mcParticles);
472  m_eclPureShowers.registerRelationTo(m_mcParticles);
473  m_eclPureClusters.registerRelationTo(m_mcParticles);
474  }
475 
476  if (m_doTracking == true) {
477  m_tracks.isRequired();
478  m_trackFitResults.isRequired();
479  m_eclPidLikelihoods.isRequired();
480  }
481 
482  if (m_writeToRoot == true) {
483  m_rootFilePtr = new TFile(m_rootFileName.c_str(), "RECREATE");
484  } else
485  m_rootFilePtr = nullptr;
486 
487  // initialize tree
488  m_tree = new TTree("m_tree", "ECL Analysis tree");
489 
490  m_tree->Branch("expNo", &m_iExperiment, "expNo/I");
491  m_tree->Branch("runNo", &m_iRun, "runNo/I");
492  m_tree->Branch("evtNo", &m_iEvent, "evtNo/I");
493 
494  //EventLevelClusteringInfo
495  m_tree->Branch("eclNumOutOfTimeDigitsFwd", &m_nECLCalDigitsOutOfTimeFWD, "eclNumOutOfTimeDigitsFwd/s");
496  m_tree->Branch("eclNumOutOfTimeDigitsBrl", &m_nECLCalDigitsOutOfTimeBarrel, "eclNumOutOfTimeDigitsBrl/s");
497  m_tree->Branch("eclNumOutOfTimeDigitsBwd", &m_nECLCalDigitsOutOfTimeBWD, "eclNumOutOfTimeDigitsBwd/s");
498  m_tree->Branch("eclNumRejectedShowersFwd", &m_nECLShowersRejectedFWD, "eclNumRejectedShowersFwd/b");
499  m_tree->Branch("eclNumRejectedShowersBrl", &m_nECLShowersRejectedBarrel, "eclNumRejectedShowersBrl/b");
500  m_tree->Branch("eclNumRejectedShowersBwd", &m_nECLShowersRejectedBWD, "eclNumRejectedShowersBwd/b");
501 
502  if (m_doDigits == 1) {
503  m_tree->Branch("eclDigitMultip", &m_eclDigitMultip, "ecldigit_Multip/I");
504  m_tree->Branch("eclDigitIdx", "std::vector<int>", &m_eclDigitIdx);
505  m_tree->Branch("eclDigitToMC", "std::vector<int>", &m_eclDigitToMC);
506  m_tree->Branch("eclDigitCellId", "std::vector<int>", &m_eclDigitCellId);
507  m_tree->Branch("eclDigitAmp", "std::vector<int>", &m_eclDigitAmp);
508  m_tree->Branch("eclDigitTimeFit", "std::vector<int>", &m_eclDigitTimeFit);
509  m_tree->Branch("eclDigitFitQuality", "std::vector<int>", &m_eclDigitFitQuality);
510  m_tree->Branch("eclDigitToCalDigit", "std::vector<int>", &m_eclDigitToCalDigit);
511 
512  m_tree->Branch("eclCalDigitMultip", &m_eclCalDigitMultip, "eclCaldigit_Multip/I");
513  m_tree->Branch("eclCalDigitIdx", "std::vector<int>", &m_eclCalDigitIdx);
514  m_tree->Branch("eclCalDigitToMC1", "std::vector<int>", &m_eclCalDigitToMC1);
515  m_tree->Branch("eclCalDigitToMC1PDG", "std::vector<int>", &m_eclCalDigitToMC1PDG);
516  m_tree->Branch("eclCalDigitToMCWeight1", "std::vector<double>", &m_eclCalDigitToMCWeight1);
517  m_tree->Branch("eclCalDigitToMC2", "std::vector<int>", &m_eclCalDigitToMC2);
518  m_tree->Branch("eclCalDigitToMC2PDG", "std::vector<int>", &m_eclCalDigitToMC2PDG);
519  m_tree->Branch("eclCalDigitToMCWeight2", "std::vector<double>", &m_eclCalDigitToMCWeight2);
520  m_tree->Branch("eclCalDigitToMC3", "std::vector<int>", &m_eclCalDigitToMC3);
521  m_tree->Branch("eclCalDigitToMC3PDG", "std::vector<int>", &m_eclCalDigitToMC3PDG);
522  m_tree->Branch("eclCalDigitToMCWeight3", "std::vector<double>", &m_eclCalDigitToMCWeight3);
523  m_tree->Branch("eclCalDigitToMC4", "std::vector<int>", &m_eclCalDigitToMC4);
524  m_tree->Branch("eclCalDigitToMC4PDG", "std::vector<int>", &m_eclCalDigitToMC4PDG);
525  m_tree->Branch("eclCalDigitToMCWeight4", "std::vector<double>", &m_eclCalDigitToMCWeight4);
526  m_tree->Branch("eclCalDigitToMC5", "std::vector<int>", &m_eclCalDigitToMC5);
527  m_tree->Branch("eclCalDigitToMC5PDG", "std::vector<int>", &m_eclCalDigitToMC5PDG);
528  m_tree->Branch("eclCalDigitToMCWeight5", "std::vector<double>", &m_eclCalDigitToMCWeight5);
529  m_tree->Branch("eclCalDigitToBkgWeight", "std::vector<double>", &m_eclCalDigitToBkgWeight);
530  m_tree->Branch("eclCalDigitSimHitSum", "std::vector<double>", &m_eclCalDigitSimHitSum);
531  m_tree->Branch("eclCalDigitToShower", "std::vector<int>", &m_eclCalDigitToShower);
532  m_tree->Branch("eclCalDigitCellId", "std::vector<int>", &m_eclCalDigitCellId);
533  m_tree->Branch("eclCalDigitAmp", "std::vector<double>", &m_eclCalDigitAmp);
534  m_tree->Branch("eclCalDigitTimeFit", "std::vector<double>", &m_eclCalDigitTimeFit);
535  m_tree->Branch("eclCalDigitFitQuality", "std::vector<int>", &m_eclCalDigitFitQuality);
536  m_tree->Branch("eclCalDigitToCR", "std::vector<int>", &m_eclCalDigitToCR);
537  m_tree->Branch("eclCalDigitToLM", "std::vector<int>", &m_eclCalDigitToLM);
538  }
539 
540  m_tree->Branch("eclCRIdx", "std::vector<int>", &m_eclCRIdx);
541  m_tree->Branch("eclCRIsTrack", "std::vector<int>", &m_eclCRIsTrack);
542  m_tree->Branch("eclCRLikelihoodMIPNGamma", "std::vector<double>", &m_eclCRLikelihoodMIPNGamma);
543  m_tree->Branch("eclCRLikelihoodChargedHadron", "std::vector<double>", &m_eclCRLikelihoodChargedHadron);
544  m_tree->Branch("eclCRLikelihoodElectronNGamma", "std::vector<double>", &m_eclCRLikelihoodElectronNGamma);
545  m_tree->Branch("eclCRLikelihoodNGamma", "std::vector<double>", &m_eclCRLikelihoodNGamma);
546  m_tree->Branch("eclCRLikelihoodNeutralHadron", "std::vector<double>", &m_eclCRLikelihoodNeutralHadron);
547  m_tree->Branch("eclCRLikelihoodMergedPi0", "std::vector<double>", &m_eclCRLikelihoodMergedPi0);
548 
549  if (m_doHits == 1) {
550  m_tree->Branch("eclSimHitMultip", &m_eclSimHitMultip, "eclSimHitMultip/I");
551  m_tree->Branch("eclSimHitIdx", "std::vector<int>", &m_eclSimHitIdx);
552  m_tree->Branch("eclSimHitToMC", "std::vector<int>", &m_eclSimHitToMC);
553  m_tree->Branch("eclSimHitCellId", "std::vector<int>", &m_eclSimHitCellId);
554  m_tree->Branch("eclSimHitPdg", "std::vector<int>", &m_eclSimHitPdg);
555  m_tree->Branch("eclSimHitEnergyDep", "std::vector<double>", &m_eclSimHitEnergyDep);
556  m_tree->Branch("eclSimHitFlightTime", "std::vector<double>", &m_eclSimHitFlightTime);
557  m_tree->Branch("eclSimHitX", "std::vector<double>", &m_eclSimHitX);
558  m_tree->Branch("eclSimHitY", "std::vector<double>", &m_eclSimHitY);
559  m_tree->Branch("eclSimHitZ", "std::vector<double>", &m_eclSimHitZ);
560  m_tree->Branch("eclSimHitPx", "std::vector<double>", &m_eclSimHitPx);
561  m_tree->Branch("eclSimHitPy", "std::vector<double>", &m_eclSimHitPy);
562  m_tree->Branch("eclSimHitPz", "std::vector<double>", &m_eclSimHitPz);
563 
564  m_tree->Branch("eclHitMultip", &m_eclHitMultip, "eclHitMultip/I");
565  m_tree->Branch("eclHitIdx", "std::vector<int>", &m_eclHitIdx);
566  m_tree->Branch("eclHitToMC", "std::vector<int>", &m_eclHitToMC);
567  m_tree->Branch("eclHitToDigit", "std::vector<int>", &m_eclHitToDigit);
568  m_tree->Branch("eclHitToDigitAmp", "std::vector<int>", &m_eclHitToDigitAmp);
569  m_tree->Branch("eclHitCellId", "std::vector<int>", &m_eclHitCellId);
570  m_tree->Branch("eclHitEnergyDep", "std::vector<double>", &m_eclHitEnergyDep);
571  m_tree->Branch("eclHitTimeAve", "std::vector<double>", &m_eclHitTimeAve);
572  }
573 
574  m_tree->Branch("eclLMMultip", &m_eclLMMultip, "eclLMMultip/I");
575  m_tree->Branch("eclLMId", "std::vector<int>", &m_eclLMId);
576  m_tree->Branch("eclLMType", "std::vector<int>", &m_eclLMType);
577  m_tree->Branch("eclLMCellId", "std::vector<int>", &m_eclLMCellId);
578 
579  m_tree->Branch("eclClusterMultip", &m_eclClusterMultip, "eclClusterMultip/I");
580  m_tree->Branch("eclClusterTrueMultip", &m_eclClusterTrueMultip, "eclClusterTrueMultip/I");
581  m_tree->Branch("eclClusterGammaMultip", &m_eclClusterGammaMultip, "eclClusterGammaMultip/I");
582  m_tree->Branch("eclClusterIdx", "std::vector<int>", &m_eclClusterIdx);
583  m_tree->Branch("eclClusterToMC1", "std::vector<int>", &m_eclClusterToMC1);
584  m_tree->Branch("eclClusterToMCWeight1", "std::vector<double>", &m_eclClusterToMCWeight1);
585  m_tree->Branch("eclClusterToMC1PDG", "std::vector<int>", &m_eclClusterToMC1PDG);
586  m_tree->Branch("eclClusterToMC2", "std::vector<int>", &m_eclClusterToMC2);
587  m_tree->Branch("eclClusterToMCWeight2", "std::vector<double>", &m_eclClusterToMCWeight2);
588  m_tree->Branch("eclClusterToMC2PDG", "std::vector<int>", &m_eclClusterToMC2PDG);
589  m_tree->Branch("eclClusterToMC3", "std::vector<int>", &m_eclClusterToMC3);
590  m_tree->Branch("eclClusterToMCWeight3", "std::vector<double>", &m_eclClusterToMCWeight3);
591  m_tree->Branch("eclClusterToMC3PDG", "std::vector<int>", &m_eclClusterToMC3PDG);
592  m_tree->Branch("eclClusterToMC4", "std::vector<int>", &m_eclClusterToMC4);
593  m_tree->Branch("eclClusterToMCWeight4", "std::vector<double>", &m_eclClusterToMCWeight4);
594  m_tree->Branch("eclClusterToMC4PDG", "std::vector<int>", &m_eclClusterToMC4PDG);
595  m_tree->Branch("eclClusterToMC5", "std::vector<int>", &m_eclClusterToMC5);
596  m_tree->Branch("eclClusterToMCWeight5", "std::vector<double>", &m_eclClusterToMCWeight5);
597  m_tree->Branch("eclClusterToMC5PDG", "std::vector<int>", &m_eclClusterToMC5PDG);
598  m_tree->Branch("eclClusterToBkgWeight", "std::vector<double>", &m_eclClusterToBkgWeight);
599  m_tree->Branch("eclClusterSimHitSum", "std::vector<double>", &m_eclClusterSimHitSum);
600  m_tree->Branch("eclClusterToShower", "std::vector<int>", &m_eclClusterToShower);
601  m_tree->Branch("eclClusterEnergy", "std::vector<double>", &m_eclClusterEnergy);
602  m_tree->Branch("eclClusterEnergyError", "std::vector<double>", &m_eclClusterEnergyError);
603  m_tree->Branch("eclClusterTheta", "std::vector<double>", &m_eclClusterTheta);
604  m_tree->Branch("eclClusterThetaError", "std::vector<double>", &m_eclClusterThetaError);
605  m_tree->Branch("eclClusterPhi", "std::vector<double>", &m_eclClusterPhi);
606  m_tree->Branch("eclClusterPhiError", "std::vector<double>", &m_eclClusterPhiError);
607  m_tree->Branch("eclClusterR", "std::vector<double>", &m_eclClusterR);
608  m_tree->Branch("eclClusterEnergyDepSum", "std::vector<double>", &m_eclClusterEnergyDepSum);
609  m_tree->Branch("eclClusterTiming", "std::vector<double>", &m_eclClusterTiming);
610  m_tree->Branch("eclClusterTimingError", "std::vector<double>", &m_eclClusterTimingError);
611  m_tree->Branch("eclClusterE9oE21", "std::vector<double>", &m_eclClusterE9oE21);
612  m_tree->Branch("eclClusterHighestE", "std::vector<double>", &m_eclClusterHighestE);
613  m_tree->Branch("eclClusterCellId", "std::vector<int>", &m_eclClusterCellId);
614  m_tree->Branch("eclClusterNofCrystals", "std::vector<int>", &m_eclClusterNofCrystals);
615  m_tree->Branch("eclClusterCrystalHealth", "std::vector<int>", &m_eclClusterCrystalHealth);
616  m_tree->Branch("eclClusterIsTrack", "std::vector<bool>", &m_eclClusterIsTrack);
617  m_tree->Branch("eclClusterClosestTrackDist", "std::vector<double>", &m_eclClusterClosestTrackDist);
618  m_tree->Branch("eclClusterDeltaL", "std::vector<double>", &m_eclClusterDeltaL);
619  m_tree->Branch("eclClusterAbsZernike40", "std::vector<double>", &m_eclClusterAbsZernike40);
620  m_tree->Branch("eclClusterAbsZernike51", "std::vector<double>", &m_eclClusterAbsZernike51);
621  m_tree->Branch("eclClusterZernikeMVA", "std::vector<double>", &m_eclClusterZernikeMVA);
622  m_tree->Branch("eclClusterE1oE9", "std::vector<double>", &m_eclClusterE1oE9);
623  m_tree->Branch("eclClusterSecondMoment", "std::vector<double>", &m_eclClusterSecondMoment);
624  m_tree->Branch("eclClusterLAT", "std::vector<double>", &m_eclClusterLAT);
625  m_tree->Branch("eclClusterDeltaTime99", "std::vector<double>", &m_eclClusterDeltaTime99);
626  m_tree->Branch("eclClusterDetectorRegion", "std::vector<int>", &m_eclClusterDetectorRegion);
627  m_tree->Branch("eclClusterHasNPhotonHypothesis", "std::vector<int>", &m_eclClusterHasNPhotonHypothesis);
628  m_tree->Branch("eclClusterHasNeutralHadronHypothesis", "std::vector<int>", &m_eclClusterHasNeutralHadronHypothesis);
629 
630  if (m_doPureCsI == true) {
631  m_tree->Branch("eclHitToPureDigit", "std::vector<int>", &m_eclHitToPureDigit);
632  m_tree->Branch("eclHitToPureDigitAmp", "std::vector<int>", &m_eclHitToPureDigitAmp);
633  //Pure Digit
634  m_tree->Branch("eclPureDigitMultip", &m_eclPureDigitMultip, "eclPureDigit_Multip/I");
635  m_tree->Branch("eclPureDigitIdx", "std::vector<int>", &m_eclPureDigitIdx);
636  m_tree->Branch("eclPureDigitToMC", "std::vector<int>", &m_eclPureDigitToMC);
637  m_tree->Branch("eclPureDigitCellId", "std::vector<int>", &m_eclPureDigitCellId);
638  m_tree->Branch("eclPureDigitAmp", "std::vector<int>", &m_eclPureDigitAmp);
639  m_tree->Branch("eclPureDigitTimeFit", "std::vector<int>", &m_eclPureDigitTimeFit);
640  m_tree->Branch("eclPureDigitFitQuality", "std::vector<int>", &m_eclPureDigitFitQuality);
641  m_tree->Branch("eclPureDigitToCluster", "std::vector<int>", &m_eclPureDigitToCluster);
642  //Pure CalDigit
643  m_tree->Branch("eclPureCalDigitMultip", &m_eclPureCalDigitMultip, "eclPureCalDigit_Multip/I");
644  m_tree->Branch("eclPureCalDigitIdx", "std::vector<int>", &m_eclPureCalDigitIdx);
645  m_tree->Branch("eclPureCalDigitToMC1", "std::vector<int>", &m_eclPureCalDigitToMC1);
646  m_tree->Branch("eclPureCalDigitToMC1PDG", "std::vector<int>", &m_eclPureCalDigitToMC1PDG);
647  m_tree->Branch("eclPureCalDigitToMCWeight1", "std::vector<double>", &m_eclPureCalDigitToMCWeight1);
648  m_tree->Branch("eclPureCalDigitToMC2", "std::vector<int>", &m_eclPureCalDigitToMC2);
649  m_tree->Branch("eclPureCalDigitToMC2PDG", "std::vector<int>", &m_eclPureCalDigitToMC2PDG);
650  m_tree->Branch("eclPureCalDigitToMCWeight2", "std::vector<double>", &m_eclPureCalDigitToMCWeight2);
651  m_tree->Branch("eclPureCalDigitToMC3", "std::vector<int>", &m_eclPureCalDigitToMC3);
652  m_tree->Branch("eclPureCalDigitToMC3PDG", "std::vector<int>", &m_eclPureCalDigitToMC3PDG);
653  m_tree->Branch("eclPureCalDigitToMCWeight3", "std::vector<double>", &m_eclPureCalDigitToMCWeight3);
654  m_tree->Branch("eclPureCalDigitToMC4", "std::vector<int>", &m_eclPureCalDigitToMC4);
655  m_tree->Branch("eclPureCalDigitToMC4PDG", "std::vector<int>", &m_eclPureCalDigitToMC4PDG);
656  m_tree->Branch("eclPureCalDigitToMCWeight4", "std::vector<double>", &m_eclPureCalDigitToMCWeight4);
657  m_tree->Branch("eclPureCalDigitToMC5", "std::vector<int>", &m_eclPureCalDigitToMC5);
658  m_tree->Branch("eclPureCalDigitToMC5PDG", "std::vector<int>", &m_eclPureCalDigitToMC5PDG);
659  m_tree->Branch("eclPureCalDigitToMCWeight5", "std::vector<double>", &m_eclPureCalDigitToMCWeight5);
660  m_tree->Branch("eclPureCalDigitToBkgWeight", "std::vector<double>", &m_eclPureCalDigitToBkgWeight);
661  m_tree->Branch("eclPureCalDigitSimHitSum", "std::vector<double>", &m_eclPureCalDigitSimHitSum);
662  m_tree->Branch("eclPureCalDigitToShower", "std::vector<int>", &m_eclPureCalDigitToShower);
663  m_tree->Branch("eclPureCalDigitCellId", "std::vector<int>", &m_eclPureCalDigitCellId);
664  m_tree->Branch("eclPureCalDigitAmp", "std::vector<double>", &m_eclPureCalDigitAmp);
665  m_tree->Branch("eclPureCalDigitTimeFit", "std::vector<double>", &m_eclPureCalDigitTimeFit);
666  m_tree->Branch("eclPureCalDigitFitQuality", "std::vector<int>", &m_eclPureCalDigitFitQuality);
667  m_tree->Branch("eclPureCalDigitToCR", "std::vector<int>", &m_eclPureCalDigitToCR);
668  m_tree->Branch("eclPureCalDigitToLM", "std::vector<int>", &m_eclPureCalDigitToLM);
669  m_tree->Branch("eclPureLMMultip", &m_eclPureLMMultip, "eclPureLMMultip/I");
670 
671  m_tree->Branch("eclPureCRIdx", "std::vector<int>", &m_eclPureCRIdx);
672  m_tree->Branch("eclPureCRIsTrack", "std::vector<int>", &m_eclPureCRIsTrack);
673  m_tree->Branch("eclPureCRLikelihoodMIPNGamma", "std::vector<double>", &m_eclPureCRLikelihoodMIPNGamma);
674  m_tree->Branch("eclPureCRLikelihoodChargedHadron", "std::vector<double>", &m_eclPureCRLikelihoodChargedHadron);
675  m_tree->Branch("eclPureCRLikelihoodElectronNGamma", "std::vector<double>", &m_eclPureCRLikelihoodElectronNGamma);
676  m_tree->Branch("eclPureCRLikelihoodNGamma", "std::vector<double>", &m_eclPureCRLikelihoodNGamma);
677  m_tree->Branch("eclPureCRLikelihoodNeutralHadron", "std::vector<double>", &m_eclPureCRLikelihoodNeutralHadron);
678  m_tree->Branch("eclPureCRLikelihoodMergedPi0", "std::vector<double>", &m_eclPureCRLikelihoodMergedPi0);
679 
680  m_tree->Branch("eclPureLMId", "std::vector<int>", &m_eclPureLMId);
681  m_tree->Branch("eclPureLMType", "std::vector<int>", &m_eclPureLMType);
682  m_tree->Branch("eclPureLMCellId", "std::vector<int>", &m_eclPureLMCellId);
683  //Pure Clusters
684  m_tree->Branch("eclPureClusterMultip", &m_eclPureClusterMultip, "eclPureClusterMultip/I");
685  m_tree->Branch("eclPureClusterIdx", "std::vector<int>", &m_eclPureClusterIdx);
686  m_tree->Branch("eclPureClusterToMC1", "std::vector<int>", &m_eclPureClusterToMC1);
687  m_tree->Branch("eclPureClusterToMCWeight1", "std::vector<double>", &m_eclPureClusterToMCWeight1);
688  m_tree->Branch("eclPureClusterToMC1PDG", "std::vector<int>", &m_eclPureClusterToMC1PDG);
689  m_tree->Branch("eclPureClusterToMC2", "std::vector<int>", &m_eclPureClusterToMC2);
690  m_tree->Branch("eclPureClusterToMCWeight2", "std::vector<double>", &m_eclPureClusterToMCWeight2);
691  m_tree->Branch("eclPureClusterToMC2PDG", "std::vector<int>", &m_eclPureClusterToMC2PDG);
692  m_tree->Branch("eclPureClusterToMC3", "std::vector<int>", &m_eclPureClusterToMC3);
693  m_tree->Branch("eclPureClusterToMCWeight3", "std::vector<double>", &m_eclPureClusterToMCWeight3);
694  m_tree->Branch("eclPureClusterToMC3PDG", "std::vector<int>", &m_eclPureClusterToMC3PDG);
695  m_tree->Branch("eclPureClusterToMC4", "std::vector<int>", &m_eclPureClusterToMC4);
696  m_tree->Branch("eclPureClusterToMCWeight4", "std::vector<double>", &m_eclPureClusterToMCWeight4);
697  m_tree->Branch("eclPureClusterToMC4PDG", "std::vector<int>", &m_eclPureClusterToMC4PDG);
698  m_tree->Branch("eclPureClusterToMC5", "std::vector<int>", &m_eclPureClusterToMC5);
699  m_tree->Branch("eclPureClusterToMCWeight5", "std::vector<double>", &m_eclPureClusterToMCWeight5);
700  m_tree->Branch("eclPureClusterToMC5PDG", "std::vector<int>", &m_eclPureClusterToMC5PDG);
701  m_tree->Branch("eclPureClusterToBkgWeight", "std::vector<double>", &m_eclPureClusterToBkgWeight);
702  m_tree->Branch("eclPureClusterEnergy", "std::vector<double>", &m_eclPureClusterEnergy);
703  m_tree->Branch("eclPureClusterEnergyError", "std::vector<double>", &m_eclPureClusterEnergyError);
704  m_tree->Branch("eclPureClusterTheta", "std::vector<double>", &m_eclPureClusterTheta);
705  m_tree->Branch("eclPureClusterThetaError", "std::vector<double>", &m_eclPureClusterThetaError);
706  m_tree->Branch("eclPureClusterPhi", "std::vector<double>", &m_eclPureClusterPhi);
707  m_tree->Branch("eclPureClusterPhiError", "std::vector<double>", &m_eclPureClusterPhiError);
708  m_tree->Branch("eclPureClusterR", "std::vector<double>", &m_eclPureClusterR);
709  m_tree->Branch("eclPureClusterEnergyDepSum", "std::vector<double>", &m_eclPureClusterEnergyDepSum);
710  m_tree->Branch("eclPureClusterTiming", "std::vector<double>", &m_eclPureClusterTiming);
711  m_tree->Branch("eclPureClusterTimingError", "std::vector<double>", &m_eclPureClusterTimingError);
712  m_tree->Branch("eclPureClusterE9oE21", "std::vector<double>", &m_eclPureClusterE9oE21);
713  m_tree->Branch("eclPureClusterHighestE", "std::vector<double>", &m_eclPureClusterHighestE);
714  m_tree->Branch("eclPureClusterCellId", "std::vector<int>", &m_eclPureClusterCellId);
715  m_tree->Branch("eclPureClusterLat", "std::vector<double>", &m_eclPureClusterLat);
716  m_tree->Branch("eclPureClusterNofCrystals", "std::vector<int>", &m_eclPureClusterNofCrystals);
717  m_tree->Branch("eclPureClusterCrystalHealth", "std::vector<int>", &m_eclPureClusterCrystalHealth);
718  m_tree->Branch("eclPureClusterClosestTrackDist", "std::vector<double>", &m_eclPureClusterClosestTrackDist);
719  m_tree->Branch("eclPureClusterAbsZernike40", "std::vector<double>", &m_eclPureClusterAbsZernike40);
720  m_tree->Branch("eclPureClusterAbsZernike51", "std::vector<double>", &m_eclPureClusterAbsZernike51);
721  m_tree->Branch("eclPureClusterZernikeMVA", "std::vector<double>", &m_eclPureClusterZernikeMVA);
722  m_tree->Branch("eclPureClusterSecondMoment", "std::vector<double>", &m_eclPureClusterSecondMoment);
723  m_tree->Branch("eclPureClusterIsTrack", "std::vector<bool>", &m_eclPureClusterIsTrack);
724  m_tree->Branch("eclPureClusterDeltaL", "std::vector<double>", &m_eclPureClusterDeltaL);
725  m_tree->Branch("eclPureClusterE1oE9", "std::vector<double>", &m_eclPureClusterE1oE9);
726  m_tree->Branch("eclPureClusterDeltaTime99", "std::vector<double>", &m_eclPureClusterDeltaTime99);
727  m_tree->Branch("eclPureClusterDetectorRegion", "std::vector<int>", &m_eclPureClusterDetectorRegion);
728  m_tree->Branch("eclPureClusterHasNPhotonHypothesis", "std::vector<int>", &m_eclPureClusterHasNPhotonHypothesis);
729  m_tree->Branch("eclPureClusterHasNeutralHadronHypothesis", "std::vector<int>", &m_eclPureClusterHasNeutralHadronHypothesis);
730  }
731 
733  m_tree->Branch("eclShowerMultip", &m_eclShowerMultip, "eclShowerMultip/I");
734  m_tree->Branch("eclShowerIdx", "std::vector<int>", &m_eclShowerIdx);
735  m_tree->Branch("eclShowerToMC1", "std::vector<int>", &m_eclShowerToMC1);
736  m_tree->Branch("eclShowerToMCWeight1", "std::vector<double>", &m_eclShowerToMCWeight1);
737  m_tree->Branch("eclShowerToMC1PDG", "std::vector<int>", &m_eclShowerToMC1PDG);
738  m_tree->Branch("eclShowerToMC1Moth", "std::vector<int>", &m_eclShowerToMC1Moth);
739  m_tree->Branch("eclShowerToMC1MothPDG", "std::vector<int>", &m_eclShowerToMC1MothPDG);
740  m_tree->Branch("eclShowerToMC1GMoth", "std::vector<int>", &m_eclShowerToMC1GMoth);
741  m_tree->Branch("eclShowerToMC1GMothPDG", "std::vector<int>", &m_eclShowerToMC1GMothPDG);
742  m_tree->Branch("eclShowerToMC2", "std::vector<int>", &m_eclShowerToMC2);
743  m_tree->Branch("eclShowerToMCWeight2", "std::vector<double>", &m_eclShowerToMCWeight2);
744  m_tree->Branch("eclShowerToMC2PDG", "std::vector<int>", &m_eclShowerToMC2PDG);
745  m_tree->Branch("eclShowerToMC2Moth", "std::vector<int>", &m_eclShowerToMC2Moth);
746  m_tree->Branch("eclShowerToMC2MothPDG", "std::vector<int>", &m_eclShowerToMC2MothPDG);
747  m_tree->Branch("eclShowerToMC2GMoth", "std::vector<int>", &m_eclShowerToMC2GMoth);
748  m_tree->Branch("eclShowerToMC2GMothPDG", "std::vector<int>", &m_eclShowerToMC2GMothPDG);
749  m_tree->Branch("eclShowerToMC3", "std::vector<int>", &m_eclShowerToMC3);
750  m_tree->Branch("eclShowerToMCWeight3", "std::vector<double>", &m_eclShowerToMCWeight3);
751  m_tree->Branch("eclShowerToMC3PDG", "std::vector<int>", &m_eclShowerToMC3PDG);
752  m_tree->Branch("eclShowerToMC3Moth", "std::vector<int>", &m_eclShowerToMC3Moth);
753  m_tree->Branch("eclShowerToMC3MothPDG", "std::vector<int>", &m_eclShowerToMC3MothPDG);
754  m_tree->Branch("eclShowerToMC3GMoth", "std::vector<int>", &m_eclShowerToMC3GMoth);
755  m_tree->Branch("eclShowerToMC3GMothPDG", "std::vector<int>", &m_eclShowerToMC3GMothPDG);
756  m_tree->Branch("eclShowerToMC4", "std::vector<int>", &m_eclShowerToMC4);
757  m_tree->Branch("eclShowerToMCWeight4", "std::vector<double>", &m_eclShowerToMCWeight4);
758  m_tree->Branch("eclShowerToMC4PDG", "std::vector<int>", &m_eclShowerToMC4PDG);
759  m_tree->Branch("eclShowerToMC4Moth", "std::vector<int>", &m_eclShowerToMC4Moth);
760  m_tree->Branch("eclShowerToMC4MothPDG", "std::vector<int>", &m_eclShowerToMC4MothPDG);
761  m_tree->Branch("eclShowerToMC4GMoth", "std::vector<int>", &m_eclShowerToMC4GMoth);
762  m_tree->Branch("eclShowerToMC4GMothPDG", "std::vector<int>", &m_eclShowerToMC4GMothPDG);
763  m_tree->Branch("eclShowerToMC5", "std::vector<int>", &m_eclShowerToMC5);
764  m_tree->Branch("eclShowerToMCWeight5", "std::vector<double>", &m_eclShowerToMCWeight5);
765  m_tree->Branch("eclShowerToMC5PDG", "std::vector<int>", &m_eclShowerToMC5PDG);
766  m_tree->Branch("eclShowerToMC5Moth", "std::vector<int>", &m_eclShowerToMC5Moth);
767  m_tree->Branch("eclShowerToMC5MothPDG", "std::vector<int>", &m_eclShowerToMC5MothPDG);
768  m_tree->Branch("eclShowerToMC5GMoth", "std::vector<int>", &m_eclShowerToMC5GMoth);
769  m_tree->Branch("eclShowerToMC5GMothPDG", "std::vector<int>", &m_eclShowerToMC5GMothPDG);
770  m_tree->Branch("eclShowerToBkgWeight", "std::vector<double>", &m_eclShowerToBkgWeight);
771  m_tree->Branch("eclShowerToLM1", "std::vector<int>", &m_eclShowerToLM1);
772  m_tree->Branch("eclShowerToLM2", "std::vector<int>", &m_eclShowerToLM2);
773  m_tree->Branch("eclShowerToLM3", "std::vector<int>", &m_eclShowerToLM3);
774  m_tree->Branch("eclShowerToLM4", "std::vector<int>", &m_eclShowerToLM4);
775  m_tree->Branch("eclShowerToLM5", "std::vector<int>", &m_eclShowerToLM5);
776  m_tree->Branch("eclShowerSimHitSum", "std::vector<double>", &m_eclShowerSimHitSum);
777  m_tree->Branch("eclShowerEnergy", "std::vector<double>", &m_eclShowerEnergy);
778  m_tree->Branch("eclShowerUncEnergy", "std::vector<double>", &m_eclShowerUncEnergy);
779  m_tree->Branch("eclShowerTheta", "std::vector<double>", &m_eclShowerTheta);
780  m_tree->Branch("eclShowerPhi", "std::vector<double>", &m_eclShowerPhi);
781  m_tree->Branch("eclShowerR", "std::vector<double>", &m_eclShowerR);
782  m_tree->Branch("eclShowerNHits", "std::vector<double>", &m_eclShowerNHits);
783  m_tree->Branch("eclShowerE9oE21", "std::vector<double>", &m_eclShowerE9oE21);
784  m_tree->Branch("eclShowerTime", "std::vector<double>", &m_eclShowerTime);
785  m_tree->Branch("eclShowerT99", "std::vector<double>", &m_eclShowerT99);
786  m_tree->Branch("eclShowerConnectedRegionId", "std::vector<int>", &m_eclShowerConnectedRegionId);
787  m_tree->Branch("eclShowerHypothesisId", "std::vector<int>", &m_eclShowerHypothesisId);
788  m_tree->Branch("eclShowerCentralCellId", "std::vector<int>", &m_eclShowerCentralCellId);
789  m_tree->Branch("eclShowerEnergyError", "std::vector<double>", &m_eclShowerEnergyError);
790  m_tree->Branch("eclShowerThetaError", "std::vector<double>", &m_eclShowerThetaError);
791  m_tree->Branch("eclShowerPhiError", "std::vector<double>", &m_eclShowerPhiError);
792  m_tree->Branch("eclShowerTimeResolution", "std::vector<double>", &m_eclShowerTimeResolution);
793  m_tree->Branch("eclShowerHighestEnergy", "std::vector<double>", &m_eclShowerHighestEnergy);
794  m_tree->Branch("eclShowerLateralEnergy", "std::vector<double>", &m_eclShowerLateralEnergy);
795  m_tree->Branch("eclShowerMinTrkDistance", "std::vector<double>", &m_eclShowerMinTrkDistance);
796  m_tree->Branch("eclShowerTrkDepth", "std::vector<double>", &m_eclShowerTrkDepth);
797  m_tree->Branch("eclShowerShowerDepth", "std::vector<double>", &m_eclShowerShowerDepth);
798  m_tree->Branch("eclShowerAbsZernike40", "std::vector<double>", &m_eclShowerAbsZernike40);
799  m_tree->Branch("eclShowerAbsZernike51", "std::vector<double>", &m_eclShowerAbsZernike51);
800  m_tree->Branch("eclShowerZernikeMVA", "std::vector<double>", &m_eclShowerZernikeMVA);
801  m_tree->Branch("eclShowerSecondMoment", "std::vector<double>", &m_eclShowerSecondMoment);
802  m_tree->Branch("eclShowerE1oE9", "std::vector<double>", &m_eclShowerE1oE9);
803  m_tree->Branch("eclShowerIsTrack", "std::vector<int>", &m_eclShowerIsTrack);
804  m_tree->Branch("eclShowerIsCluster", "std::vector<bool>", &m_eclShowerIsCluster);
805  m_tree->Branch("eclShowerMCVtxInEcl", "std::vector<int>", &m_eclShowerMCVtxInEcl);
806  m_tree->Branch("eclShowerMCFlightMatch", "std::vector<int>", &m_eclShowerMCFlightMatch);
807  m_tree->Branch("eclShowerMCFFlightMatch", "std::vector<int>", &m_eclShowerMCFFlightMatch);
808  m_tree->Branch("eclShowerHighestE1mE2", "std::vector<double>", &m_eclShowerHighestE1mE2);
809  m_tree->Branch("eclShowerNumberOfCrystalsForEnergy", "std::vector<double>", &m_eclShowerNumberOfCrystalsForEnergy);
810 
811  //MC Truth
812  m_tree->Branch("mcMultip", &m_mcMultip, "mcMultip/I");
813  m_tree->Branch("mcIdx", "std::vector<int>", &m_mcIdx);
814  m_tree->Branch("mcPdg", "std::vector<int>", &m_mcPdg);
815  m_tree->Branch("mcMothPdg", "std::vector<int>", &m_mcMothPdg);
816  m_tree->Branch("mcGMothPdg", "std::vector<int>", &m_mcGMothPdg);
817  m_tree->Branch("mcGGMothPdg", "std::vector<int>", &m_mcGGMothPdg);
818  m_tree->Branch("mcEnergy", "std::vector<double>", &m_mcEnergy);
819  m_tree->Branch("mcPx", "std::vector<double>", &m_mcPx);
820  m_tree->Branch("mcPy", "std::vector<double>", &m_mcPy);
821  m_tree->Branch("mcPz", "std::vector<double>", &m_mcPz);
822  m_tree->Branch("mcDecVtxx", "std::vector<double>", &m_mcDecayVtxX);
823  m_tree->Branch("mcDecVtxy", "std::vector<double>", &m_mcDecayVtxY);
824  m_tree->Branch("mcDecVtxz", "std::vector<double>", &m_mcDecayVtxZ);
825  m_tree->Branch("mcProdVtxx", "std::vector<double>", &m_mcProdVtxX);
826  m_tree->Branch("mcProdVtxy", "std::vector<double>", &m_mcProdVtxY);
827  m_tree->Branch("mcProdVtxz", "std::vector<double>", &m_mcProdVtxZ);
828  m_tree->Branch("mcSecProc", "std::vector<int>", &m_mcSecondaryPhysProc);
829 
830  if (m_doTracking == true) {
831  m_tree->Branch("trkMultip", &m_trkMultip, "trkMulti/I");
832  m_tree->Branch("trkIdx", "std::vector<int>", &m_trkIdx);
833  m_tree->Branch("trkPdg", "std::vector<int>", &m_trkPdg);
834  m_tree->Branch("trkCharge", "std::vector<int>", &m_trkCharge);
835  m_tree->Branch("trkPx", "std::vector<double>", &m_trkPx);
836  m_tree->Branch("trkPy", "std::vector<double>", &m_trkPy);
837  m_tree->Branch("trkPz", "std::vector<double>", &m_trkPz);
838  m_tree->Branch("trkP", "std::vector<double>", &m_trkP);
839  m_tree->Branch("trkTheta", "std::vector<double>", &m_trkTheta);
840  m_tree->Branch("trkPhi", "std::vector<double>", &m_trkPhi);
841  m_tree->Branch("trkPosx", "std::vector<double>", &m_trkX);
842  m_tree->Branch("trkPosy", "std::vector<double>", &m_trkY);
843  m_tree->Branch("trkPosz", "std::vector<double>", &m_trkZ);
844 
845  m_tree->Branch("eclpidtrkIdx", "std::vector<int>", &m_eclpidtrkIdx);
846  m_tree->Branch("eclpidEnergy", "std::vector<double>", &m_eclpidEnergy);
847  m_tree->Branch("eclpidEop", "std::vector<double>", &m_eclpidEop);
848  m_tree->Branch("eclpidE9E21", "std::vector<double>", &m_eclpidE9E21);
849  m_tree->Branch("eclpidNCrystals", "std::vector<int>", &m_eclpidNCrystals);
850  m_tree->Branch("eclpidNClusters", "std::vector<int>", &m_eclpidNClusters);
851  m_tree->Branch("eclLogLikeEl", "std::vector<double>", &m_eclLogLikeEl);
852  m_tree->Branch("eclLogLikeMu", "std::vector<double>", &m_eclLogLikeMu);
853  m_tree->Branch("eclLogLikePi", "std::vector<double>", &m_eclLogLikePi);
854  }
855 
856  B2INFO("[ECLDataAnalysis Module]: Initialization of ECLDataAnalysis Module completed.");
857 
858 }
859 
860 void ECLDataAnalysisModule::beginRun()
861 {
862 }
863 
864 
865 void ECLDataAnalysisModule::event()
866 {
867 
868  B2DEBUG(1, " ++++++++++++++ ECLDataAnalysisModule");
869 
870  //EventLevelClusteringInfo
871  m_nECLCalDigitsOutOfTimeFWD = 0;
872  m_nECLCalDigitsOutOfTimeBarrel = 0;
873  m_nECLCalDigitsOutOfTimeBWD = 0;
874  m_nECLShowersRejectedFWD = 0;
875  m_nECLShowersRejectedBarrel = 0;
876  m_nECLShowersRejectedBWD = 0;
877 
878  if (m_doDigits == 1) {
880  m_eclDigitMultip = 0;
881  m_eclDigitIdx->clear();
882  m_eclDigitToMC->clear();
883  m_eclDigitCellId->clear();
884  m_eclDigitAmp->clear();
885  m_eclDigitTimeFit->clear();
886  m_eclDigitFitQuality->clear();
887  m_eclDigitToCalDigit->clear();
888 
890  m_eclCalDigitMultip = 0;
891  m_eclCalDigitCellId->clear();
892  m_eclCalDigitAmp->clear();
893  m_eclCalDigitTimeFit->clear();
894  m_eclCalDigitFitQuality->clear();
895  m_eclCalDigitIdx->clear();
896  m_eclCalDigitToMC1->clear();
897  m_eclCalDigitToMCWeight1->clear();
898  m_eclCalDigitToMC2->clear();
899  m_eclCalDigitToMCWeight2->clear();
900  m_eclCalDigitToMC3->clear();
901  m_eclCalDigitToMCWeight3->clear();
902  m_eclCalDigitToMC4->clear();
903  m_eclCalDigitToMCWeight4->clear();
904  m_eclCalDigitToMC5->clear();
905  m_eclCalDigitToMCWeight5->clear();
906  m_eclCalDigitToMC1PDG->clear();
907  m_eclCalDigitToMC2PDG->clear();
908  m_eclCalDigitToMC3PDG->clear();
909  m_eclCalDigitToMC4PDG->clear();
910  m_eclCalDigitToMC5PDG->clear();
911  m_eclCalDigitToBkgWeight->clear();
912  m_eclCalDigitSimHitSum->clear();
913  m_eclCalDigitToShower->clear();
914  m_eclCalDigitToCR->clear();
915  m_eclCalDigitToLM->clear();
916  }
917 
918  m_eclCRIdx->clear();
919  m_eclCRIsTrack->clear();
920  m_eclCRLikelihoodMIPNGamma->clear();
921  m_eclCRLikelihoodChargedHadron->clear();
922  m_eclCRLikelihoodElectronNGamma->clear();
923  m_eclCRLikelihoodNGamma->clear();
924  m_eclCRLikelihoodNeutralHadron->clear();
925  m_eclCRLikelihoodMergedPi0->clear();
926 
927  if (m_doHits == 1) {
928  //SimHit
929  m_eclSimHitMultip = 0;
930  m_eclSimHitCellId->clear();
931  m_eclSimHitPdg->clear();
932  m_eclSimHitEnergyDep->clear();
933  m_eclSimHitFlightTime->clear();
934  m_eclSimHitIdx->clear();
935  m_eclSimHitToMC->clear();
936  m_eclSimHitX->clear();
937  m_eclSimHitY->clear();
938  m_eclSimHitZ->clear();
939  m_eclSimHitPx->clear();
940  m_eclSimHitPy->clear();
941  m_eclSimHitPz->clear();
942 
944  m_eclHitMultip = 0;
945  m_eclHitCellId->clear();
946  m_eclHitEnergyDep->clear();
947  m_eclHitTimeAve->clear();
948  m_eclHitIdx->clear();
949  m_eclHitToMC->clear();
950  m_eclHitToDigit->clear();
951  m_eclHitToDigitAmp->clear();
952  }
953 
954  m_eclLMMultip = 0;
955  m_eclLMId->clear();
956  m_eclLMType->clear();
957  m_eclLMCellId->clear();
958 
960  m_eclClusterMultip = 0;
961  m_eclClusterTrueMultip = 0;
962  m_eclClusterGammaMultip = 0;
963  m_eclClusterEnergy->clear();
964  m_eclClusterEnergyError->clear();
965  m_eclClusterTheta->clear();
966  m_eclClusterThetaError->clear();
967  m_eclClusterPhi->clear();
968  m_eclClusterPhiError->clear();
969  m_eclClusterR->clear();
970  m_eclClusterIdx->clear();
971  m_eclClusterToMC1->clear();
972  m_eclClusterToMCWeight1->clear();
973  m_eclClusterToMC1PDG->clear();
974  m_eclClusterToMC2->clear();
975  m_eclClusterToMCWeight2->clear();
976  m_eclClusterToMC2PDG->clear();
977  m_eclClusterToMC3->clear();
978  m_eclClusterToMCWeight3->clear();
979  m_eclClusterToMC3PDG->clear();
980  m_eclClusterToMC4->clear();
981  m_eclClusterToMCWeight4->clear();
982  m_eclClusterToMC4PDG->clear();
983  m_eclClusterToMC5->clear();
984  m_eclClusterToMCWeight5->clear();
985  m_eclClusterToMC5PDG->clear();
986  m_eclClusterToBkgWeight->clear();
987  m_eclClusterSimHitSum->clear();
988  m_eclClusterEnergyDepSum->clear();
989  m_eclClusterTiming->clear();
990  m_eclClusterTimingError->clear();
991  m_eclClusterE9oE21->clear();
992  m_eclClusterHighestE->clear();
993  m_eclClusterCellId->clear();
994  m_eclClusterNofCrystals->clear();
995  m_eclClusterCrystalHealth->clear();
996  m_eclClusterIsTrack->clear();
997  m_eclClusterClosestTrackDist->clear();
998  m_eclClusterDeltaL->clear();
999  m_eclClusterToShower->clear();
1000  m_eclClusterAbsZernike40->clear();
1001  m_eclClusterAbsZernike51->clear();
1002  m_eclClusterZernikeMVA->clear();
1003  m_eclClusterE1oE9->clear();
1004  m_eclClusterSecondMoment->clear();
1005  m_eclClusterLAT->clear();
1006  m_eclClusterDeltaTime99->clear();
1007  m_eclClusterDetectorRegion->clear();
1008  m_eclClusterHasNPhotonHypothesis->clear();
1009  m_eclClusterHasNeutralHadronHypothesis->clear();
1010 
1012  m_eclShowerMultip = 0;
1013  m_eclShowerIdx->clear();
1014  m_eclShowerToMC1->clear();
1015  m_eclShowerToMCWeight1->clear();
1016  m_eclShowerToMC1PDG->clear();
1017  m_eclShowerToMC1Moth->clear();
1018  m_eclShowerToMC1MothPDG->clear();
1019  m_eclShowerToMC1GMoth->clear();
1020  m_eclShowerToMC1GMothPDG->clear();
1021  m_eclShowerToMC2->clear();
1022  m_eclShowerToMCWeight2->clear();
1023  m_eclShowerToMC2PDG->clear();
1024  m_eclShowerToMC2Moth->clear();
1025  m_eclShowerToMC2MothPDG->clear();
1026  m_eclShowerToMC2GMoth->clear();
1027  m_eclShowerToMC2GMothPDG->clear();
1028  m_eclShowerToMC3->clear();
1029  m_eclShowerToMCWeight3->clear();
1030  m_eclShowerToMC3PDG->clear();
1031  m_eclShowerToMC3Moth->clear();
1032  m_eclShowerToMC3MothPDG->clear();
1033  m_eclShowerToMC3GMoth->clear();
1034  m_eclShowerToMC3GMothPDG->clear();
1035  m_eclShowerToMC4->clear();
1036  m_eclShowerToMCWeight4->clear();
1037  m_eclShowerToMC4PDG->clear();
1038  m_eclShowerToMC4Moth->clear();
1039  m_eclShowerToMC4MothPDG->clear();
1040  m_eclShowerToMC4GMoth->clear();
1041  m_eclShowerToMC4GMothPDG->clear();
1042  m_eclShowerToMC5->clear();
1043  m_eclShowerToMCWeight5->clear();
1044  m_eclShowerToMC5PDG->clear();
1045  m_eclShowerToMC5Moth->clear();
1046  m_eclShowerToMC5MothPDG->clear();
1047  m_eclShowerToMC5GMoth->clear();
1048  m_eclShowerToMC5GMothPDG->clear();
1049  m_eclShowerToBkgWeight->clear();
1050  m_eclShowerToLM1->clear();
1051  m_eclShowerToLM2->clear();
1052  m_eclShowerToLM3->clear();
1053  m_eclShowerToLM4->clear();
1054  m_eclShowerToLM5->clear();
1055  m_eclShowerSimHitSum->clear();
1056  m_eclShowerUncEnergy->clear();
1057  m_eclShowerEnergy->clear();
1058  m_eclShowerTheta->clear();
1059  m_eclShowerPhi->clear();
1060  m_eclShowerR->clear();
1061  m_eclShowerNHits->clear();
1062  m_eclShowerE9oE21->clear();
1063  m_eclShowerTime->clear();
1064  m_eclShowerT99->clear();
1065  m_eclShowerConnectedRegionId->clear();
1066  m_eclShowerHypothesisId->clear();
1067  m_eclShowerCentralCellId->clear();
1068  m_eclShowerEnergyError->clear();
1069  m_eclShowerThetaError->clear();
1070  m_eclShowerPhiError->clear();
1071  m_eclShowerTimeResolution->clear();
1072  m_eclShowerHighestEnergy->clear();
1073  m_eclShowerLateralEnergy->clear();
1074  m_eclShowerMinTrkDistance->clear();
1075  m_eclShowerTrkDepth->clear();
1076  m_eclShowerShowerDepth->clear();
1077  m_eclShowerAbsZernike40->clear();
1078  m_eclShowerAbsZernike51->clear();
1079  m_eclShowerZernikeMVA->clear();
1080  m_eclShowerSecondMoment->clear();
1081  m_eclShowerE1oE9->clear();
1082  m_eclShowerIsTrack->clear();
1083  m_eclShowerIsCluster->clear();
1084  m_eclShowerMCVtxInEcl->clear();
1085  m_eclShowerMCFlightMatch->clear();
1086  m_eclShowerMCFFlightMatch->clear();
1087  m_eclShowerHighestE1mE2->clear();
1088  m_eclShowerNumberOfCrystalsForEnergy->clear();
1089 
1091  if (m_doPureCsI == true) {
1092  m_eclPureDigitMultip = 0;
1093  m_eclPureDigitIdx->clear();
1094  m_eclPureDigitToMC->clear();
1095  m_eclPureDigitCellId->clear();
1096  m_eclPureDigitAmp->clear();
1097  m_eclPureDigitTimeFit->clear();
1098  m_eclPureDigitFitQuality->clear();
1099  m_eclPureDigitToCluster->clear();
1100  m_eclHitToPureDigit->clear();
1101  m_eclHitToPureDigitAmp->clear();
1102 
1103  //Pure CalDigits
1104  m_eclPureCalDigitMultip = 0;
1105  m_eclPureCalDigitCellId->clear();
1106  m_eclPureCalDigitAmp->clear();
1107  m_eclPureCalDigitTimeFit->clear();
1108  m_eclPureCalDigitFitQuality->clear();
1109  m_eclPureCalDigitIdx->clear();
1110  m_eclPureCalDigitToMC1->clear();
1111  m_eclPureCalDigitToMCWeight1->clear();
1112  m_eclPureCalDigitToMC2->clear();
1113  m_eclPureCalDigitToMCWeight2->clear();
1114  m_eclPureCalDigitToMC3->clear();
1115  m_eclPureCalDigitToMCWeight3->clear();
1116  m_eclPureCalDigitToMC4->clear();
1117  m_eclPureCalDigitToMCWeight4->clear();
1118  m_eclPureCalDigitToMC5->clear();
1119  m_eclPureCalDigitToMCWeight5->clear();
1120  m_eclPureCalDigitToMC1PDG->clear();
1121  m_eclPureCalDigitToMC2PDG->clear();
1122  m_eclPureCalDigitToMC3PDG->clear();
1123  m_eclPureCalDigitToMC4PDG->clear();
1124  m_eclPureCalDigitToMC5PDG->clear();
1125  m_eclPureCalDigitToBkgWeight->clear();
1126  m_eclPureCalDigitSimHitSum->clear();
1127  m_eclPureCalDigitToShower->clear();
1128  m_eclPureCalDigitToCR->clear();
1129  m_eclPureCalDigitToLM->clear();
1130 
1131  m_eclPureCRIdx->clear();
1132  m_eclPureCRIsTrack->clear();
1133  m_eclPureCRLikelihoodMIPNGamma->clear();
1134  m_eclPureCRLikelihoodChargedHadron->clear();
1135  m_eclPureCRLikelihoodElectronNGamma->clear();
1136  m_eclPureCRLikelihoodNGamma->clear();
1137  m_eclPureCRLikelihoodNeutralHadron->clear();
1138  m_eclPureCRLikelihoodMergedPi0->clear();
1139 
1140  m_eclPureLMMultip = 0;
1141  m_eclPureLMId->clear();
1142  m_eclPureLMType->clear();
1143  m_eclPureLMCellId->clear();
1144 
1146  m_eclPureClusterMultip = 0;
1147  m_eclPureClusterToMC1->clear();
1148  m_eclPureClusterToMCWeight1->clear();
1149  m_eclPureClusterToMC1PDG->clear();
1150  m_eclPureClusterToMC2->clear();
1151  m_eclPureClusterToMCWeight2->clear();
1152  m_eclPureClusterToMC2PDG->clear();
1153  m_eclPureClusterToMC3->clear();
1154  m_eclPureClusterToMCWeight3->clear();
1155  m_eclPureClusterToMC3PDG->clear();
1156  m_eclPureClusterToMC4->clear();
1157  m_eclPureClusterToMCWeight4->clear();
1158  m_eclPureClusterToMC4PDG->clear();
1159  m_eclPureClusterToMC5->clear();
1160  m_eclPureClusterToMCWeight5->clear();
1161  m_eclPureClusterToMC5PDG->clear();
1162  m_eclPureClusterToBkgWeight->clear();
1163  m_eclPureClusterEnergy->clear();
1164  m_eclPureClusterEnergyError->clear();
1165  m_eclPureClusterTheta->clear();
1166  m_eclPureClusterEnergyDepSum->clear();
1167  m_eclPureClusterThetaError->clear();
1168  m_eclPureClusterPhi->clear();
1169  m_eclPureClusterPhiError->clear();
1170  m_eclPureClusterR->clear();
1171  m_eclPureClusterIdx->clear();
1172  m_eclPureClusterTiming->clear();
1173  m_eclPureClusterTimingError->clear();
1174  m_eclPureClusterE9oE21->clear();
1175  m_eclPureClusterHighestE->clear();
1176  m_eclPureClusterCellId->clear();
1177  m_eclPureClusterLat->clear();
1178  m_eclPureClusterNofCrystals->clear();
1179  m_eclPureClusterCrystalHealth->clear();
1180  m_eclPureClusterClosestTrackDist->clear();
1181  m_eclPureClusterAbsZernike40->clear();
1182  m_eclPureClusterAbsZernike51->clear();
1183  m_eclPureClusterZernikeMVA->clear();
1184  m_eclPureClusterSecondMoment->clear();
1185  m_eclPureClusterIsTrack->clear();
1186  m_eclPureClusterDeltaL->clear();
1187  m_eclPureClusterE1oE9->clear();
1188  m_eclPureClusterDeltaTime99->clear();
1189  m_eclPureClusterDetectorRegion->clear();
1190  m_eclPureClusterHasNPhotonHypothesis->clear();
1191  m_eclPureClusterHasNeutralHadronHypothesis->clear();
1192  }
1193 
1195  m_mcMultip = 0;
1196  m_mcIdx->clear();
1197  m_mcPdg->clear();
1198  m_mcMothPdg->clear();
1199  m_mcGMothPdg->clear();
1200  m_mcGGMothPdg->clear();
1201  m_mcEnergy->clear();
1202  m_mcPx->clear();
1203  m_mcPy->clear();
1204  m_mcPz->clear();
1205  m_mcDecayVtxX->clear();
1206  m_mcDecayVtxY->clear();
1207  m_mcDecayVtxZ->clear();
1208  m_mcProdVtxX->clear();
1209  m_mcProdVtxY->clear();
1210  m_mcProdVtxZ->clear();
1211  m_mcSecondaryPhysProc->clear();
1212 
1214  if (m_doTracking == true) {
1215  m_trkMultip = 0;
1216  m_trkIdx->clear();
1217  m_trkPdg->clear();
1218  m_trkCharge->clear();
1219  m_trkPx->clear();
1220  m_trkPy->clear();
1221  m_trkPz->clear();
1222  m_trkP->clear();
1223  m_trkPhi->clear();
1224  m_trkTheta->clear();
1225  m_trkPhi->clear();
1226  m_trkX->clear();
1227  m_trkY->clear();
1228  m_trkZ->clear();
1229 
1231  m_eclpidtrkIdx->clear();
1232  m_eclpidEnergy->clear();
1233  m_eclpidEop->clear();
1234  m_eclpidE9E21->clear();
1235  m_eclpidNCrystals->clear();
1236  m_eclpidNClusters->clear();
1237  m_eclLogLikeEl->clear();
1238  m_eclLogLikeMu->clear();
1239  m_eclLogLikePi->clear();
1240  }
1241 
1242 
1243  if (m_eventmetadata) {
1244  m_iExperiment = m_eventmetadata->getExperiment();
1245  m_iRun = m_eventmetadata->getRun();
1246  m_iEvent = m_eventmetadata->getEvent();
1247  } else {
1248  m_iExperiment = -1;
1249  m_iRun = -1;
1250  m_iEvent = -1;
1251  }
1252 
1253  //EventLevelClusteringInfo
1254  m_nECLCalDigitsOutOfTimeFWD = m_eventLevelClusteringInfo->getNECLCalDigitsOutOfTimeFWD();
1255  m_nECLCalDigitsOutOfTimeBarrel = m_eventLevelClusteringInfo->getNECLCalDigitsOutOfTimeBarrel();
1256  m_nECLCalDigitsOutOfTimeBWD = m_eventLevelClusteringInfo->getNECLCalDigitsOutOfTimeBWD();
1257  m_nECLShowersRejectedFWD = m_eventLevelClusteringInfo->getNECLShowersRejectedFWD();
1258  m_nECLShowersRejectedBarrel = m_eventLevelClusteringInfo->getNECLShowersRejectedBarrel();
1259  m_nECLShowersRejectedBWD = m_eventLevelClusteringInfo->getNECLShowersRejectedBWD();
1260 
1261  if (m_doDigits == 1) {
1262  //DIGITS
1263  m_eclDigitMultip = m_eclDigits.getEntries();
1264  for (int idigits = 0; idigits < m_eclDigits.getEntries() ; idigits++) {
1265  ECLDigit* aECLDigits = m_eclDigits[idigits];
1266  m_eclDigitIdx->push_back(idigits);
1267  m_eclDigitCellId->push_back(aECLDigits->getCellId());
1268  m_eclDigitAmp->push_back(aECLDigits->getAmp());
1269  m_eclDigitTimeFit->push_back(aECLDigits->getTimeFit());
1270  m_eclDigitFitQuality->push_back(aECLDigits->getQuality());
1271 
1272  if (aECLDigits->getRelated<MCParticle>() != (nullptr)) {
1273  const MCParticle* mc_digit = aECLDigits->getRelated<MCParticle>();
1274  m_eclDigitToMC->push_back(mc_digit->getArrayIndex());
1275  } else
1276  m_eclDigitToMC->push_back(-1);
1277 
1278  if (aECLDigits->getRelated<ECLCalDigit>() != (nullptr)) {
1279  const ECLCalDigit* cal_digit = aECLDigits->getRelated<ECLCalDigit>();
1280  m_eclDigitToCalDigit->push_back(cal_digit->getArrayIndex());
1281  } else
1282  m_eclDigitToCalDigit->push_back(-1);
1283  }
1284 
1285  //CAL DIGITS
1286  m_eclCalDigitMultip = m_eclCalDigits.getEntries();
1287  for (uint icaldigits = 0; icaldigits < (uint)m_eclCalDigits.getEntries() ; icaldigits++) {
1288  ECLCalDigit* aECLCalDigits = m_eclCalDigits[icaldigits];
1289 
1290  m_eclCalDigitIdx->push_back(icaldigits);
1291  m_eclCalDigitCellId->push_back(aECLCalDigits->getCellId());
1292  m_eclCalDigitAmp->push_back(aECLCalDigits->getEnergy());
1293  m_eclCalDigitTimeFit->push_back(aECLCalDigits->getTime());
1294  m_eclCalDigitFitQuality->push_back(aECLCalDigits->isFailedFit());
1295 
1296  double sumHit = 0;
1297  int idx[10];
1298  for (int i = 0; i < 10; i++)
1299  idx[i] = -1;
1300 
1301  double wi[10];
1302  for (int i = 0; i < 10; i++)
1303  wi[i] = -1;
1304 
1305  int ii = 0;
1306  sumHit = 0;
1307 
1308  auto digitMCRelations = aECLCalDigits->getRelationsTo<MCParticle>();
1309  for (unsigned int i = 0; i < digitMCRelations.size(); ++i) {
1310  if (ii < 10) {
1311  const auto mcParticle = digitMCRelations.object(i);
1312  idx[ii] = mcParticle->getIndex() - 1;
1313  wi[ii] = digitMCRelations.weight(i);
1314  sumHit = sumHit + digitMCRelations.weight(i);
1315  ii++;
1316  }
1317  }
1318 
1319  //Re-ordering based on contribution
1320  int y = 0;
1321  while (y < 10) {
1322  for (int i = 0; i < 9; i++) {
1323  if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1324  if (wi[i] < wi[i + 1]) {
1325  int temp = idx[i];
1326  idx[i] = idx[i + 1];
1327  idx[i + 1] = temp;
1328 
1329  double wtemp = wi[i];
1330  wi[i] = wi[i + 1];
1331  wi[i + 1] = wtemp;
1332  }
1333  }
1334  }
1335  y++;
1336  }
1337 
1338  m_eclCalDigitToBkgWeight->push_back(aECLCalDigits->getEnergy() - sumHit);
1339  m_eclCalDigitSimHitSum->push_back(sumHit);
1340  if (idx[0] > -1) {
1341  m_eclCalDigitToMCWeight1->push_back(wi[0]);
1342  m_eclCalDigitToMC1->push_back(idx[0]);
1343  MCParticle* amcParticle = m_mcParticles[idx[0]];
1344  m_eclCalDigitToMC1PDG->push_back(amcParticle->getPDG());
1345  } else {
1346  m_eclCalDigitToMCWeight1->push_back(-1);
1347  m_eclCalDigitToMC1->push_back(-1);
1348  m_eclCalDigitToMC1PDG->push_back(-1);
1349  }
1350  if (idx[1] > -1) {
1351  m_eclCalDigitToMCWeight2->push_back(wi[1]);
1352  m_eclCalDigitToMC2->push_back(idx[1]);
1353  MCParticle* amcParticle = m_mcParticles[idx[1]];
1354  m_eclCalDigitToMC2PDG->push_back(amcParticle->getPDG());
1355  } else {
1356  m_eclCalDigitToMCWeight2->push_back(-1);
1357  m_eclCalDigitToMC2->push_back(-1);
1358  m_eclCalDigitToMC2PDG->push_back(-1);
1359  }
1360  if (idx[2] > -1) {
1361  m_eclCalDigitToMCWeight3->push_back(wi[2]);
1362  m_eclCalDigitToMC3->push_back(idx[2]);
1363  MCParticle* amcParticle = m_mcParticles[idx[2]];
1364  m_eclCalDigitToMC3PDG->push_back(amcParticle->getPDG());
1365  } else {
1366  m_eclCalDigitToMCWeight3->push_back(-1);
1367  m_eclCalDigitToMC3->push_back(-1);
1368  m_eclCalDigitToMC3PDG->push_back(-1);
1369  }
1370  if (idx[3] > -1) {
1371  m_eclCalDigitToMCWeight4->push_back(wi[3]);
1372  m_eclCalDigitToMC4->push_back(idx[3]);
1373  MCParticle* amcParticle = m_mcParticles[idx[3]];
1374  m_eclCalDigitToMC4PDG->push_back(amcParticle->getPDG());
1375  } else {
1376  m_eclCalDigitToMCWeight4->push_back(-1);
1377  m_eclCalDigitToMC4->push_back(-1);
1378  m_eclCalDigitToMC4PDG->push_back(-1);
1379  }
1380  if (idx[4] > -1) {
1381  m_eclCalDigitToMCWeight5->push_back(wi[4]);
1382  m_eclCalDigitToMC5->push_back(idx[4]);
1383  MCParticle* amcParticle = m_mcParticles[idx[4]];
1384  m_eclCalDigitToMC5PDG->push_back(amcParticle->getPDG());
1385  } else {
1386  m_eclCalDigitToMCWeight5->push_back(-1);
1387  m_eclCalDigitToMC5->push_back(-1);
1388  m_eclCalDigitToMC5PDG->push_back(-1);
1389  }
1390 
1391  if (aECLCalDigits->getRelated<ECLShower>() != (nullptr)) {
1392  const ECLShower* shower_caldigit = aECLCalDigits->getRelated<ECLShower>();
1393  m_eclCalDigitToShower->push_back(shower_caldigit->getArrayIndex());
1394  } else
1395  m_eclCalDigitToShower->push_back(-1);
1396 
1397  if (aECLCalDigits->getRelated<ECLConnectedRegion>() != (nullptr)) {
1398  const ECLConnectedRegion* cr_caldigit = aECLCalDigits->getRelated<ECLConnectedRegion>();
1399  m_eclCalDigitToCR->push_back(cr_caldigit->getCRId());
1400  } else
1401  m_eclCalDigitToCR->push_back(-1);
1402 
1403  if (aECLCalDigits->getRelated<ECLLocalMaximum>() != (nullptr)) {
1404  const ECLLocalMaximum* lm_caldigit = aECLCalDigits->getRelated<ECLLocalMaximum>();
1405  m_eclCalDigitToLM->push_back(lm_caldigit->getLMId());
1406  } else
1407  m_eclCalDigitToLM->push_back(-1);
1408 
1409  }
1410  }
1411 
1412  //CR
1413  int CRmultip = m_eclConnectedRegions.getEntries();
1414  for (int i = 0; i < CRmultip; i++) {
1415  ECLConnectedRegion* aECLCR = m_eclConnectedRegions[i];
1416  m_eclCRIdx->push_back(aECLCR->getCRId());
1417  m_eclCRIsTrack->push_back(aECLCR->isTrack());
1418  m_eclCRLikelihoodMIPNGamma->push_back(aECLCR->getLikelihoodMIPNGamma());
1419  m_eclCRLikelihoodChargedHadron->push_back(aECLCR->getLikelihoodChargedHadron());
1420  m_eclCRLikelihoodElectronNGamma->push_back(aECLCR->getLikelihoodElectronNGamma());
1421  m_eclCRLikelihoodNGamma->push_back(aECLCR->getLikelihoodNGamma());
1422  m_eclCRLikelihoodNeutralHadron->push_back(aECLCR->getLikelihoodNeutralHadron());
1423  m_eclCRLikelihoodMergedPi0->push_back(aECLCR->getLikelihoodMergedPi0());
1424  }
1425 
1426  if (m_doHits == 1) {
1427 
1428  //SIM HITS
1429  m_eclSimHitMultip = m_eclSimHits.getEntries();
1430  for (int isimhits = 0; isimhits < m_eclSimHits.getEntries() ; isimhits++) {
1431  ECLSimHit* aECLSimHits = m_eclSimHits[isimhits];
1432 
1433  m_eclSimHitIdx->push_back(isimhits);
1434  m_eclSimHitCellId->push_back(aECLSimHits->getCellId());
1435  m_eclSimHitPdg->push_back(aECLSimHits->getPDGCode());
1436  m_eclSimHitEnergyDep->push_back(aECLSimHits->getEnergyDep());
1437  m_eclSimHitFlightTime->push_back(aECLSimHits->getFlightTime());
1438  m_eclSimHitX->push_back(aECLSimHits->getPosition().x());
1439  m_eclSimHitY->push_back(aECLSimHits->getPosition().y());
1440  m_eclSimHitZ->push_back(aECLSimHits->getPosition().z());
1441  m_eclSimHitPx->push_back(aECLSimHits->getMomentum().x());
1442  m_eclSimHitPy->push_back(aECLSimHits->getMomentum().y());
1443  m_eclSimHitPz->push_back(aECLSimHits->getMomentum().z());
1444 
1445  if (aECLSimHits->getRelated<MCParticle>() != (nullptr)) {
1446  const MCParticle* mc_simhit = aECLSimHits->getRelated<MCParticle>();
1447  m_eclSimHitToMC->push_back(mc_simhit->getArrayIndex());
1448  } else
1449  m_eclSimHitToMC->push_back(-1);
1450  }
1451 
1452  //HITS
1453  m_eclHitMultip = m_eclHits.getEntries();
1454  for (int ihits = 0; ihits < m_eclHits.getEntries() ; ihits++) {
1455  ECLHit* aECLHits = m_eclHits[ihits];
1456  m_eclHitIdx->push_back(ihits);
1457  m_eclHitCellId->push_back(aECLHits->getCellId());
1458  m_eclHitEnergyDep->push_back(aECLHits->getEnergyDep());
1459  m_eclHitTimeAve->push_back(aECLHits->getTimeAve());
1460 
1461  if (aECLHits->getRelated<ECLDigit>() != (nullptr)) {
1462  const ECLDigit* hit_digit = aECLHits->getRelated<ECLDigit>();
1463  m_eclHitToDigit->push_back(hit_digit->getArrayIndex());
1464  m_eclHitToDigitAmp->push_back(hit_digit->getAmp());
1465  } else {
1466  m_eclHitToDigit->push_back(-1);
1467  m_eclHitToDigitAmp->push_back(-1);
1468  }
1469 
1470  if (m_doPureCsI == true) {
1471  if (aECLHits->getRelated<ECLDigit>(eclPureDigitArrayName()) != (nullptr)) {
1472  const ECLDigit* hit_pdigit = aECLHits->getRelated<ECLDigit>(eclPureDigitArrayName());
1473  m_eclHitToPureDigit->push_back(hit_pdigit->getArrayIndex());
1474  m_eclHitToPureDigitAmp->push_back(hit_pdigit->getAmp());
1475  } else {
1476  m_eclHitToPureDigit->push_back(-1);
1477  m_eclHitToPureDigitAmp->push_back(-1);
1478  }
1479  }
1480 
1481  if (aECLHits->getRelated<MCParticle>() != (nullptr)) {
1482  const MCParticle* mc_hit = aECLHits->getRelated<MCParticle>();
1483  m_eclHitToMC->push_back(mc_hit->getArrayIndex());
1484  } else
1485  m_eclHitToMC->push_back(-1);
1486  }
1487  }
1488 
1489  //LM
1490  m_eclLMMultip = m_eclLocalMaximums.getEntries();
1491  for (unsigned int ilms = 0; ilms < (unsigned int)m_eclLocalMaximums.getEntries() ; ilms++) {
1492  ECLLocalMaximum* aECLLMs = m_eclLocalMaximums[ilms];
1493  m_eclLMId->push_back(aECLLMs->getLMId());
1494  m_eclLMType->push_back(aECLLMs->getType());
1495  m_eclLMCellId->push_back(aECLLMs->getCellId());
1496  }
1497 
1498  //CLUSTERS
1499  m_eclClusterMultip = m_eclClusters.getEntries();
1500  for (unsigned int iclusters = 0; iclusters < (unsigned int)m_eclClusters.getEntries() ; iclusters++) {
1501  ECLCluster* aECLClusters = m_eclClusters[iclusters];
1502  m_eclClusterIdx->push_back(iclusters);
1503 
1504  double clusterE = 0.0;
1505  if (aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) clusterE = aECLClusters->getEnergy(
1506  ECLCluster::EHypothesisBit::c_nPhotons);
1507  else clusterE = aECLClusters->getEnergy(ECLCluster::EHypothesisBit::c_neutralHadron);
1508  m_eclClusterEnergy->push_back(clusterE);
1509 
1510  m_eclClusterEnergyError->push_back(aECLClusters->getUncertaintyEnergy());
1511  m_eclClusterTheta->push_back(aECLClusters->getTheta());
1512  m_eclClusterThetaError->push_back(aECLClusters->getUncertaintyTheta());
1513  m_eclClusterPhi->push_back(aECLClusters->getPhi());
1514  m_eclClusterPhiError->push_back(aECLClusters->getUncertaintyPhi());
1515  m_eclClusterR->push_back(aECLClusters->getR());
1516  m_eclClusterEnergyDepSum->push_back(aECLClusters->getEnergyRaw());
1517  m_eclClusterTiming->push_back(aECLClusters->getTime());
1518  m_eclClusterTimingError->push_back(aECLClusters->getDeltaTime99());
1519  m_eclClusterE9oE21->push_back(aECLClusters->getE9oE21());
1520  m_eclClusterHighestE->push_back(aECLClusters->getEnergyHighestCrystal());
1521  m_eclClusterCellId->push_back(aECLClusters->getMaxECellId());
1522  m_eclClusterNofCrystals->push_back(aECLClusters->getNumberOfCrystals());
1523  m_eclClusterCrystalHealth->push_back(aECLClusters->getStatus());
1524 
1525  m_eclClusterIsTrack->push_back(aECLClusters->isTrack());
1526  m_eclClusterClosestTrackDist->push_back(aECLClusters->getMinTrkDistance());
1527  m_eclClusterDeltaL->push_back(aECLClusters->getDeltaL());
1528 
1529  m_eclClusterAbsZernike40->push_back(aECLClusters->getAbsZernike40());
1530  m_eclClusterAbsZernike51->push_back(aECLClusters->getAbsZernike51());
1531  m_eclClusterZernikeMVA->push_back(aECLClusters->getZernikeMVA());
1532  m_eclClusterE1oE9->push_back(aECLClusters->getE1oE9());
1533  m_eclClusterSecondMoment->push_back(aECLClusters->getSecondMoment());
1534  m_eclClusterLAT->push_back(aECLClusters->getLAT());
1535  m_eclClusterDeltaTime99->push_back(aECLClusters->getDeltaTime99());
1536  m_eclClusterDetectorRegion->push_back(aECLClusters->getDetectorRegion());
1537  m_eclClusterHasNPhotonHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons));
1538  m_eclClusterHasNeutralHadronHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_neutralHadron));
1539 
1540  if (aECLClusters->getRelated<ECLShower>() != (nullptr)) {
1541  const ECLShower* shower_cluster = aECLClusters->getRelated<ECLShower>();
1542  m_eclClusterToShower->push_back(shower_cluster->getArrayIndex());
1543  } else
1544  m_eclClusterToShower->push_back(-1);
1545 
1546  //Dump MC Info - Multiple Matching
1547  double sumHit = 0;
1548  int idx[10];
1549  for (int i = 0; i < 10; i++)
1550  idx[i] = -1;
1551 
1552  double wi[10];
1553  for (int i = 0; i < 10; i++)
1554  wi[i] = -1;
1555 
1556  int ii = 0;
1557  sumHit = 0;
1558 
1559  auto clusterMCRelations = aECLClusters->getRelationsTo<MCParticle>();
1560  for (unsigned int i = 0; i < clusterMCRelations.size(); ++i) {
1561  if (ii < 10) {
1562  const auto mcParticle = clusterMCRelations.object(i);
1563  idx[ii] = mcParticle->getIndex() - 1;
1564  wi[ii] = clusterMCRelations.weight(i);
1565  sumHit = sumHit + clusterMCRelations.weight(i);
1566  ii++;
1567  }
1568  }
1569 
1570  //Re-ordering based on contribution
1571  int y = 0;
1572  while (y < 10) {
1573  for (int i = 0; i < 9; i++) {
1574  if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1575  if (wi[i] < wi[i + 1]) {
1576  int temp = idx[i];
1577  idx[i] = idx[i + 1];
1578  idx[i + 1] = temp;
1579 
1580  double wtemp = wi[i];
1581  wi[i] = wi[i + 1];
1582  wi[i + 1] = wtemp;
1583  }
1584  }
1585  }
1586  y++;
1587  }
1588 
1589  m_eclClusterToBkgWeight->push_back(clusterE - sumHit);
1590  m_eclClusterSimHitSum->push_back(sumHit);
1591  if (idx[0] > -1) {
1592  m_eclClusterToMCWeight1->push_back(wi[0]);
1593  m_eclClusterToMC1->push_back(idx[0]);
1594  MCParticle* amcParticle = m_mcParticles[idx[0]];
1595  m_eclClusterToMC1PDG->push_back(amcParticle->getPDG());
1596  } else {
1597  m_eclClusterToMCWeight1->push_back(-1);
1598  m_eclClusterToMC1->push_back(-1);
1599  m_eclClusterToMC1PDG->push_back(-1);
1600  }
1601  if (idx[1] > -1) {
1602  m_eclClusterToMCWeight2->push_back(wi[1]);
1603  m_eclClusterToMC2->push_back(idx[1]);
1604  MCParticle* amcParticle = m_mcParticles[idx[1]];
1605  m_eclClusterToMC2PDG->push_back(amcParticle->getPDG());
1606  } else {
1607  m_eclClusterToMCWeight2->push_back(-1);
1608  m_eclClusterToMC2->push_back(-1);
1609  m_eclClusterToMC2PDG->push_back(-1);
1610  }
1611  if (idx[2] > -1) {
1612  m_eclClusterToMCWeight3->push_back(wi[2]);
1613  m_eclClusterToMC3->push_back(idx[2]);
1614  MCParticle* amcParticle = m_mcParticles[idx[2]];
1615  m_eclClusterToMC3PDG->push_back(amcParticle->getPDG());
1616  } else {
1617  m_eclClusterToMCWeight3->push_back(-1);
1618  m_eclClusterToMC3->push_back(-1);
1619  m_eclClusterToMC3PDG->push_back(-1);
1620  }
1621  if (idx[3] > -1) {
1622  m_eclClusterToMCWeight4->push_back(wi[3]);
1623  m_eclClusterToMC4->push_back(idx[3]);
1624  MCParticle* amcParticle = m_mcParticles[idx[3]];
1625  m_eclClusterToMC4PDG->push_back(amcParticle->getPDG());
1626  } else {
1627  m_eclClusterToMCWeight4->push_back(-1);
1628  m_eclClusterToMC4->push_back(-1);
1629  m_eclClusterToMC4PDG->push_back(-1);
1630  }
1631  if (idx[4] > -1) {
1632  m_eclClusterToMCWeight5->push_back(wi[4]);
1633  m_eclClusterToMC5->push_back(idx[4]);
1634  MCParticle* amcParticle = m_mcParticles[idx[4]];
1635  m_eclClusterToMC5PDG->push_back(amcParticle->getPDG());
1636  } else {
1637  m_eclClusterToMCWeight5->push_back(-1);
1638  m_eclClusterToMC5->push_back(-1);
1639  m_eclClusterToMC5PDG->push_back(-1);
1640  }
1641 
1642  }
1643 
1644  if (m_doPureCsI == true) {
1645 
1646  m_eclPureDigitMultip = m_eclPureDigits.getEntries();
1647  for (int idigits = 0; idigits < m_eclPureDigits.getEntries() ; idigits++) {
1648  ECLDigit* aECLPureDigits = m_eclPureDigits[idigits];
1649 
1650  m_eclPureDigitIdx->push_back(idigits);
1651  m_eclPureDigitCellId->push_back(aECLPureDigits->getCellId());
1652  m_eclPureDigitAmp->push_back(aECLPureDigits->getAmp());
1653  m_eclPureDigitTimeFit->push_back(aECLPureDigits->getTimeFit());
1654  m_eclPureDigitFitQuality->push_back(aECLPureDigits->getQuality());
1655 
1656  if (aECLPureDigits->getRelated<MCParticle>() != (nullptr)) {
1657  const MCParticle* mc_digit = aECLPureDigits->getRelated<MCParticle>();
1658  m_eclPureDigitToMC->push_back(mc_digit->getArrayIndex());
1659  } else
1660  m_eclPureDigitToMC->push_back(-1);
1661  }
1662 
1663  //PURE CAL DIGITS
1664  m_eclPureCalDigitMultip = m_eclPureCalDigits.getEntries();
1665  for (uint icaldigits = 0; icaldigits < (uint)m_eclPureCalDigits.getEntries() ; icaldigits++) {
1666  ECLCalDigit* aECLPureCalDigits = m_eclPureCalDigits[icaldigits];
1667 
1668  m_eclPureCalDigitIdx->push_back(icaldigits);
1669  m_eclPureCalDigitCellId->push_back(aECLPureCalDigits->getCellId());
1670  m_eclPureCalDigitAmp->push_back(aECLPureCalDigits->getEnergy());
1671  m_eclPureCalDigitTimeFit->push_back(aECLPureCalDigits->getTime());
1672  m_eclPureCalDigitFitQuality->push_back(aECLPureCalDigits->isFailedFit());
1673 
1674  double sumHit = 0;
1675  int idx[10];
1676  for (int i = 0; i < 10; i++)
1677  idx[i] = -1;
1678 
1679  double wi[10];
1680  for (int i = 0; i < 10; i++)
1681  wi[i] = -1;
1682 
1683  int ii = 0;
1684  sumHit = 0;
1685 
1686  auto digitMCRelations = aECLPureCalDigits->getRelationsTo<MCParticle>();
1687  for (unsigned int i = 0; i < digitMCRelations.size(); ++i) {
1688  if (ii < 10) {
1689  const auto mcParticle = digitMCRelations.object(i);
1690  idx[ii] = mcParticle->getIndex() - 1;
1691  wi[ii] = digitMCRelations.weight(i);
1692  sumHit = sumHit + digitMCRelations.weight(i);
1693  ii++;
1694  }
1695  }
1696 
1697  //Re-ordering based on contribution
1698  int y = 0;
1699  while (y < 10) {
1700  for (int i = 0; i < 9; i++) {
1701  if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1702  if (wi[i] < wi[i + 1]) {
1703  int temp = idx[i];
1704  idx[i] = idx[i + 1];
1705  idx[i + 1] = temp;
1706 
1707  double wtemp = wi[i];
1708  wi[i] = wi[i + 1];
1709  wi[i + 1] = wtemp;
1710  }
1711  }
1712  }
1713  y++;
1714  }
1715 
1716  m_eclPureCalDigitToBkgWeight->push_back(aECLPureCalDigits->getEnergy() - sumHit);
1717  m_eclPureCalDigitSimHitSum->push_back(sumHit);
1718  if (idx[0] > -1) {
1719  m_eclPureCalDigitToMCWeight1->push_back(wi[0]);
1720  m_eclPureCalDigitToMC1->push_back(idx[0]);
1721  MCParticle* amcParticle = m_mcParticles[idx[0]];
1722  m_eclPureCalDigitToMC1PDG->push_back(amcParticle->getPDG());
1723  } else {
1724  m_eclPureCalDigitToMCWeight1->push_back(-1);
1725  m_eclPureCalDigitToMC1->push_back(-1);
1726  m_eclPureCalDigitToMC1PDG->push_back(-1);
1727  }
1728  if (idx[1] > -1) {
1729  m_eclPureCalDigitToMCWeight2->push_back(wi[1]);
1730  m_eclPureCalDigitToMC2->push_back(idx[1]);
1731  MCParticle* amcParticle = m_mcParticles[idx[1]];
1732  m_eclPureCalDigitToMC2PDG->push_back(amcParticle->getPDG());
1733  } else {
1734  m_eclPureCalDigitToMCWeight2->push_back(-1);
1735  m_eclPureCalDigitToMC2->push_back(-1);
1736  m_eclPureCalDigitToMC2PDG->push_back(-1);
1737  }
1738  if (idx[2] > -1) {
1739  m_eclPureCalDigitToMCWeight3->push_back(wi[2]);
1740  m_eclPureCalDigitToMC3->push_back(idx[2]);
1741  MCParticle* amcParticle = m_mcParticles[idx[2]];
1742  m_eclPureCalDigitToMC3PDG->push_back(amcParticle->getPDG());
1743  } else {
1744  m_eclPureCalDigitToMCWeight3->push_back(-1);
1745  m_eclPureCalDigitToMC3->push_back(-1);
1746  m_eclPureCalDigitToMC3PDG->push_back(-1);
1747  }
1748  if (idx[3] > -1) {
1749  m_eclPureCalDigitToMCWeight4->push_back(wi[3]);
1750  m_eclPureCalDigitToMC4->push_back(idx[3]);
1751  MCParticle* amcParticle = m_mcParticles[idx[3]];
1752  m_eclPureCalDigitToMC4PDG->push_back(amcParticle->getPDG());
1753  } else {
1754  m_eclPureCalDigitToMCWeight4->push_back(-1);
1755  m_eclPureCalDigitToMC4->push_back(-1);
1756  m_eclPureCalDigitToMC4PDG->push_back(-1);
1757  }
1758  if (idx[4] > -1) {
1759  m_eclPureCalDigitToMCWeight5->push_back(wi[4]);
1760  m_eclPureCalDigitToMC5->push_back(idx[4]);
1761  MCParticle* amcParticle = m_mcParticles[idx[4]];
1762  m_eclPureCalDigitToMC5PDG->push_back(amcParticle->getPDG());
1763  } else {
1764  m_eclPureCalDigitToMCWeight5->push_back(-1);
1765  m_eclPureCalDigitToMC5->push_back(-1);
1766  m_eclPureCalDigitToMC5PDG->push_back(-1);
1767  }
1768 
1769  if (aECLPureCalDigits->getRelated<ECLShower>() != (nullptr)) {
1770  const ECLShower* shower_caldigit = aECLPureCalDigits->getRelated<ECLShower>();
1771  m_eclPureCalDigitToShower->push_back(shower_caldigit->getArrayIndex());
1772  } else
1773  m_eclPureCalDigitToShower->push_back(-1);
1774 
1775  if (aECLPureCalDigits->getRelated<ECLConnectedRegion>(eclPureConnectedRegionArrayName()) != (nullptr)) {
1776  const ECLConnectedRegion* cr_caldigit = aECLPureCalDigits->getRelated<ECLConnectedRegion>(eclPureConnectedRegionArrayName());
1777  m_eclPureCalDigitToCR->push_back(cr_caldigit->getCRId());
1778  } else
1779  m_eclPureCalDigitToCR->push_back(-1);
1780 
1781  if (aECLPureCalDigits->getRelated<ECLLocalMaximum>(eclPureLocalMaximumArrayName()) != (nullptr)) {
1782  const ECLLocalMaximum* lm_caldigit = aECLPureCalDigits->getRelated<ECLLocalMaximum>(eclPureLocalMaximumArrayName());
1783  m_eclPureCalDigitToLM->push_back(lm_caldigit->getLMId());
1784  } else
1785  m_eclPureCalDigitToLM->push_back(-1);
1786 
1787  }
1788 
1789  //CR
1790  int PureCRmultip = m_eclPureConnectedRegions.getEntries();
1791  for (int i = 0; i < PureCRmultip; i++) {
1792  ECLConnectedRegion* aECLPureCR = m_eclPureConnectedRegions[i];
1793  m_eclPureCRIdx->push_back(aECLPureCR->getCRId());
1794  m_eclPureCRIsTrack->push_back(aECLPureCR->isTrack());
1795  m_eclPureCRLikelihoodMIPNGamma->push_back(aECLPureCR->getLikelihoodMIPNGamma());
1796  m_eclPureCRLikelihoodChargedHadron->push_back(aECLPureCR->getLikelihoodChargedHadron());
1797  m_eclPureCRLikelihoodElectronNGamma->push_back(aECLPureCR->getLikelihoodElectronNGamma());
1798  m_eclPureCRLikelihoodNGamma->push_back(aECLPureCR->getLikelihoodNGamma());
1799  m_eclPureCRLikelihoodNeutralHadron->push_back(aECLPureCR->getLikelihoodNeutralHadron());
1800  m_eclPureCRLikelihoodMergedPi0->push_back(aECLPureCR->getLikelihoodMergedPi0());
1801  }
1802 
1803  //LM
1804  m_eclPureLMMultip = m_eclPureLocalMaximums.getEntries();
1805  for (unsigned int pure_ilms = 0; pure_ilms < (unsigned int)m_eclPureLocalMaximums.getEntries() ; pure_ilms++) {
1806  ECLLocalMaximum* aECLLMs = m_eclPureLocalMaximums[pure_ilms];
1807  m_eclPureLMId->push_back(aECLLMs->getLMId());
1808  m_eclPureLMType->push_back(aECLLMs->getType());
1809  m_eclPureLMCellId->push_back(aECLLMs->getCellId());
1810  }
1811 
1812  m_eclPureClusterMultip = m_eclPureClusters.getEntries();
1813  for (unsigned int iclusters = 0; iclusters < (unsigned int)m_eclPureClusters.getEntries() ; iclusters++) {
1814  ECLCluster* aECLClusters = m_eclPureClusters[iclusters];
1815  m_eclPureClusterIdx->push_back(iclusters);
1816 
1817  double clusterE = 0.0;
1818  if (aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) clusterE = aECLClusters->getEnergy(
1819  ECLCluster::EHypothesisBit::c_nPhotons);
1820  else clusterE = aECLClusters->getEnergy(ECLCluster::EHypothesisBit::c_neutralHadron);
1821  m_eclPureClusterEnergy->push_back(clusterE);
1822 
1823  m_eclPureClusterEnergyError->push_back(aECLClusters->getUncertaintyEnergy());
1824  m_eclPureClusterTheta->push_back(aECLClusters->getTheta());
1825  m_eclPureClusterThetaError->push_back(aECLClusters->getUncertaintyTheta());
1826  m_eclPureClusterPhi->push_back(aECLClusters->getPhi());
1827  m_eclPureClusterPhiError->push_back(aECLClusters->getUncertaintyPhi());
1828  m_eclPureClusterR->push_back(aECLClusters->getR());
1829  m_eclPureClusterEnergyDepSum->push_back(aECLClusters->getEnergyRaw());
1830  m_eclPureClusterTiming->push_back(aECLClusters->getTime());
1831  m_eclPureClusterTimingError->push_back(aECLClusters->getDeltaTime99());
1832  m_eclPureClusterE9oE21->push_back(aECLClusters->getE9oE21());
1833  m_eclPureClusterHighestE->push_back(aECLClusters->getEnergyHighestCrystal());
1834  m_eclPureClusterCellId->push_back(aECLClusters->getMaxECellId());
1835  m_eclPureClusterLat->push_back(aECLClusters->getLAT());
1836  m_eclPureClusterNofCrystals->push_back(aECLClusters->getNumberOfCrystals());
1837  m_eclPureClusterCrystalHealth->push_back(aECLClusters->getStatus());
1838 
1839  m_eclPureClusterClosestTrackDist->push_back(aECLClusters->getMinTrkDistance());
1840  m_eclPureClusterAbsZernike40->push_back(aECLClusters->getAbsZernike40());
1841  m_eclPureClusterAbsZernike51->push_back(aECLClusters->getAbsZernike51());
1842  m_eclPureClusterZernikeMVA->push_back(aECLClusters->getZernikeMVA());
1843  m_eclPureClusterSecondMoment->push_back(aECLClusters->getSecondMoment());
1844 
1845  m_eclPureClusterIsTrack->push_back(aECLClusters->isTrack());
1846  m_eclPureClusterDeltaL->push_back(aECLClusters->getDeltaL());
1847 
1848  m_eclPureClusterE1oE9->push_back(aECLClusters->getE1oE9());
1849  m_eclPureClusterDeltaTime99->push_back(aECLClusters->getDeltaTime99());
1850  m_eclPureClusterDetectorRegion->push_back(aECLClusters->getDetectorRegion());
1851  m_eclPureClusterHasNPhotonHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons));
1852  m_eclPureClusterHasNeutralHadronHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_neutralHadron));
1853 
1854  //Dump MC Info - Multiple Matching
1855  double sumHit = 0;
1856  int idx[10];
1857  for (int i = 0; i < 10; i++)
1858  idx[i] = -1;
1859 
1860  double wi[10];
1861  for (int i = 0; i < 10; i++)
1862  wi[i] = -1;
1863 
1864  int ii = 0;
1865  sumHit = 0;
1866 
1867  auto clusterMCRelations = aECLClusters->getRelationsTo<MCParticle>();
1868  for (unsigned int i = 0; i < clusterMCRelations.size(); ++i) {
1869  if (ii < 10) {
1870  const auto mcParticle = clusterMCRelations.object(i);
1871  idx[ii] = mcParticle->getIndex() - 1;
1872  wi[ii] = clusterMCRelations.weight(i);
1873  sumHit = sumHit + clusterMCRelations.weight(i);
1874  ii++;
1875  }
1876  }
1877 
1878  //Re-ordering based on contribution
1879  int y = 0;
1880  while (y < 10) {
1881  for (int i = 0; i < 9; i++) {
1882  if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1883  if (wi[i] < wi[i + 1]) {
1884  int temp = idx[i];
1885  idx[i] = idx[i + 1];
1886  idx[i + 1] = temp;
1887 
1888  double wtemp = wi[i];
1889  wi[i] = wi[i + 1];
1890  wi[i + 1] = wtemp;
1891  }
1892  }
1893  }
1894  y++;
1895  }
1896 
1897  m_eclPureClusterToBkgWeight->push_back(clusterE - sumHit);
1898  if (idx[0] > -1) {
1899  m_eclPureClusterToMCWeight1->push_back(wi[0]);
1900  m_eclPureClusterToMC1->push_back(idx[0]);
1901  MCParticle* amcParticle = m_mcParticles[idx[0]];
1902  m_eclPureClusterToMC1PDG->push_back(amcParticle->getPDG());
1903  } else {
1904  m_eclPureClusterToMCWeight1->push_back(-1);
1905  m_eclPureClusterToMC1->push_back(-1);
1906  m_eclPureClusterToMC1PDG->push_back(-1);
1907  }
1908  if (idx[1] > -1) {
1909  m_eclPureClusterToMCWeight2->push_back(wi[1]);
1910  m_eclPureClusterToMC2->push_back(idx[1]);
1911  MCParticle* amcParticle = m_mcParticles[idx[1]];
1912  m_eclPureClusterToMC2PDG->push_back(amcParticle->getPDG());
1913  } else {
1914  m_eclPureClusterToMCWeight2->push_back(-1);
1915  m_eclPureClusterToMC2->push_back(-1);
1916  m_eclPureClusterToMC2PDG->push_back(-1);
1917  }
1918  if (idx[2] > -1) {
1919  m_eclPureClusterToMCWeight3->push_back(wi[2]);
1920  m_eclPureClusterToMC3->push_back(idx[2]);
1921  MCParticle* amcParticle = m_mcParticles[idx[2]];
1922  m_eclPureClusterToMC3PDG->push_back(amcParticle->getPDG());
1923  } else {
1924  m_eclPureClusterToMCWeight3->push_back(-1);
1925  m_eclPureClusterToMC3->push_back(-1);
1926  m_eclPureClusterToMC3PDG->push_back(-1);
1927  }
1928  if (idx[3] > -1) {
1929  m_eclPureClusterToMCWeight4->push_back(wi[3]);
1930  m_eclPureClusterToMC4->push_back(idx[3]);
1931  MCParticle* amcParticle = m_mcParticles[idx[3]];
1932  m_eclPureClusterToMC4PDG->push_back(amcParticle->getPDG());
1933  } else {
1934  m_eclPureClusterToMCWeight4->push_back(-1);
1935  m_eclPureClusterToMC4->push_back(-1);
1936  m_eclPureClusterToMC4PDG->push_back(-1);
1937  }
1938  if (idx[4] > -1) {
1939  m_eclPureClusterToMCWeight5->push_back(wi[4]);
1940  m_eclPureClusterToMC5->push_back(idx[4]);
1941  MCParticle* amcParticle = m_mcParticles[idx[4]];
1942  m_eclPureClusterToMC5PDG->push_back(amcParticle->getPDG());
1943  } else {
1944  m_eclPureClusterToMCWeight5->push_back(-1);
1945  m_eclPureClusterToMC5->push_back(-1);
1946  m_eclPureClusterToMC5PDG->push_back(-1);
1947  }
1948 
1949  }
1950  }
1951 
1952  m_eclShowerMultip = m_eclShowers.getEntries();
1953  for (uint ishowers = 0; ishowers < (uint)m_eclShowers.getEntries() ; ishowers++) {
1954  ECLShower* aECLShowers = m_eclShowers[ishowers];
1955  m_eclShowerIdx->push_back(ishowers);
1956  m_eclShowerEnergy->push_back(aECLShowers->getEnergy());
1957  m_eclShowerTheta->push_back(aECLShowers->getTheta());
1958  m_eclShowerPhi->push_back(aECLShowers->getPhi());
1959  m_eclShowerR->push_back(aECLShowers->getR());
1960  m_eclShowerNHits->push_back(aECLShowers->getNumberOfCrystals());
1961  m_eclShowerE9oE21->push_back(aECLShowers->getE9oE21());
1962  m_eclShowerUncEnergy->push_back(aECLShowers->getEnergyRaw());
1963  m_eclShowerTime->push_back(aECLShowers->getTime());
1964  m_eclShowerT99->push_back(aECLShowers->getDeltaTime99());
1965  m_eclShowerConnectedRegionId->push_back(aECLShowers->getConnectedRegionId());
1966  m_eclShowerHypothesisId->push_back(aECLShowers->getHypothesisId());
1967  m_eclShowerCentralCellId->push_back(aECLShowers->getCentralCellId());
1968  m_eclShowerEnergyError->push_back(aECLShowers->getUncertaintyEnergy());
1969  m_eclShowerThetaError->push_back(aECLShowers->getUncertaintyTheta());
1970  m_eclShowerPhiError->push_back(aECLShowers->getUncertaintyPhi());
1971  m_eclShowerTimeResolution->push_back(aECLShowers->getDeltaTime99());
1972  m_eclShowerHighestEnergy->push_back(aECLShowers->getEnergyHighestCrystal());
1973  m_eclShowerLateralEnergy->push_back(aECLShowers->getLateralEnergy());
1974  m_eclShowerMinTrkDistance->push_back(aECLShowers->getMinTrkDistance());
1975  m_eclShowerTrkDepth->push_back(aECLShowers->getTrkDepth());
1976  m_eclShowerShowerDepth->push_back(aECLShowers->getShowerDepth());
1977  m_eclShowerAbsZernike40->push_back(aECLShowers->getAbsZernikeMoment(4, 0));
1978  m_eclShowerAbsZernike51->push_back(aECLShowers->getAbsZernikeMoment(5, 1));
1979  m_eclShowerZernikeMVA->push_back(aECLShowers->getZernikeMVA());
1980  m_eclShowerSecondMoment->push_back(aECLShowers->getSecondMoment());
1981  m_eclShowerE1oE9->push_back(aECLShowers->getE1oE9());
1982  m_eclShowerIsTrack->push_back(aECLShowers->getIsTrack());
1983  m_eclShowerNumberOfCrystalsForEnergy->push_back(aECLShowers->getNumberOfCrystalsForEnergy());
1984 
1985  double fe = 0.;
1986  double se = 0.;
1987 
1988  auto showerDigitRelations = aECLShowers->getRelationsTo<ECLCalDigit>();
1989  for (unsigned int i = 0; i < showerDigitRelations.size(); ++i) {
1990  const auto aECLCalDigits = showerDigitRelations.object(i);
1991  if (aECLCalDigits->getEnergy() > fe) {
1992  se = fe;
1993  fe = aECLCalDigits->getEnergy();
1994  }
1995  }
1996  if (fe > 0 && se > 0)
1997  m_eclShowerHighestE1mE2->push_back(fe - se);
1998  else
1999  m_eclShowerHighestE1mE2->push_back(-1);
2000 
2001  int lm1[5] = { -1, -1, -1, -1, -1};
2002 
2003  auto showerLMRelations = aECLShowers->getRelationsTo<ECLLocalMaximum>();
2004  for (unsigned int i = 0; i < showerLMRelations.size(); ++i) {
2005  const auto aECLLM = showerLMRelations.object(i);
2006  lm1[i] = aECLLM->getLMId();
2007  }
2008  m_eclShowerToLM1->push_back(lm1[0]);
2009  m_eclShowerToLM2->push_back(lm1[1]);
2010  m_eclShowerToLM3->push_back(lm1[2]);
2011  m_eclShowerToLM4->push_back(lm1[3]);
2012  m_eclShowerToLM5->push_back(lm1[4]);
2013 
2014  double sumHit = 0;
2015 
2016  int idx[10];
2017  for (int i = 0; i < 10; i++)
2018  idx[i] = -1;
2019 
2020  double wi[10];
2021  for (int i = 0; i < 10; i++)
2022  wi[i] = -1;
2023 
2024  int ii = 0;
2025  sumHit = 0;
2026 
2027  auto showerMCRelations = aECLShowers->getRelationsTo<MCParticle>();
2028  for (unsigned int i = 0; i < showerMCRelations.size(); ++i) {
2029  if (ii < 10) {
2030  const auto mcParticle = showerMCRelations.object(i);
2031  idx[ii] = mcParticle->getIndex() - 1;
2032  wi[ii] = showerMCRelations.weight(i);
2033  sumHit = sumHit + showerMCRelations.weight(i);
2034  ii++;
2035  }
2036  }
2037 
2038  //Re-ordering based on contribution
2039  int y = 0;
2040  while (y < 10) {
2041  for (int i = 0; i < 9; i++) {
2042  if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
2043  if (wi[i] < wi[i + 1]) {
2044  int temp = idx[i];
2045  idx[i] = idx[i + 1];
2046  idx[i + 1] = temp;
2047 
2048  double wtemp = wi[i];
2049  wi[i] = wi[i + 1];
2050  wi[i + 1] = wtemp;
2051  }
2052  }
2053  }
2054  y++;
2055  }
2056 
2057  int no_Primary = 1;
2058 
2059  for (unsigned int i = 0; i < showerMCRelations.size(); ++i) {
2060  const auto mcParticle = showerMCRelations.object(i);
2061  if (mcParticle->getSecondaryPhysicsProcess() == 0 && mcParticle->getPDG() == Const::Klong.getPDGCode()) {
2062  double vtxx = mcParticle->getDecayVertex().X();
2063  double vtxy = mcParticle->getDecayVertex().Y();
2064  double vtxz = mcParticle->getDecayVertex().Z();
2065  if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16))
2066  no_Primary = 0;
2067  } else if (mcParticle->getSecondaryPhysicsProcess() != 0 && mcParticle->getMother()->getPDG() == Const::Klong.getPDGCode()) {
2068  double vtxx = mcParticle->getProductionVertex().X();
2069  double vtxy = mcParticle->getProductionVertex().Y();
2070  double vtxz = mcParticle->getProductionVertex().Z();
2071  if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16))
2072  no_Primary = 0;
2073  }
2074  }
2075 
2076  if (no_Primary == 0)
2077  m_eclShowerMCVtxInEcl->push_back(1);
2078  else
2079  m_eclShowerMCVtxInEcl->push_back(0);
2080 
2081  double no_fMatch = 0;
2082  double no_fFMatch = 0;
2083 
2084  for (unsigned int i = 0; i < showerMCRelations.size(); ++i) {
2085  const auto mcParticle = showerMCRelations.object(i);
2086  if (mcParticle->getSecondaryPhysicsProcess() == 0) {
2087  double vtxx = mcParticle->getDecayVertex().X();
2088  double vtxy = mcParticle->getDecayVertex().Y();
2089  double vtxz = mcParticle->getDecayVertex().Z();
2090  double px = mcParticle->getMomentum().X();
2091  double py = mcParticle->getMomentum().Y();
2092  double pz = mcParticle->getMomentum().Z();
2093  double p = TMath::Sqrt(px * px + py * py + pz * pz);
2094  double pTheta = TMath::ACos(pz / p);
2095  double pPhi = 10.;
2096  if (py > 0) {
2097  if (px > 0)
2098  pPhi = TMath::ATan(py / px);
2099  if (px < 0)
2100  pPhi = TMath::ATan(py / px) + M_PI;
2101  } else {
2102  if (px > 0)
2103  pPhi = TMath::ATan(py / px) ;
2104  if (px < 0)
2105  pPhi = TMath::ATan(py / px) - M_PI;
2106  }
2107  if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16)) {
2108  if (TMath::Abs(aECLShowers->getTheta() - pTheta) < 0.05 && TMath::Abs(aECLShowers->getPhi() - pPhi) < 0.05)
2109  no_fMatch = 1;
2110  no_fFMatch = 1;
2111  }
2112  } else if (mcParticle->getMother()->getPDG() == Const::Klong.getPDGCode()) {
2113  double vtxx = mcParticle->getProductionVertex().X();
2114  double vtxy = mcParticle->getProductionVertex().Y();
2115  double vtxz = mcParticle->getProductionVertex().Z();
2116  MCParticle* amcParticle = mcParticle->getMother();
2117  double px = amcParticle->getMomentum().X();
2118  double py = amcParticle->getMomentum().Y();
2119  double pz = amcParticle->getMomentum().Z();
2120  double p = TMath::Sqrt(px * px + py * py + pz * pz);
2121  double pTheta = TMath::ACos(pz / p);
2122  double pPhi = 10.;
2123  if (py > 0) {
2124  if (px > 0)
2125  pPhi = TMath::ATan(py / px);
2126  if (px < 0)
2127  pPhi = TMath::ATan(py / px) + M_PI;
2128  } else {
2129  if (px > 0)
2130  pPhi = TMath::ATan(py / px) ;
2131  if (px < 0)
2132  pPhi = TMath::ATan(py / px) - M_PI;
2133  }
2134  if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16)) {
2135  if (TMath::Abs(aECLShowers->getTheta() - pTheta) < 0.05 && TMath::Abs(aECLShowers->getPhi() - pPhi) < 0.05)
2136  no_fMatch = 1;
2137  }
2138  }
2139  }
2140 
2141  if (no_fMatch == 1)
2142  m_eclShowerMCFlightMatch->push_back(1);
2143  else
2144  m_eclShowerMCFlightMatch->push_back(0);
2145 
2146  if (no_fFMatch == 1)
2147  m_eclShowerMCFFlightMatch->push_back(1);
2148  else
2149  m_eclShowerMCFFlightMatch->push_back(0);
2150 
2151  if (idx[0] > -1) {
2152  m_eclShowerToMCWeight1->push_back(wi[0]);
2153  m_eclShowerToMC1->push_back(idx[0]);
2154  MCParticle* amcParticle = m_mcParticles[idx[0]];
2155  m_eclShowerToMC1PDG->push_back(amcParticle->getPDG());
2156  if (amcParticle->getMother() != nullptr) {
2157  m_eclShowerToMC1Moth->push_back(amcParticle->getMother()->getIndex());
2158  m_eclShowerToMC1MothPDG->push_back(amcParticle->getMother()->getPDG());
2159  if (amcParticle->getMother()->getMother() != nullptr) {
2160  m_eclShowerToMC1GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2161  m_eclShowerToMC1GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2162  } else {
2163  m_eclShowerToMC1GMoth->push_back(-999);
2164  m_eclShowerToMC1GMothPDG->push_back(-999);
2165  }
2166  } else {
2167  m_eclShowerToMC1Moth->push_back(-999);
2168  m_eclShowerToMC1MothPDG->push_back(-999);
2169  m_eclShowerToMC1GMoth->push_back(-999);
2170  m_eclShowerToMC1GMothPDG->push_back(-999);
2171  }
2172  } else {
2173  m_eclShowerToMCWeight1->push_back(-1);
2174  m_eclShowerToMC1->push_back(-1);
2175  m_eclShowerToMC1PDG->push_back(-1);
2176  m_eclShowerToMC1Moth->push_back(-1);
2177  m_eclShowerToMC1MothPDG->push_back(-1);
2178  m_eclShowerToMC1GMoth->push_back(-1);
2179  m_eclShowerToMC1GMothPDG->push_back(-1);
2180  }
2181  if (idx[1] > -1) {
2182  m_eclShowerToMCWeight2->push_back(wi[1]);
2183  m_eclShowerToMC2->push_back(idx[1]);
2184  MCParticle* amcParticle = m_mcParticles[idx[1]];
2185  m_eclShowerToMC2PDG->push_back(amcParticle->getPDG());
2186  if (amcParticle->getMother() != nullptr) {
2187  m_eclShowerToMC2Moth->push_back(amcParticle->getMother()->getIndex());
2188  m_eclShowerToMC2MothPDG->push_back(amcParticle->getMother()->getPDG());
2189  if (amcParticle->getMother()->getMother() != nullptr) {
2190  m_eclShowerToMC2GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2191  m_eclShowerToMC2GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2192  } else {
2193  m_eclShowerToMC2GMoth->push_back(-999);
2194  m_eclShowerToMC2GMothPDG->push_back(-999);
2195  }
2196  } else {
2197  m_eclShowerToMC2Moth->push_back(-999);
2198  m_eclShowerToMC2MothPDG->push_back(-999);
2199  m_eclShowerToMC2GMoth->push_back(-999);
2200  m_eclShowerToMC2GMothPDG->push_back(-999);
2201  };
2202  } else {
2203  m_eclShowerToMCWeight2->push_back(-1);
2204  m_eclShowerToMC2->push_back(-1);
2205  m_eclShowerToMC2PDG->push_back(-1);
2206  m_eclShowerToMC2Moth->push_back(-1);
2207  m_eclShowerToMC2MothPDG->push_back(-1);
2208  m_eclShowerToMC2GMoth->push_back(-1);
2209  m_eclShowerToMC2GMothPDG->push_back(-1);
2210  }
2211  if (idx[2] > -1) {
2212  m_eclShowerToMCWeight3->push_back(wi[2]);
2213  m_eclShowerToMC3->push_back(idx[2]);
2214  MCParticle* amcParticle = m_mcParticles[idx[2]];
2215  m_eclShowerToMC3PDG->push_back(amcParticle->getPDG());
2216  if (amcParticle->getMother() != nullptr) {
2217  m_eclShowerToMC3Moth->push_back(amcParticle->getMother()->getIndex());
2218  m_eclShowerToMC3MothPDG->push_back(amcParticle->getMother()->getPDG());
2219  if (amcParticle->getMother()->getMother() != nullptr) {
2220  m_eclShowerToMC3GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2221  m_eclShowerToMC3GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2222  } else {
2223  m_eclShowerToMC3GMoth->push_back(-999);
2224  m_eclShowerToMC3GMothPDG->push_back(-999);
2225  }
2226  } else {
2227  m_eclShowerToMC3Moth->push_back(-999);
2228  m_eclShowerToMC3MothPDG->push_back(-999);
2229  m_eclShowerToMC3GMoth->push_back(-999);
2230  m_eclShowerToMC3GMothPDG->push_back(-999);
2231  }
2232  } else {
2233  m_eclShowerToMCWeight3->push_back(-1);
2234  m_eclShowerToMC3->push_back(-1);
2235  m_eclShowerToMC3PDG->push_back(-1);
2236  m_eclShowerToMC3Moth->push_back(-1);
2237  m_eclShowerToMC3MothPDG->push_back(-1);
2238  m_eclShowerToMC3GMoth->push_back(-1);
2239  m_eclShowerToMC3GMothPDG->push_back(-1);
2240  }
2241  if (idx[3] > -1) {
2242  m_eclShowerToMCWeight4->push_back(wi[3]);
2243  m_eclShowerToMC4->push_back(idx[3]);
2244  MCParticle* amcParticle = m_mcParticles[idx[3]];
2245  m_eclShowerToMC4PDG->push_back(amcParticle->getPDG());
2246  if (amcParticle->getMother() != nullptr) {
2247  m_eclShowerToMC4Moth->push_back(amcParticle->getMother()->getIndex());
2248  m_eclShowerToMC4MothPDG->push_back(amcParticle->getMother()->getPDG());
2249  if (amcParticle->getMother()->getMother() != nullptr) {
2250  m_eclShowerToMC4GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2251  m_eclShowerToMC4GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2252  } else {
2253  m_eclShowerToMC4GMoth->push_back(-999);
2254  m_eclShowerToMC4GMothPDG->push_back(-999);
2255  }
2256  } else {
2257  m_eclShowerToMC4Moth->push_back(-999);
2258  m_eclShowerToMC4MothPDG->push_back(-999);
2259  m_eclShowerToMC4GMoth->push_back(-999);
2260  m_eclShowerToMC4GMothPDG->push_back(-999);
2261  }
2262  } else {
2263  m_eclShowerToMCWeight4->push_back(-1);
2264  m_eclShowerToMC4->push_back(-1);
2265  m_eclShowerToMC4PDG->push_back(-1);
2266  m_eclShowerToMC4Moth->push_back(-1);
2267  m_eclShowerToMC4MothPDG->push_back(-1);
2268  m_eclShowerToMC4GMoth->push_back(-1);
2269  m_eclShowerToMC4GMothPDG->push_back(-1);
2270  }
2271  if (idx[4] > -1) {
2272  m_eclShowerToMCWeight5->push_back(wi[4]);
2273  m_eclShowerToMC5->push_back(idx[4]);
2274  MCParticle* amcParticle = m_mcParticles[idx[4]];
2275  m_eclShowerToMC5PDG->push_back(amcParticle->getPDG());
2276  if (amcParticle->getMother() != nullptr) {
2277  m_eclShowerToMC5Moth->push_back(amcParticle->getMother()->getIndex());
2278  m_eclShowerToMC5MothPDG->push_back(amcParticle->getMother()->getPDG());
2279  if (amcParticle->getMother()->getMother() != nullptr) {
2280  m_eclShowerToMC5GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2281  m_eclShowerToMC5GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2282  } else {
2283  m_eclShowerToMC5GMoth->push_back(-999);
2284  m_eclShowerToMC5GMothPDG->push_back(-999);
2285  }
2286  } else {
2287  m_eclShowerToMC5Moth->push_back(-999);
2288  m_eclShowerToMC5MothPDG->push_back(-999);
2289  m_eclShowerToMC5GMoth->push_back(-999);
2290  m_eclShowerToMC5GMothPDG->push_back(-999);
2291  }
2292  } else {
2293  m_eclShowerToMCWeight5->push_back(-1);
2294  m_eclShowerToMC5->push_back(-1);
2295  m_eclShowerToMC5PDG->push_back(-1);
2296  m_eclShowerToMC5Moth->push_back(-1);
2297  m_eclShowerToMC5MothPDG->push_back(-1);
2298  m_eclShowerToMC5GMoth->push_back(-1);
2299  m_eclShowerToMC5GMothPDG->push_back(-1);
2300  }
2301  m_eclShowerToBkgWeight->push_back(aECLShowers->getEnergy() - sumHit);
2302  }
2303 
2304  m_mcMultip = m_mcParticles.getEntries();
2305  for (int imcpart = 0; imcpart < m_mcParticles.getEntries(); imcpart++) {
2306  MCParticle* amcParticle = m_mcParticles[imcpart];
2307  m_mcIdx->push_back(amcParticle->getArrayIndex());
2308  m_mcPdg->push_back(amcParticle->getPDG());
2309  if (amcParticle->getMother() != nullptr) m_mcMothPdg->push_back(amcParticle->getMother()->getPDG());
2310  else m_mcMothPdg->push_back(-999);
2311  if (amcParticle->getMother() != nullptr
2312  && amcParticle->getMother()->getMother() != nullptr) m_mcGMothPdg->push_back(amcParticle->getMother()->getMother()->getPDG());
2313  else m_mcGMothPdg->push_back(-999);
2314  if (amcParticle->getMother() != nullptr && amcParticle->getMother()->getMother() != nullptr
2315  && amcParticle->getMother()->getMother()->getMother() != nullptr)
2316  m_mcGGMothPdg->push_back(amcParticle->getMother()->getMother()->getMother()->getPDG());
2317  else m_mcGGMothPdg->push_back(-999);
2318  m_mcEnergy->push_back(amcParticle->getEnergy());
2319  m_mcSecondaryPhysProc->push_back(amcParticle->getSecondaryPhysicsProcess());
2320 
2321  m_mcPx->push_back(amcParticle->getMomentum().X());
2322  m_mcPy->push_back(amcParticle->getMomentum().Y());
2323  m_mcPz->push_back(amcParticle->getMomentum().Z());
2324 
2325  m_mcDecayVtxX->push_back(amcParticle->getDecayVertex().X());
2326  m_mcDecayVtxY->push_back(amcParticle->getDecayVertex().Y());
2327  m_mcDecayVtxZ->push_back(amcParticle->getDecayVertex().Z());
2328 
2329  m_mcProdVtxX->push_back(amcParticle->getProductionVertex().X());
2330  m_mcProdVtxY->push_back(amcParticle->getProductionVertex().Y());
2331  m_mcProdVtxZ->push_back(amcParticle->getProductionVertex().Z());
2332 
2333  }
2334 
2335  if (m_doTracking == true) {
2336  m_trkMultip = 0;
2337  for (const Track& itrk : m_tracks) {
2338  const TrackFitResult* atrk = itrk.getTrackFitResult(Const::pion);
2339  if (atrk == nullptr) continue;
2340 
2341  m_trkIdx->push_back(m_trkMultip);
2342  m_trkPdg->push_back(atrk->getParticleType().getPDGCode());
2343  m_trkCharge->push_back(atrk->getChargeSign());
2344  m_trkPx->push_back(atrk->getMomentum().X());
2345  m_trkPy->push_back(atrk->getMomentum().Y());
2346  m_trkPz->push_back(atrk->getMomentum().Z());
2347  m_trkP->push_back(atrk->getMomentum().R());
2348  m_trkTheta->push_back(atrk->getMomentum().Theta());
2349  m_trkPhi->push_back(atrk->getMomentum().Phi());
2350  m_trkX->push_back(atrk->getPosition().X());
2351  m_trkY->push_back(atrk->getPosition().Y());
2352  m_trkZ->push_back(atrk->getPosition().Z());
2353 
2354  const ECLPidLikelihood* eclpid = itrk.getRelatedTo<ECLPidLikelihood>() ;
2355 
2356  if (eclpid != nullptr) {
2357  m_eclpidtrkIdx -> push_back(m_trkMultip);
2358  m_eclpidEnergy -> push_back(eclpid-> energy());
2359  m_eclpidEop -> push_back(eclpid-> eop());
2360  m_eclpidE9E21 -> push_back(eclpid-> e9e25());
2361  m_eclpidNCrystals -> push_back(eclpid-> nCrystals());
2362  m_eclpidNClusters -> push_back(eclpid-> nClusters());
2363  m_eclLogLikeEl -> push_back(eclpid-> getLogLikelihood(Const::electron));
2364  m_eclLogLikeMu -> push_back(eclpid-> getLogLikelihood(Const::muon));
2365  m_eclLogLikePi -> push_back(eclpid-> getLogLikelihood(Const::pion));
2366  } else {
2367  m_eclpidtrkIdx -> push_back(m_trkMultip);
2368  m_eclpidEnergy -> push_back(0);
2369  m_eclpidEop -> push_back(0);
2370  m_eclpidE9E21 -> push_back(0);
2371  m_eclpidNCrystals -> push_back(0);
2372  m_eclpidNClusters -> push_back(0);
2373  m_eclLogLikeEl -> push_back(0);
2374  m_eclLogLikeMu -> push_back(0);
2375  m_eclLogLikePi -> push_back(0);
2376  }
2377  m_trkMultip++;
2378  }
2379  }
2380 
2381  m_tree->Fill();
2382 }
2383 
2384 void ECLDataAnalysisModule::endRun()
2385 {
2386 }
2387 
2388 void ECLDataAnalysisModule::terminate()
2389 {
2390 
2391  if (m_rootFilePtr != nullptr) {
2392  m_rootFilePtr->cd();
2393  m_tree->Write();
2394  }
2395 
2396 }
Belle2::Const::ParticleType::getPDGCode
int getPDGCode() const
PDG code.
Definition: Const.h:464
Belle2::Const::muon
static const ChargedStable muon
muon particle
Definition: Const.h:651
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:652
Belle2::Const::Klong
static const ParticleType Klong
K^0_L particle.
Definition: Const.h:669
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition: Const.h:650
Belle2::ECLCalDigit
Class to store calibrated ECLDigits: ECLCalDigits.
Definition: ECLCalDigit.h:23
Belle2::ECLCalDigit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLCalDigit.h:114
Belle2::ECLCalDigit::getEnergy
double getEnergy() const
Get Calibrated Energy.
Definition: ECLCalDigit.h:119
Belle2::ECLCalDigit::getTime
double getTime() const
Get Calibrated Time.
Definition: ECLCalDigit.h:159
Belle2::ECLCluster
ECL cluster data.
Definition: ECLCluster.h:27
Belle2::ECLCluster::getMaxECellId
unsigned short getMaxECellId() const
Return cellID of maximum energy crystal.
Definition: ECLCluster.h:247
Belle2::ECLCluster::isTrack
bool isTrack() const
Return true if the cluster matches with track.
Definition: ECLCluster.h:235
Belle2::ECLCluster::hasHypothesis
bool hasHypothesis(EHypothesisBit bitmask) const
Return if specific hypothesis bit is set.
Definition: ECLCluster.h:348
Belle2::ECLCluster::getPhi
double getPhi() const
Return Corrected Phi of Shower (radian).
Definition: ECLCluster.h:301
Belle2::ECLCluster::getE1oE9
double getE1oE9() const
Return E1/E9 (shower shape variable).
Definition: ECLCluster.h:274
Belle2::ECLCluster::getDeltaL
double getDeltaL() const
Return deltaL.
Definition: ECLCluster.h:262
Belle2::ECLCluster::getR
double getR() const
Return R.
Definition: ECLCluster.h:307
Belle2::ECLCluster::getEnergyRaw
double getEnergyRaw() const
Return Uncorrected Energy deposited (GeV)
Definition: ECLCluster.h:313
Belle2::ECLCluster::getUncertaintyTheta
double getUncertaintyTheta() const
Return Uncertainty on Theta of Shower.
Definition: ECLCluster.h:322
Belle2::ECLCluster::getLAT
double getLAT() const
Return LAT (shower shape variable).
Definition: ECLCluster.h:289
Belle2::ECLCluster::getE9oE21
double getE9oE21() const
Return E9/E21 (shower shape variable).
Definition: ECLCluster.h:277
Belle2::ECLCluster::getDetectorRegion
int getDetectorRegion() const
Return detector region: 0: below acceptance, 1: FWD, 2: BRL, 3: BWD, 11: FWDGAP, 13: BWDGAP.
Definition: ECLCluster.cc:70
Belle2::ECLCluster::getStatus
unsigned short getStatus() const
Return status.
Definition: ECLCluster.h:241
Belle2::ECLCluster::getEnergy
double getEnergy(EHypothesisBit hypothesis) const
Return Energy (GeV).
Definition: ECLCluster.cc:23
Belle2::ECLCluster::getUncertaintyEnergy
double getUncertaintyEnergy() const
Return Uncertainty on Energy of Shower.
Definition: ECLCluster.h:319
Belle2::ECLCluster::getMinTrkDistance
double getMinTrkDistance() const
Get distance between cluster COG and track extrapolation to ECL.
Definition: ECLCluster.h:256
Belle2::ECLCluster::getNumberOfCrystals
double getNumberOfCrystals() const
Return number of a crystals in a shower (sum of weights).
Definition: ECLCluster.h:292
Belle2::ECLCluster::getEnergyHighestCrystal
double getEnergyHighestCrystal() const
Return energy of highest energetic crystal in cluster (GeV)
Definition: ECLCluster.h:316
Belle2::ECLCluster::getZernikeMVA
double getZernikeMVA() const
Return MVA based hadron/photon value based on Zernike moments (shower shape variable).
Definition: ECLCluster.h:271
Belle2::ECLCluster::getUncertaintyPhi
double getUncertaintyPhi() const
Return Uncertainty on Phi of Shower.
Definition: ECLCluster.h:325
Belle2::ECLCluster::getAbsZernike40
double getAbsZernike40() const
Return Zernike moment 40 (shower shape variable).
Definition: ECLCluster.h:265
Belle2::ECLCluster::getSecondMoment
double getSecondMoment() const
Return second moment (shower shape variable).
Definition: ECLCluster.h:286
Belle2::ECLCluster::getTheta
double getTheta() const
Return Corrected Theta of Shower (radian).
Definition: ECLCluster.h:304
Belle2::ECLCluster::getDeltaTime99
double getDeltaTime99() const
Return cluster delta time 99.
Definition: ECLCluster.h:298
Belle2::ECLCluster::getTime
double getTime() const
Return cluster time.
Definition: ECLCluster.h:295
Belle2::ECLCluster::EHypothesisBit::c_nPhotons
@ c_nPhotons
CR is split into n photons (N1)
Belle2::ECLCluster::EHypothesisBit::c_neutralHadron
@ c_neutralHadron
CR is reconstructed as a neutral hadron (N2)
Belle2::ECLCluster::getAbsZernike51
double getAbsZernike51() const
Return Zernike moment 51 (shower shape variable).
Definition: ECLCluster.h:268
Belle2::ECLConnectedRegion
Class to store connected regions (CRs)
Definition: ECLConnectedRegion.h:21
Belle2::ECLConnectedRegion::getLikelihoodChargedHadron
float getLikelihoodChargedHadron() const
Get Charged Hadron likelihood (ECL based only) T2.
Definition: ECLConnectedRegion.h:89
Belle2::ECLConnectedRegion::isTrack
bool isTrack() const
Get boolean to flag if a track is matched to the CR.
Definition: ECLConnectedRegion.h:79
Belle2::ECLConnectedRegion::getLikelihoodNeutralHadron
float getLikelihoodNeutralHadron() const
Get Neutral Hadron likelihood (ECL based only) N2.
Definition: ECLConnectedRegion.h:104
Belle2::ECLConnectedRegion::getLikelihoodMIPNGamma
float getLikelihoodMIPNGamma() const
Get MIPNGamma likelihood (ECL based only) T1.
Definition: ECLConnectedRegion.h:84
Belle2::ECLConnectedRegion::getLikelihoodNGamma
float getLikelihoodNGamma() const
Get NGamma likelihood (ECL based only) N1.
Definition: ECLConnectedRegion.h:99
Belle2::ECLConnectedRegion::getCRId
int getCRId() const
Get CR identifieer.
Definition: ECLConnectedRegion.h:74
Belle2::ECLConnectedRegion::getLikelihoodMergedPi0
float getLikelihoodMergedPi0() const
Get Merged Pi0 likelihood (ECL based only) N3.
Definition: ECLConnectedRegion.h:109
Belle2::ECLConnectedRegion::getLikelihoodElectronNGamma
float getLikelihoodElectronNGamma() const
Get ElectronNGamma likelihood (ECL based only) T3.
Definition: ECLConnectedRegion.h:94
Belle2::ECLDataAnalysisModule::m_eclClusterToMC4PDG
std::vector< int > * m_eclClusterToMC4PDG
PDG code of fourth MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:279
Belle2::ECLDataAnalysisModule::m_eclShowerToLM5
std::vector< int > * m_eclShowerToLM5
Index of 5th maximum related to ECLShower.
Definition: ECLDataAnalysisModule.h:468
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2PDG
std::vector< int > * m_eclShowerToMC2PDG
PDG code of second MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:436
Belle2::ECLDataAnalysisModule::m_eclShowerTimeResolution
std::vector< double > * m_eclShowerTimeResolution
Shower Time Resolution.
Definition: ECLDataAnalysisModule.h:485
Belle2::ECLDataAnalysisModule::m_doPureCsI
bool m_doPureCsI
if true, info on pureCsI upgrade is stored
Definition: ECLDataAnalysisModule.h:88
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC5PDG
std::vector< int > * m_eclPureCalDigitToMC5PDG
PDG code of fifth MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:344
Belle2::ECLDataAnalysisModule::m_rootFileName
std::string m_rootFileName
name of the root file
Definition: ECLDataAnalysisModule.h:85
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight5
std::vector< double > * m_eclPureCalDigitToMCWeight5
Energy contribution of fifth MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:346
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5GMothPDG
std::vector< int > * m_eclShowerToMC5GMothPDG
PDG code of Gparent of fifth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:461
Belle2::ECLDataAnalysisModule::m_eclLogLikeEl
std::vector< double > * m_eclLogLikeEl
PID track electron likelyhood.
Definition: ECLDataAnalysisModule.h:543
Belle2::ECLDataAnalysisModule::m_eclDigitMultip
int m_eclDigitMultip
Number of ECLDigits per event.
Definition: ECLDataAnalysisModule.h:188
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight5
std::vector< double > * m_eclClusterToMCWeight5
Energy contribution of 5th MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:281
Belle2::ECLDataAnalysisModule::m_doHits
bool m_doHits
if true, info on Hits and SimHits is stored
Definition: ECLDataAnalysisModule.h:89
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4MothPDG
std::vector< int > * m_eclShowerToMC4MothPDG
PDG code of parent of fourth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:452
Belle2::ECLDataAnalysisModule::m_mcPy
std::vector< double > * m_mcPy
MCParticle momentum Y direction.
Definition: ECLDataAnalysisModule.h:513
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight1
std::vector< double > * m_eclCalDigitToMCWeight1
Energy contribution of first MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:201
Belle2::ECLDataAnalysisModule::m_eclClusterTheta
std::vector< double > * m_eclClusterTheta
ECLCluster polar direction.
Definition: ECLDataAnalysisModule.h:289
Belle2::ECLDataAnalysisModule::m_eclClusterNofCrystals
std::vector< int > * m_eclClusterNofCrystals
Number of crystals in ECLCluster.
Definition: ECLDataAnalysisModule.h:300
Belle2::ECLDataAnalysisModule::m_eclPureClusterToBkgWeight
std::vector< double > * m_eclPureClusterToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLCluster,...
Definition: ECLDataAnalysisModule.h:395
Belle2::ECLDataAnalysisModule::eclPureCalDigitArrayName
virtual const char * eclPureCalDigitArrayName() const
Default name ECLPureCalDigits array.
Definition: ECLDataAnalysisModule.h:150
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodNeutralHadron
std::vector< double > * m_eclPureCRLikelihoodNeutralHadron
Connected Region Neutral Hadron Likelihood, PureCsI option.
Definition: ECLDataAnalysisModule.h:364
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC3PDG
std::vector< int > * m_eclPureCalDigitToMC3PDG
PDG code of third MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:336
Belle2::ECLDataAnalysisModule::m_eclClusterDetectorRegion
std::vector< int > * m_eclClusterDetectorRegion
Cluster Detector Region.
Definition: ECLDataAnalysisModule.h:312
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC2
std::vector< int > * m_eclPureCalDigitToMC2
Index of second MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:331
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight2
std::vector< double > * m_eclCalDigitToMCWeight2
Energy contribution of second MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:204
Belle2::ECLDataAnalysisModule::eclDigitArrayName
virtual const char * eclDigitArrayName() const
Default name ECLDigits array.
Definition: ECLDataAnalysisModule.h:114
Belle2::ECLDataAnalysisModule::m_eclCRIdx
std::vector< int > * m_eclCRIdx
Connected Region ID.
Definition: ECLDataAnalysisModule.h:225
Belle2::ECLDataAnalysisModule::m_eclClusterCellId
std::vector< int > * m_eclClusterCellId
CellId with highest energy deposit in ECLCluster.
Definition: ECLDataAnalysisModule.h:299
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToShower
std::vector< int > * m_eclPureCalDigitToShower
Index of ECLShower related to that CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:350
Belle2::ECLDataAnalysisModule::m_eclHitToMC
std::vector< int > * m_eclHitToMC
Index of MCParticle related to ECLHit.
Definition: ECLDataAnalysisModule.h:255
Belle2::ECLDataAnalysisModule::m_eclClusterToMC3PDG
std::vector< int > * m_eclClusterToMC3PDG
PDG code of third MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:276
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodElectronNGamma
std::vector< double > * m_eclCRLikelihoodElectronNGamma
Connected Region Electron Likelihood.
Definition: ECLDataAnalysisModule.h:229
Belle2::ECLDataAnalysisModule::m_eclCalDigitTimeFit
std::vector< double > * m_eclCalDigitTimeFit
ECLCalDigit timing.
Definition: ECLDataAnalysisModule.h:220
Belle2::ECLDataAnalysisModule::m_eclPureClusterDeltaL
std::vector< double > * m_eclPureClusterDeltaL
Reconstructed Cluster DeltaL, PureCsI option.
Definition: ECLDataAnalysisModule.h:413
Belle2::ECLDataAnalysisModule::m_tree
TTree * m_tree
Root tree and file for saving the output.
Definition: ECLDataAnalysisModule.h:167
Belle2::ECLDataAnalysisModule::m_eclShowers
StoreArray< ECLShower > m_eclShowers
Store array: ECLShower.
Definition: ECLDataAnalysisModule.h:101
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight5
std::vector< double > * m_eclCalDigitToMCWeight5
Energy contribution of fifth MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:213
Belle2::ECLDataAnalysisModule::m_eclSimHitFlightTime
std::vector< double > * m_eclSimHitFlightTime
ECLSimhit Flight Time.
Definition: ECLDataAnalysisModule.h:245
Belle2::ECLDataAnalysisModule::m_eclClusterIdx
std::vector< int > * m_eclClusterIdx
ECLCluster index.
Definition: ECLDataAnalysisModule.h:267
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC5
std::vector< int > * m_eclPureClusterToMC5
Index of fifth MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:390
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToBkgWeight
std::vector< double > * m_eclPureCalDigitToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to CalDigit,...
Definition: ECLDataAnalysisModule.h:348
Belle2::ECLDataAnalysisModule::m_eclShowerEnergyError
std::vector< double > * m_eclShowerEnergyError
Shower Energy Error.
Definition: ECLDataAnalysisModule.h:482
Belle2::ECLDataAnalysisModule::m_eclConnectedRegions
StoreArray< ECLConnectedRegion > m_eclConnectedRegions
Store array: ECLConnectedRegion.
Definition: ECLDataAnalysisModule.h:100
Belle2::ECLDataAnalysisModule::m_eclShowerTime
std::vector< double > * m_eclShowerTime
Shower Timing.
Definition: ECLDataAnalysisModule.h:477
Belle2::ECLDataAnalysisModule::m_trkMultip
int m_trkMultip
Track Multiplicity.
Definition: ECLDataAnalysisModule.h:523
Belle2::ECLDataAnalysisModule::m_eclShowerTheta
std::vector< double > * m_eclShowerTheta
Shower Theta.
Definition: ECLDataAnalysisModule.h:472
Belle2::ECLDataAnalysisModule::m_eclShowerShowerDepth
std::vector< double > * m_eclShowerShowerDepth
Shower Depth.
Definition: ECLDataAnalysisModule.h:490
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4GMoth
std::vector< int > * m_eclShowerToMC4GMoth
GMother index of fourth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:453
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight4
std::vector< double > * m_eclCalDigitToMCWeight4
Energy contribution of fourth MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:210
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitCellId
std::vector< int > * m_eclPureCalDigitCellId
Number of CalDigit CellId, PureCsI option.
Definition: ECLDataAnalysisModule.h:351
Belle2::ECLDataAnalysisModule::m_eclClusterR
std::vector< double > * m_eclClusterR
ECLCluster distance from IP.
Definition: ECLDataAnalysisModule.h:293
Belle2::ECLDataAnalysisModule::m_eclPureClusterIsTrack
std::vector< bool > * m_eclPureClusterIsTrack
Flag for charged clusters, PureCsI option.
Definition: ECLDataAnalysisModule.h:412
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC1
std::vector< int > * m_eclPureCalDigitToMC1
Index of first MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:327
Belle2::ECLDataAnalysisModule::m_writeToRoot
bool m_writeToRoot
if true, a rootFile named by m_rootFileName will be filled with info
Definition: ECLDataAnalysisModule.h:86
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC5PDG
std::vector< int > * m_eclPureClusterToMC5PDG
PDG code of fifth MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:393
Belle2::ECLDataAnalysisModule::m_eclShowerE9oE21
std::vector< double > * m_eclShowerE9oE21
Shower E9oE21.
Definition: ECLDataAnalysisModule.h:476
Belle2::ECLDataAnalysisModule::m_eclPureClusterTimingError
std::vector< double > * m_eclPureClusterTimingError
Cluster time error, PureCsI option.
Definition: ECLDataAnalysisModule.h:405
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC3
std::vector< int > * m_eclPureClusterToMC3
Index of third MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:382
Belle2::ECLDataAnalysisModule::m_eclPureDigitToCluster
std::vector< int > * m_eclPureDigitToCluster
ECLDigit To Cluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:323
Belle2::ECLDataAnalysisModule::m_doDigits
bool m_doDigits
if true, info on Digits and CalDigits is stored
Definition: ECLDataAnalysisModule.h:90
Belle2::ECLDataAnalysisModule::m_eclPureClusterEnergyDepSum
std::vector< double > * m_eclPureClusterEnergyDepSum
Cluster simulated energy, PureCsI option.
Definition: ECLDataAnalysisModule.h:403
Belle2::ECLDataAnalysisModule::m_eclShowerNumberOfCrystalsForEnergy
std::vector< double > * m_eclShowerNumberOfCrystalsForEnergy
Number of crystals used for energy calculation.
Definition: ECLDataAnalysisModule.h:503
Belle2::ECLDataAnalysisModule::m_eclShowerIsCluster
std::vector< bool > * m_eclShowerIsCluster
Shower Cluster Match.
Definition: ECLDataAnalysisModule.h:497
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC3PDG
std::vector< int > * m_eclPureClusterToMC3PDG
PDG code of third MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:385
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC2PDG
std::vector< int > * m_eclCalDigitToMC2PDG
PDG code of second MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:203
Belle2::ECLDataAnalysisModule::m_mcDecayVtxZ
std::vector< double > * m_mcDecayVtxZ
MCParticle decay vertex Z.
Definition: ECLDataAnalysisModule.h:517
Belle2::ECLDataAnalysisModule::m_eclPureDigitToMC
std::vector< int > * m_eclPureDigitToMC
Index of MCParticle related to that ECLDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:318
Belle2::ECLDataAnalysisModule::m_eclClusterToMC5PDG
std::vector< int > * m_eclClusterToMC5PDG
PDG code of fifth MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:282
Belle2::ECLDataAnalysisModule::m_eclPureClusterZernikeMVA
std::vector< double > * m_eclPureClusterZernikeMVA
Output of MVA classifier based on Zernike Momenta, PureCsI option.
Definition: ECLDataAnalysisModule.h:417
Belle2::ECLDataAnalysisModule::m_eclSimHitX
std::vector< double > * m_eclSimHitX
ECLSimHit X position.
Definition: ECLDataAnalysisModule.h:246
Belle2::ECLDataAnalysisModule::initialize
virtual void initialize() override
Initializes the Module.
Definition: ECLDataAnalysisModule.cc:440
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC2
std::vector< int > * m_eclCalDigitToMC2
Index of second MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:202
Belle2::ECLDataAnalysisModule::m_eclPureCalDigits
StoreArray< ECLCalDigit > m_eclPureCalDigits
Store array: ECLPureCalDigit.
Definition: ECLDataAnalysisModule.h:136
Belle2::ECLDataAnalysisModule::m_eclShowerHypothesisId
std::vector< int > * m_eclShowerHypothesisId
Shower Particle Hypothesis ID.
Definition: ECLDataAnalysisModule.h:480
Belle2::ECLDataAnalysisModule::m_eclSimHitPz
std::vector< double > * m_eclSimHitPz
ECLSimHit PZ.
Definition: ECLDataAnalysisModule.h:251
Belle2::ECLDataAnalysisModule::m_eclShowerMCVtxInEcl
std::vector< int > * m_eclShowerMCVtxInEcl
Int, 1 if particle decays (interacts) in ECL, 0 otherwise.
Definition: ECLDataAnalysisModule.h:498
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToCR
std::vector< int > * m_eclPureCalDigitToCR
Index of CR related to that CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:355
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight4
std::vector< double > * m_eclShowerToMCWeight4
Energy contribution of fourth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:449
Belle2::ECLDataAnalysisModule::m_eclPureClusterDeltaTime99
std::vector< double > * m_eclPureClusterDeltaTime99
Reconstructed DeltaT99, PureCsI option.
Definition: ECLDataAnalysisModule.h:420
Belle2::ECLDataAnalysisModule::m_eclHitMultip
int m_eclHitMultip
Number of ECLHits per event.
Definition: ECLDataAnalysisModule.h:253
Belle2::ECLDataAnalysisModule::m_eclClusterZernikeMVA
std::vector< double > * m_eclClusterZernikeMVA
Zernike MVA.
Definition: ECLDataAnalysisModule.h:307
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5PDG
std::vector< int > * m_eclShowerToMC5PDG
PDG code of fifth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:457
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3PDG
std::vector< int > * m_eclShowerToMC3PDG
PDG code of third MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:443
Belle2::ECLDataAnalysisModule::m_eclPureLMType
std::vector< int > * m_eclPureLMType
Local Maximum type, PureCsI option.
Definition: ECLDataAnalysisModule.h:369
Belle2::ECLDataAnalysisModule::m_trkCharge
std::vector< int > * m_trkCharge
Track charge.
Definition: ECLDataAnalysisModule.h:526
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2
std::vector< int > * m_eclShowerToMC2
Index of second MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:434
Belle2::ECLDataAnalysisModule::m_eclShowerToBkgWeight
std::vector< double > * m_eclShowerToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLShower.
Definition: ECLDataAnalysisModule.h:463
Belle2::ECLDataAnalysisModule::m_trkPx
std::vector< double > * m_trkPx
Track momentum along X direction.
Definition: ECLDataAnalysisModule.h:527
Belle2::ECLDataAnalysisModule::m_eclPureClusterAbsZernike51
std::vector< double > * m_eclPureClusterAbsZernike51
Reconstructed Zernike51, PureCsI option.
Definition: ECLDataAnalysisModule.h:416
Belle2::ECLDataAnalysisModule::m_eclDigitToMC
std::vector< int > * m_eclDigitToMC
Index of MCParticle related to that ECLDigit.
Definition: ECLDataAnalysisModule.h:190
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodMergedPi0
std::vector< double > * m_eclPureCRLikelihoodMergedPi0
Connected Region Merged Pi0 Likelihood, PureCsI option.
Definition: ECLDataAnalysisModule.h:365
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodMIPNGamma
std::vector< double > * m_eclCRLikelihoodMIPNGamma
Connected Region MIP Likelihood.
Definition: ECLDataAnalysisModule.h:227
Belle2::ECLDataAnalysisModule::m_eclClusterToMC4
std::vector< int > * m_eclClusterToMC4
Index of fourth MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:277
Belle2::ECLDataAnalysisModule::m_eclSimHitCellId
std::vector< int > * m_eclSimHitCellId
ECLSimHit CellId.
Definition: ECLDataAnalysisModule.h:242
Belle2::ECLDataAnalysisModule::m_eclLocalMaximums
StoreArray< ECLLocalMaximum > m_eclLocalMaximums
Store array: ECLLocalMaximum.
Definition: ECLDataAnalysisModule.h:103
Belle2::ECLDataAnalysisModule::eclPureClusterArrayName
virtual const char * eclPureClusterArrayName() const
Default name ECLPureClusters array.
Definition: ECLDataAnalysisModule.h:156
Belle2::ECLDataAnalysisModule::event
virtual void event() override
event
Definition: ECLDataAnalysisModule.cc:865
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodNeutralHadron
std::vector< double > * m_eclCRLikelihoodNeutralHadron
Connected Region Neutral Hadron Likelihood.
Definition: ECLDataAnalysisModule.h:231
Belle2::ECLDataAnalysisModule::m_eclPureClusterTiming
std::vector< double > * m_eclPureClusterTiming
Cluster time, PureCsI option.
Definition: ECLDataAnalysisModule.h:404
Belle2::ECLDataAnalysisModule::m_trkZ
std::vector< double > * m_trkZ
Track DOCA Z (?)
Definition: ECLDataAnalysisModule.h:535
Belle2::ECLDataAnalysisModule::m_eclCalDigitSimHitSum
std::vector< double > * m_eclCalDigitSimHitSum
Full energy contribution related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:216
Belle2::ECLDataAnalysisModule::m_eclPureClusterHasNPhotonHypothesis
std::vector< int > * m_eclPureClusterHasNPhotonHypothesis
Cluster has n-photon hypothesis, PureCsI option.
Definition: ECLDataAnalysisModule.h:422
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight4
std::vector< double > * m_eclPureCalDigitToMCWeight4
Energy contribution of fourth MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:342
Belle2::ECLDataAnalysisModule::m_eclCalDigitFitQuality
std::vector< int > * m_eclCalDigitFitQuality
ECLCalDigit fit quality.
Definition: ECLDataAnalysisModule.h:221
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5GMoth
std::vector< int > * m_eclShowerToMC5GMoth
GMother index of fifth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:460
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC4
std::vector< int > * m_eclCalDigitToMC4
Index of fourth MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:208
Belle2::ECLDataAnalysisModule::m_eclHitEnergyDep
std::vector< double > * m_eclHitEnergyDep
ECLHit energy.
Definition: ECLDataAnalysisModule.h:261
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodChargedHadron
std::vector< double > * m_eclCRLikelihoodChargedHadron
Connected Region Charged Hadron Likelihood.
Definition: ECLDataAnalysisModule.h:228
Belle2::ECLDataAnalysisModule::m_eclShowerMCFlightMatch
std::vector< int > * m_eclShowerMCFlightMatch
Int, 1 if particle flight direction is "well" reconstructed in ECL, 0 otherwise.
Definition: ECLDataAnalysisModule.h:499
Belle2::ECLDataAnalysisModule::m_eclClusterPhi
std::vector< double > * m_eclClusterPhi
ECLCluster azimuthal direction.
Definition: ECLDataAnalysisModule.h:291
Belle2::ECLDataAnalysisModule::m_eclClusterAbsZernike40
std::vector< double > * m_eclClusterAbsZernike40
Reconstructed Abs Zernike40.
Definition: ECLDataAnalysisModule.h:305
Belle2::ECLDataAnalysisModule::m_eclCalDigitMultip
int m_eclCalDigitMultip
Number of ECLCalDigits per event.
Definition: ECLDataAnalysisModule.h:197
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4Moth
std::vector< int > * m_eclShowerToMC4Moth
Mother index of fourth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:451
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3GMoth
std::vector< int > * m_eclShowerToMC3GMoth
GMother index of third MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:446
Belle2::ECLDataAnalysisModule::m_eclPureClusterHighestE
std::vector< double > * m_eclPureClusterHighestE
Highest energy deposit (per crystal) in Cluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:407
Belle2::ECLDataAnalysisModule::m_eclClusterHasNPhotonHypothesis
std::vector< int > * m_eclClusterHasNPhotonHypothesis
Cluster has n-photon hypothesis.
Definition: ECLDataAnalysisModule.h:313
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC2PDG
std::vector< int > * m_eclPureClusterToMC2PDG
PDG code of second MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:381
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight2
std::vector< double > * m_eclShowerToMCWeight2
Energy contribution of second MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:435
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1PDG
std::vector< int > * m_eclShowerToMC1PDG
PDG code of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:429
Belle2::ECLDataAnalysisModule::m_nECLCalDigitsOutOfTimeFWD
uint16_t m_nECLCalDigitsOutOfTimeFWD
Number of out of time, energetic ECLCalDigits, FWD.
Definition: ECLDataAnalysisModule.h:176
Belle2::ECLDataAnalysisModule::m_eclSimHitEnergyDep
std::vector< double > * m_eclSimHitEnergyDep
Energy deposition of ECLSimHit.
Definition: ECLDataAnalysisModule.h:244
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC2PDG
std::vector< int > * m_eclPureCalDigitToMC2PDG
PDG code of second MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:332
Belle2::ECLDataAnalysisModule::m_trkPz
std::vector< double > * m_trkPz
Track momentum along Z direction.
Definition: ECLDataAnalysisModule.h:529
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight1
std::vector< double > * m_eclClusterToMCWeight1
Energy contribution of first MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:269
Belle2::ECLDataAnalysisModule::m_eclShowerToLM2
std::vector< int > * m_eclShowerToLM2
Index of 2nd maximum related to ECLShower.
Definition: ECLDataAnalysisModule.h:465
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC4
std::vector< int > * m_eclPureCalDigitToMC4
Index of fourth MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:339
Belle2::ECLDataAnalysisModule::m_eclPureClusterNofCrystals
std::vector< int > * m_eclPureClusterNofCrystals
Number of crystals in Cluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:410
Belle2::ECLDataAnalysisModule::m_eclHitToPureDigit
std::vector< int > * m_eclHitToPureDigit
Index of ECLDigit related to ECLHit, PureCsI option.
Definition: ECLDataAnalysisModule.h:258
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3GMothPDG
std::vector< int > * m_eclShowerToMC3GMothPDG
PDG code of Gparent of third MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:447
Belle2::ECLDataAnalysisModule::eclShowerArrayName
virtual const char * eclShowerArrayName() const
Default name ECLShower array.
Definition: ECLDataAnalysisModule.h:120
Belle2::ECLDataAnalysisModule::endRun
virtual void endRun() override
endRun
Definition: ECLDataAnalysisModule.cc:2384
Belle2::ECLDataAnalysisModule::m_eclPureClusterMultip
int m_eclPureClusterMultip
Number of ECLClusterss per event, PureCsI option.
Definition: ECLDataAnalysisModule.h:372
Belle2::ECLDataAnalysisModule::m_eclShowerMinTrkDistance
std::vector< double > * m_eclShowerMinTrkDistance
Shower Min Dist to Track.
Definition: ECLDataAnalysisModule.h:488
Belle2::ECLDataAnalysisModule::m_eclSimHitPx
std::vector< double > * m_eclSimHitPx
ECLSimHit PX.
Definition: ECLDataAnalysisModule.h:249
Belle2::ECLDataAnalysisModule::m_eclPureClusterCellId
std::vector< int > * m_eclPureClusterCellId
CellId with highest energy deposit in Cluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:408
Belle2::ECLDataAnalysisModule::m_eclCalDigitToShower
std::vector< int > * m_eclCalDigitToShower
Index of ECLShower related to that ECLCalDigit.
Definition: ECLDataAnalysisModule.h:217
Belle2::ECLDataAnalysisModule::m_eclSimHitZ
std::vector< double > * m_eclSimHitZ
ECLSimHit Z position.
Definition: ECLDataAnalysisModule.h:248
Belle2::ECLDataAnalysisModule::m_eclClusterThetaError
std::vector< double > * m_eclClusterThetaError
ECLCluster error on polar direction.
Definition: ECLDataAnalysisModule.h:290
Belle2::ECLDataAnalysisModule::m_nECLShowersRejectedBWD
uint8_t m_nECLShowersRejectedBWD
Number of photon showers that are rejected before storing to mdst (max.
Definition: ECLDataAnalysisModule.h:186
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC2
std::vector< int > * m_eclPureClusterToMC2
Index of second MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:378
Belle2::ECLDataAnalysisModule::m_eclClusterAbsZernike51
std::vector< double > * m_eclClusterAbsZernike51
Reconstructed Abs Zernike51.
Definition: ECLDataAnalysisModule.h:306
Belle2::ECLDataAnalysisModule::m_trackFitResults
StoreArray< TrackFitResult > m_trackFitResults
TrackFitResult storeArray.
Definition: ECLDataAnalysisModule.h:94
Belle2::ECLDataAnalysisModule::m_eclDigitAmp
std::vector< int > * m_eclDigitAmp
ECLDigit amplitude.
Definition: ECLDataAnalysisModule.h:192
Belle2::ECLDataAnalysisModule::m_trkPy
std::vector< double > * m_trkPy
Track momentum along Y direction.
Definition: ECLDataAnalysisModule.h:528
Belle2::ECLDataAnalysisModule::m_eclClusterEnergyDepSum
std::vector< double > * m_eclClusterEnergyDepSum
ECLCluster simulated energy.
Definition: ECLDataAnalysisModule.h:294
Belle2::ECLDataAnalysisModule::m_eclPureClusterThetaError
std::vector< double > * m_eclPureClusterThetaError
Cluster error on polar direction, PureCsI option.
Definition: ECLDataAnalysisModule.h:399
Belle2::ECLDataAnalysisModule::m_eclPureDigitIdx
std::vector< int > * m_eclPureDigitIdx
ECLDigit index, PureCsI option.
Definition: ECLDataAnalysisModule.h:317
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2GMothPDG
std::vector< int > * m_eclShowerToMC2GMothPDG
PDG code of Gparent of second MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:440
Belle2::ECLDataAnalysisModule::m_mcPdg
std::vector< int > * m_mcPdg
MCParticle PDG code.
Definition: ECLDataAnalysisModule.h:507
Belle2::ECLDataAnalysisModule::m_eclShowerSecondMoment
std::vector< double > * m_eclShowerSecondMoment
Shower Second Moment.
Definition: ECLDataAnalysisModule.h:494
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5
std::vector< int > * m_eclShowerToMC5
Index of fifth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:455
Belle2::ECLDataAnalysisModule::terminate
virtual void terminate() override
Termination action.
Definition: ECLDataAnalysisModule.cc:2388
Belle2::ECLDataAnalysisModule::m_mcDecayVtxY
std::vector< double > * m_mcDecayVtxY
MCParticle decay vertex Y.
Definition: ECLDataAnalysisModule.h:516
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3MothPDG
std::vector< int > * m_eclShowerToMC3MothPDG
PDG code of parent of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:445
Belle2::ECLDataAnalysisModule::m_eclSimHits
StoreArray< ECLSimHit > m_eclSimHits
Store array: ECLSimHit.
Definition: ECLDataAnalysisModule.h:96
Belle2::ECLDataAnalysisModule::m_eclClusterToMC5
std::vector< int > * m_eclClusterToMC5
Index of fifth MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:280
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4GMothPDG
std::vector< int > * m_eclShowerToMC4GMothPDG
PDG code of Gparent of fourth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:454
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight5
std::vector< double > * m_eclPureClusterToMCWeight5
Energy contribution of 5th MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:392
Belle2::ECLDataAnalysisModule::m_eclShowerToLM3
std::vector< int > * m_eclShowerToLM3
Index of 3rd maximum related to ECLShower.
Definition: ECLDataAnalysisModule.h:466
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight1
std::vector< double > * m_eclPureClusterToMCWeight1
Energy contribution of first MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:376
Belle2::ECLDataAnalysisModule::m_eclPureDigitFitQuality
std::vector< int > * m_eclPureDigitFitQuality
ECLDigit fit quality, PureCsI option.
Definition: ECLDataAnalysisModule.h:322
Belle2::ECLDataAnalysisModule::m_eclDigits
StoreArray< ECLDigit > m_eclDigits
Store array: ECLDigit.
Definition: ECLDataAnalysisModule.h:98
Belle2::ECLDataAnalysisModule::m_eclClusterEnergyError
std::vector< double > * m_eclClusterEnergyError
ECLCluster energy error.
Definition: ECLDataAnalysisModule.h:288
Belle2::ECLDataAnalysisModule::m_eclClusterPhiError
std::vector< double > * m_eclClusterPhiError
ECLCluster error on azimuthal direction.
Definition: ECLDataAnalysisModule.h:292
Belle2::ECLDataAnalysisModule::m_trkIdx
std::vector< int > * m_trkIdx
Track index.
Definition: ECLDataAnalysisModule.h:525
Belle2::ECLDataAnalysisModule::m_eclCalDigitToCR
std::vector< int > * m_eclCalDigitToCR
Index of CR related to that ECLCalDigit.
Definition: ECLDataAnalysisModule.h:222
Belle2::ECLDataAnalysisModule::m_eclClusterToMC3
std::vector< int > * m_eclClusterToMC3
Index of third MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:274
Belle2::ECLDataAnalysisModule::m_eclClusterSimHitSum
std::vector< double > * m_eclClusterSimHitSum
Energy contribution of 1st MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:285
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitFitQuality
std::vector< int > * m_eclPureCalDigitFitQuality
CalDigit fit quality, PureCsI option.
Definition: ECLDataAnalysisModule.h:354
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC1PDG
std::vector< int > * m_eclPureCalDigitToMC1PDG
PDG code of first MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:328
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodNGamma
std::vector< double > * m_eclPureCRLikelihoodNGamma
Connected Region Gamma Likelihood, PureCsI option.
Definition: ECLDataAnalysisModule.h:363
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC3
std::vector< int > * m_eclPureCalDigitToMC3
Index of third MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:335
Belle2::ECLDataAnalysisModule::m_eclPureLMMultip
int m_eclPureLMMultip
Local Maxima multiplicity, PureCsI option.
Definition: ECLDataAnalysisModule.h:367
Belle2::ECLDataAnalysisModule::m_mcMothPdg
std::vector< int > * m_mcMothPdg
MCParticle mother particle PDG code.
Definition: ECLDataAnalysisModule.h:508
Belle2::ECLDataAnalysisModule::m_eclClusterToMC1
std::vector< int > * m_eclClusterToMC1
Index of first MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:268
Belle2::ECLDataAnalysisModule::m_eclShowerToLM4
std::vector< int > * m_eclShowerToLM4
Index of 4th maximum related to ECLShower.
Definition: ECLDataAnalysisModule.h:467
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight2
std::vector< double > * m_eclClusterToMCWeight2
Energy contribution of second MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:272
Belle2::ECLDataAnalysisModule::m_eclLogLikePi
std::vector< double > * m_eclLogLikePi
PID track pion likelyhood.
Definition: ECLDataAnalysisModule.h:545
Belle2::ECLDataAnalysisModule::m_eclClusterE1oE9
std::vector< double > * m_eclClusterE1oE9
Reconstructed E1 over E9.
Definition: ECLDataAnalysisModule.h:308
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitTimeFit
std::vector< double > * m_eclPureCalDigitTimeFit
CalDigit timing, PureCsI option.
Definition: ECLDataAnalysisModule.h:353
Belle2::ECLDataAnalysisModule::eclPureDigitArrayName
virtual const char * eclPureDigitArrayName() const
Default name ECLPureDigits array.
Definition: ECLDataAnalysisModule.h:147
Belle2::ECLDataAnalysisModule::m_eclShowerUncEnergy
std::vector< double > * m_eclShowerUncEnergy
Shower bare energy.
Definition: ECLDataAnalysisModule.h:470
Belle2::ECLDataAnalysisModule::m_eclCalDigitToBkgWeight
std::vector< double > * m_eclCalDigitToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:215
Belle2::ECLDataAnalysisModule::m_eclHitToDigit
std::vector< int > * m_eclHitToDigit
Index of ECLDigit related to ECLHit.
Definition: ECLDataAnalysisModule.h:256
Belle2::ECLDataAnalysisModule::m_eclPureDigits
StoreArray< ECLDigit > m_eclPureDigits
Store array: ECLPureDigit.
Definition: ECLDataAnalysisModule.h:134
Belle2::ECLDataAnalysisModule::m_eclClusterHasNeutralHadronHypothesis
std::vector< int > * m_eclClusterHasNeutralHadronHypothesis
Cluster has neutral hadron hypothesis.
Definition: ECLDataAnalysisModule.h:314
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2Moth
std::vector< int > * m_eclShowerToMC2Moth
Mother index of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:437
Belle2::ECLDataAnalysisModule::m_eclShowerT99
std::vector< double > * m_eclShowerT99
Shower T99.
Definition: ECLDataAnalysisModule.h:478
Belle2::ECLDataAnalysisModule::m_eclShowerToLM1
std::vector< int > * m_eclShowerToLM1
Index of first maximum related to ECLShower.
Definition: ECLDataAnalysisModule.h:464
Belle2::ECLDataAnalysisModule::m_eclLMCellId
std::vector< int > * m_eclLMCellId
Local Maximum Cell ID.
Definition: ECLDataAnalysisModule.h:237
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight3
std::vector< double > * m_eclShowerToMCWeight3
Energy contribution of third MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:442
Belle2::ECLDataAnalysisModule::m_eclHitToDigitAmp
std::vector< int > * m_eclHitToDigitAmp
Amplitude of ECLDigit related to ECLHit.
Definition: ECLDataAnalysisModule.h:257
Belle2::ECLDataAnalysisModule::eclClusterArrayName
virtual const char * eclClusterArrayName() const
Default name ECLClusters array.
Definition: ECLDataAnalysisModule.h:123
Belle2::ECLDataAnalysisModule::m_eclClusterTrueMultip
int m_eclClusterTrueMultip
Number of ECLClusters per event.
Definition: ECLDataAnalysisModule.h:265
Belle2::ECLDataAnalysisModule::m_eclDigitTimeFit
std::vector< int > * m_eclDigitTimeFit
ECLDigit timing.
Definition: ECLDataAnalysisModule.h:193
Belle2::ECLDataAnalysisModule::m_eclPureClusterClosestTrackDist
std::vector< double > * m_eclPureClusterClosestTrackDist
Reconstructed Distance to Closest Track, PureCsI option.
Definition: ECLDataAnalysisModule.h:414
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight4
std::vector< double > * m_eclClusterToMCWeight4
Energy contribution of fourth MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:278
Belle2::ECLDataAnalysisModule::m_eclShowerHighestEnergy
std::vector< double > * m_eclShowerHighestEnergy
Shower Highest Energy Crystal Energy.
Definition: ECLDataAnalysisModule.h:486
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodElectronNGamma
std::vector< double > * m_eclPureCRLikelihoodElectronNGamma
Connected Region Electron Likelihood, PureCsI option.
Definition: ECLDataAnalysisModule.h:362
Belle2::ECLDataAnalysisModule::m_eclClusterToMC2
std::vector< int > * m_eclClusterToMC2
Index of second MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:271
Belle2::ECLDataAnalysisModule::m_eclShowerIdx
std::vector< int > * m_eclShowerIdx
Shower Index.
Definition: ECLDataAnalysisModule.h:426
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitIdx
std::vector< int > * m_eclPureCalDigitIdx
ECLCalDigit index, PureCsI option.
Definition: ECLDataAnalysisModule.h:326
Belle2::ECLDataAnalysisModule::m_eclSimHitToMC
std::vector< int > * m_eclSimHitToMC
Index of MCParticle related to that ECLSimHit.
Definition: ECLDataAnalysisModule.h:241
Belle2::ECLDataAnalysisModule::m_eclClusterToBkgWeight
std::vector< double > * m_eclClusterToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLCluster.
Definition: ECLDataAnalysisModule.h:284
Belle2::ECLDataAnalysisModule::m_eclDigitToCalDigit
std::vector< int > * m_eclDigitToCalDigit
Index of CalDigit related to that ECLDigit.
Definition: ECLDataAnalysisModule.h:195
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3Moth
std::vector< int > * m_eclShowerToMC3Moth
Mother index of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:444
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight2
std::vector< double > * m_eclPureCalDigitToMCWeight2
Energy contribution of second MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:334
Belle2::ECLDataAnalysisModule::m_eclDigitIdx
std::vector< int > * m_eclDigitIdx
ECLDigit index.
Definition: ECLDataAnalysisModule.h:189
Belle2::ECLDataAnalysisModule::m_eclClusterGammaMultip
int m_eclClusterGammaMultip
Number of ECLClusters per event.
Definition: ECLDataAnalysisModule.h:266
Belle2::ECLDataAnalysisModule::m_eclPureClusterE1oE9
std::vector< double > * m_eclPureClusterE1oE9
Reconstructed E1oE9, PureCsI option.
Definition: ECLDataAnalysisModule.h:419
Belle2::ECLDataAnalysisModule::beginRun
virtual void beginRun() override
beginRun
Definition: ECLDataAnalysisModule.cc:860
Belle2::ECLDataAnalysisModule::m_eclShowerThetaError
std::vector< double > * m_eclShowerThetaError
Shower Theta Error.
Definition: ECLDataAnalysisModule.h:483
Belle2::ECLDataAnalysisModule::m_eclShowerSimHitSum
std::vector< double > * m_eclShowerSimHitSum
Full energy contribution related to ECLShower.
Definition: ECLDataAnalysisModule.h:469
Belle2::ECLDataAnalysisModule::m_tracks
StoreArray< Track > m_tracks
Tracks storeArray.
Definition: ECLDataAnalysisModule.h:93
Belle2::ECLDataAnalysisModule::m_eclPureLocalMaximums
StoreArray< ECLLocalMaximum > m_eclPureLocalMaximums
Store array: ECLPureLocalMaximum.
Definition: ECLDataAnalysisModule.h:144
Belle2::ECLDataAnalysisModule::m_eclPureLMCellId
std::vector< int > * m_eclPureLMCellId
Local Maximum Cell ID, PureCsI option.
Definition: ECLDataAnalysisModule.h:370
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC5PDG
std::vector< int > * m_eclCalDigitToMC5PDG
PDG code of fifth MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:212
Belle2::ECLDataAnalysisModule::m_eclShowerIsTrack
std::vector< int > * m_eclShowerIsTrack
Shower Track Match.
Definition: ECLDataAnalysisModule.h:496
Belle2::ECLDataAnalysisModule::m_mcGMothPdg
std::vector< int > * m_mcGMothPdg
MCParticle grandmother particle PDG code.
Definition: ECLDataAnalysisModule.h:509
Belle2::ECLDataAnalysisModule::m_eclpidEnergy
std::vector< double > * m_eclpidEnergy
PID track energy.
Definition: ECLDataAnalysisModule.h:538
Belle2::ECLDataAnalysisModule::m_eclpidNClusters
std::vector< int > * m_eclpidNClusters
PID track number of clusters.
Definition: ECLDataAnalysisModule.h:542
Belle2::ECLDataAnalysisModule::m_eclShowerPhi
std::vector< double > * m_eclShowerPhi
Shower Phi.
Definition: ECLDataAnalysisModule.h:473
Belle2::ECLDataAnalysisModule::m_mcMultip
int m_mcMultip
Multiplicity of MCParticles.
Definition: ECLDataAnalysisModule.h:505
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodMIPNGamma
std::vector< double > * m_eclPureCRLikelihoodMIPNGamma
Connected Region MIP Likelihood, PureCsI option.
Definition: ECLDataAnalysisModule.h:360
Belle2::ECLDataAnalysisModule::m_eclPureClusterE9oE21
std::vector< double > * m_eclPureClusterE9oE21
Ratio of 3x3 over 5x5 crystal matrices energies for Cluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:406
Belle2::ECLDataAnalysisModule::m_eclLMType
std::vector< int > * m_eclLMType
Local Maximum type.
Definition: ECLDataAnalysisModule.h:236
Belle2::ECLDataAnalysisModule::m_eclShowerTrkDepth
std::vector< double > * m_eclShowerTrkDepth
Shower Track Depth.
Definition: ECLDataAnalysisModule.h:489
Belle2::ECLDataAnalysisModule::m_eclLMId
std::vector< int > * m_eclLMId
Local Maximum ID.
Definition: ECLDataAnalysisModule.h:235
Belle2::ECLDataAnalysisModule::m_trkP
std::vector< double > * m_trkP
Track momentum.
Definition: ECLDataAnalysisModule.h:530
Belle2::ECLDataAnalysisModule::m_eclPureClusterEnergy
std::vector< double > * m_eclPureClusterEnergy
Cluster energy, PureCsI option.
Definition: ECLDataAnalysisModule.h:396
Belle2::ECLDataAnalysisModule::m_eclHitToPureDigitAmp
std::vector< int > * m_eclHitToPureDigitAmp
Amplitude of ECLDigit related to ECLHit, PureCsI option.
Definition: ECLDataAnalysisModule.h:259
Belle2::ECLDataAnalysisModule::m_eclClusterTimingError
std::vector< double > * m_eclClusterTimingError
ECLCluster time error.
Definition: ECLDataAnalysisModule.h:296
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4
std::vector< int > * m_eclShowerToMC4
Index of fourth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:448
Belle2::ECLDataAnalysisModule::m_mcProdVtxZ
std::vector< double > * m_mcProdVtxZ
MCParticle production vertex Z.
Definition: ECLDataAnalysisModule.h:520
Belle2::ECLDataAnalysisModule::m_mcEnergy
std::vector< double > * m_mcEnergy
MCParticle energyx.
Definition: ECLDataAnalysisModule.h:511
Belle2::ECLDataAnalysisModule::m_eclpidtrkIdx
std::vector< int > * m_eclpidtrkIdx
PID track index.
Definition: ECLDataAnalysisModule.h:537
Belle2::ECLDataAnalysisModule::m_eclShowerCentralCellId
std::vector< int > * m_eclShowerCentralCellId
Cell ID for most energetic crystal.
Definition: ECLDataAnalysisModule.h:481
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight1
std::vector< double > * m_eclShowerToMCWeight1
Energy contribution of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:428
Belle2::ECLDataAnalysisModule::m_eclClusters
StoreArray< ECLCluster > m_eclClusters
Store array: ECLCluster.
Definition: ECLDataAnalysisModule.h:102
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC3
std::vector< int > * m_eclCalDigitToMC3
Index of third MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:205
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC4PDG
std::vector< int > * m_eclPureCalDigitToMC4PDG
PDG code of fourth MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:340
Belle2::ECLDataAnalysisModule::m_eclHitIdx
std::vector< int > * m_eclHitIdx
Index of ECLHits.
Definition: ECLDataAnalysisModule.h:254
Belle2::ECLDataAnalysisModule::m_eclClusterToMC1PDG
std::vector< int > * m_eclClusterToMC1PDG
PDG code of first MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:270
Belle2::ECLDataAnalysisModule::m_eclPureClusterDetectorRegion
std::vector< int > * m_eclPureClusterDetectorRegion
Clusters detector region, PureCsI option.
Definition: ECLDataAnalysisModule.h:421
Belle2::ECLDataAnalysisModule::m_mcDecayVtxX
std::vector< double > * m_mcDecayVtxX
MCParticle decay vertex X.
Definition: ECLDataAnalysisModule.h:515
Belle2::ECLDataAnalysisModule::m_trkY
std::vector< double > * m_trkY
Track DOCA Y (?)
Definition: ECLDataAnalysisModule.h:534
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5Moth
std::vector< int > * m_eclShowerToMC5Moth
Mother index of fifth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:458
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitAmp
std::vector< double > * m_eclPureCalDigitAmp
CalDigit amplitude, PureCsI option.
Definition: ECLDataAnalysisModule.h:352
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToLM
std::vector< int > * m_eclPureCalDigitToLM
Index of LM related to that CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:356
Belle2::ECLDataAnalysisModule::m_eclCalDigitIdx
std::vector< int > * m_eclCalDigitIdx
ECLCalDigit index.
Definition: ECLDataAnalysisModule.h:198
Belle2::ECLDataAnalysisModule::m_eclSimHitIdx
std::vector< int > * m_eclSimHitIdx
Index of ECLSimHit.
Definition: ECLDataAnalysisModule.h:240
Belle2::ECLDataAnalysisModule::m_eclClusterToMC2PDG
std::vector< int > * m_eclClusterToMC2PDG
PDG code of second MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:273
Belle2::ECLDataAnalysisModule::m_eclPureConnectedRegions
StoreArray< ECLConnectedRegion > m_eclPureConnectedRegions
Store array: ECLPureConnectedRegion.
Definition: ECLDataAnalysisModule.h:138
Belle2::ECLDataAnalysisModule::m_eclPureDigitCellId
std::vector< int > * m_eclPureDigitCellId
Number of ECLDigit CellId, PureCsI option.
Definition: ECLDataAnalysisModule.h:319
Belle2::ECLDataAnalysisModule::m_eclDigitFitQuality
std::vector< int > * m_eclDigitFitQuality
ECLDigit fit quality.
Definition: ECLDataAnalysisModule.h:194
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitMultip
int m_eclPureCalDigitMultip
Number of ECLCalDigits per event, PureCsI option.
Definition: ECLDataAnalysisModule.h:325
Belle2::ECLDataAnalysisModule::m_eclPureClusterLat
std::vector< double > * m_eclPureClusterLat
Cluster shape parameter LAT, PureCsI option.
Definition: ECLDataAnalysisModule.h:409
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC4PDG
std::vector< int > * m_eclPureClusterToMC4PDG
PDG code of fourth MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:389
Belle2::ECLDataAnalysisModule::m_eclShowerMCFFlightMatch
std::vector< int > * m_eclShowerMCFFlightMatch
Int, 1 if primary particle flight direction is "well" reconstructed in ECL, 0 otherwise,...
Definition: ECLDataAnalysisModule.h:501
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC1PDG
std::vector< int > * m_eclCalDigitToMC1PDG
PDG code of first MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:200
Belle2::ECLDataAnalysisModule::m_eclCalDigitAmp
std::vector< double > * m_eclCalDigitAmp
ECLCalDigit amplitude.
Definition: ECLDataAnalysisModule.h:219
Belle2::ECLDataAnalysisModule::m_mcPx
std::vector< double > * m_mcPx
MCParticle momentum X direction.
Definition: ECLDataAnalysisModule.h:512
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2MothPDG
std::vector< int > * m_eclShowerToMC2MothPDG
PDG code of parent of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:438
Belle2::ECLDataAnalysisModule::m_eclpidNCrystals
std::vector< int > * m_eclpidNCrystals
PID track number of crystals.
Definition: ECLDataAnalysisModule.h:541
Belle2::ECLDataAnalysisModule::m_mcIdx
std::vector< int > * m_mcIdx
MCParticle index.
Definition: ECLDataAnalysisModule.h:506
Belle2::ECLDataAnalysisModule::m_eclPureShowers
StoreArray< ECLShower > m_eclPureShowers
Store array: ECLPureShower.
Definition: ECLDataAnalysisModule.h:140
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC1PDG
std::vector< int > * m_eclPureClusterToMC1PDG
PDG code of first MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:377
Belle2::ECLDataAnalysisModule::m_eclShowerZernikeMVA
std::vector< double > * m_eclShowerZernikeMVA
Shower ZernikeMVA.
Definition: ECLDataAnalysisModule.h:493
Belle2::ECLDataAnalysisModule::m_eclPureClusterAbsZernike40
std::vector< double > * m_eclPureClusterAbsZernike40
Reconstructed Zernike40, PureCsI option.
Definition: ECLDataAnalysisModule.h:415
Belle2::ECLDataAnalysisModule::m_eclPureClusterSecondMoment
std::vector< double > * m_eclPureClusterSecondMoment
Reconstructed Cluster Second Moment, PureCsI option.
Definition: ECLDataAnalysisModule.h:418
Belle2::ECLDataAnalysisModule::m_eclPureDigitMultip
int m_eclPureDigitMultip
Number of ECLDigits per event, PureCsI option.
Definition: ECLDataAnalysisModule.h:316
Belle2::ECLDataAnalysisModule::m_nECLShowersRejectedBarrel
uint8_t m_nECLShowersRejectedBarrel
Number of photon showers that are rejected before storing to mdst (max.
Definition: ECLDataAnalysisModule.h:184
Belle2::ECLDataAnalysisModule::eclPureShowerArrayName
virtual const char * eclPureShowerArrayName() const
Default name ECLPureShower array.
Definition: ECLDataAnalysisModule.h:153
Belle2::ECLDataAnalysisModule::m_eclClusterTiming
std::vector< double > * m_eclClusterTiming
ECLCluster time.
Definition: ECLDataAnalysisModule.h:295
Belle2::ECLDataAnalysisModule::m_eclCalDigitCellId
std::vector< int > * m_eclCalDigitCellId
Number of ECLCalDigit CellId.
Definition: ECLDataAnalysisModule.h:218
Belle2::ECLDataAnalysisModule::m_mcProdVtxX
std::vector< double > * m_mcProdVtxX
MCParticle production vertex X.
Definition: ECLDataAnalysisModule.h:518
Belle2::ECLDataAnalysisModule::m_eclShowerEnergy
std::vector< double > * m_eclShowerEnergy
Shower Energy.
Definition: ECLDataAnalysisModule.h:471
Belle2::ECLDataAnalysisModule::m_eclHits
StoreArray< ECLHit > m_eclHits
Store array: ECLHit.
Definition: ECLDataAnalysisModule.h:97
Belle2::ECLDataAnalysisModule::m_eclPureCRIdx
std::vector< int > * m_eclPureCRIdx
Connected Region ID, PureCsI option.
Definition: ECLDataAnalysisModule.h:358
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodMergedPi0
std::vector< double > * m_eclCRLikelihoodMergedPi0
Connected Region Merged Pi0 Likelihood.
Definition: ECLDataAnalysisModule.h:232
Belle2::ECLDataAnalysisModule::m_nECLShowersRejectedFWD
uint8_t m_nECLShowersRejectedFWD
Number of photon showers that are rejected before storing to mdst (max.
Definition: ECLDataAnalysisModule.h:182
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5MothPDG
std::vector< int > * m_eclShowerToMC5MothPDG
PDG code of parent of fifth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:459
Belle2::ECLDataAnalysisModule::eclHitArrayName
virtual const char * eclHitArrayName() const
Default name ECLCalDigits array.
Definition: ECLDataAnalysisModule.h:111
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight2
std::vector< double > * m_eclPureClusterToMCWeight2
Energy contribution of second MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:380
Belle2::ECLDataAnalysisModule::m_trkX
std::vector< double > * m_trkX
Track DOCA X (?)
Definition: ECLDataAnalysisModule.h:533
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight3
std::vector< double > * m_eclPureClusterToMCWeight3
Energy contribution of third MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:384
Belle2::ECLDataAnalysisModule::m_eclClusterMultip
int m_eclClusterMultip
Number of ECLClusters per event.
Definition: ECLDataAnalysisModule.h:264
Belle2::ECLDataAnalysisModule::m_eclShowerLateralEnergy
std::vector< double > * m_eclShowerLateralEnergy
Shower Lateral Energy.
Definition: ECLDataAnalysisModule.h:487
Belle2::ECLDataAnalysisModule::m_mcPz
std::vector< double > * m_mcPz
MCParticle momentum Z direction.
Definition: ECLDataAnalysisModule.h:514
Belle2::ECLDataAnalysisModule::m_eclPureClusterHasNeutralHadronHypothesis
std::vector< int > * m_eclPureClusterHasNeutralHadronHypothesis
Cluster has neutral hadron hypothesis, PureCsI option.
Definition: ECLDataAnalysisModule.h:423
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitSimHitSum
std::vector< double > * m_eclPureCalDigitSimHitSum
Full energy contribution related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:349
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC5
std::vector< int > * m_eclCalDigitToMC5
Index of fifth MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:211
Belle2::ECLDataAnalysisModule::m_mcParticles
StoreArray< MCParticle > m_mcParticles
MCParticles StoreArray.
Definition: ECLDataAnalysisModule.h:165
Belle2::ECLDataAnalysisModule::m_eclClusterHighestE
std::vector< double > * m_eclClusterHighestE
Highest energy deposit (per crystal) in ECLCluster.
Definition: ECLDataAnalysisModule.h:298
Belle2::ECLDataAnalysisModule::m_eclPureDigitAmp
std::vector< int > * m_eclPureDigitAmp
ECLDigit amplitude, PureCsI option.
Definition: ECLDataAnalysisModule.h:320
Belle2::ECLDataAnalysisModule::m_eventmetadata
StoreObjPtr< EventMetaData > m_eventmetadata
Store object pointer: EventMetaData.
Definition: ECLDataAnalysisModule.h:105
Belle2::ECLDataAnalysisModule::~ECLDataAnalysisModule
virtual ~ECLDataAnalysisModule()
Destructor of the module.
Definition: ECLDataAnalysisModule.cc:435
Belle2::ECLDataAnalysisModule::m_eclCRIsTrack
std::vector< int > * m_eclCRIsTrack
Int for Connected Region - Track Match.
Definition: ECLDataAnalysisModule.h:226
Belle2::ECLDataAnalysisModule::m_eclShowerConnectedRegionId
std::vector< int > * m_eclShowerConnectedRegionId
Matched Connetcted Region Idx.
Definition: ECLDataAnalysisModule.h:479
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight4
std::vector< double > * m_eclPureClusterToMCWeight4
Energy contribution of fourth MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:388
Belle2::ECLDataAnalysisModule::m_eclPureClusterPhiError
std::vector< double > * m_eclPureClusterPhiError
Cluster error on azimuthal direction, PureCsI option.
Definition: ECLDataAnalysisModule.h:401
Belle2::ECLDataAnalysisModule::m_doTracking
bool m_doTracking
if true, info on tracking will be stored, job will fail if doTracking==1 and the tracking modules are...
Definition: ECLDataAnalysisModule.h:87
Belle2::ECLDataAnalysisModule::m_eclShowerAbsZernike51
std::vector< double > * m_eclShowerAbsZernike51
Shower Zernike51 Moment.
Definition: ECLDataAnalysisModule.h:492
Belle2::ECLDataAnalysisModule::m_eclShowerR
std::vector< double > * m_eclShowerR
Shower R.
Definition: ECLDataAnalysisModule.h:474
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC1
std::vector< int > * m_eclPureClusterToMC1
Index of first MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:374
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight5
std::vector< double > * m_eclShowerToMCWeight5
Energy contribution of fifth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:456
Belle2::ECLDataAnalysisModule::m_eclHitTimeAve
std::vector< double > * m_eclHitTimeAve
ECLHit time.
Definition: ECLDataAnalysisModule.h:262
Belle2::ECLDataAnalysisModule::m_eclPureClusters
StoreArray< ECLCluster > m_eclPureClusters
Store array: ECLPureCluster.
Definition: ECLDataAnalysisModule.h:142
Belle2::ECLDataAnalysisModule::m_eclLMMultip
int m_eclLMMultip
Local Maxima multiplicity.
Definition: ECLDataAnalysisModule.h:234
Belle2::ECLDataAnalysisModule::m_eclSimHitPdg
std::vector< int > * m_eclSimHitPdg
PDG code of MCParticle associted to that ECLDigit.
Definition: ECLDataAnalysisModule.h:243
Belle2::ECLDataAnalysisModule::m_trkPhi
std::vector< double > * m_trkPhi
Track azimuthal direction.
Definition: ECLDataAnalysisModule.h:532
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC3PDG
std::vector< int > * m_eclCalDigitToMC3PDG
PDG code of third MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:206
Belle2::ECLDataAnalysisModule::m_eclDigitCellId
std::vector< int > * m_eclDigitCellId
Number of ECLDigit CellId.
Definition: ECLDataAnalysisModule.h:191
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight1
std::vector< double > * m_eclPureCalDigitToMCWeight1
Energy contribution of first MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:330
Belle2::ECLDataAnalysisModule::m_eclPureClusterR
std::vector< double > * m_eclPureClusterR
Cluster distance from IP, PureCsI option.
Definition: ECLDataAnalysisModule.h:402
Belle2::ECLDataAnalysisModule::m_eclPureClusterTheta
std::vector< double > * m_eclPureClusterTheta
Cluster polar direction, PureCsI option.
Definition: ECLDataAnalysisModule.h:398
Belle2::ECLDataAnalysisModule::m_trkTheta
std::vector< double > * m_trkTheta
Track polar direction.
Definition: ECLDataAnalysisModule.h:531
Belle2::ECLDataAnalysisModule::m_nECLCalDigitsOutOfTimeBarrel
uint16_t m_nECLCalDigitsOutOfTimeBarrel
Number of out of time, energetic ECLCalDigits, Barrel.
Definition: ECLDataAnalysisModule.h:178
Belle2::ECLDataAnalysisModule::m_eclLogLikeMu
std::vector< double > * m_eclLogLikeMu
PID track muon likelyhood.
Definition: ECLDataAnalysisModule.h:544
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC4PDG
std::vector< int > * m_eclCalDigitToMC4PDG
PDG code of fourth MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:209
Belle2::ECLDataAnalysisModule::eclPureConnectedRegionArrayName
virtual const char * eclPureConnectedRegionArrayName() const
Default name ECLPureConnectedRegions array.
Definition: ECLDataAnalysisModule.h:159
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC4
std::vector< int > * m_eclPureClusterToMC4
Index of fourth MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:386
Belle2::ECLDataAnalysisModule::eclCalDigitArrayName
virtual const char * eclCalDigitArrayName() const
Default name ECLCalDigits array.
Definition: ECLDataAnalysisModule.h:117
Belle2::ECLDataAnalysisModule::m_eclPureClusterIdx
std::vector< int > * m_eclPureClusterIdx
ECLCluster index, PureCsI option.
Definition: ECLDataAnalysisModule.h:373
Belle2::ECLDataAnalysisModule::m_eclClusterEnergy
std::vector< double > * m_eclClusterEnergy
ECLCluster energy.
Definition: ECLDataAnalysisModule.h:287
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1
std::vector< int > * m_eclShowerToMC1
Index of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:427
Belle2::ECLDataAnalysisModule::m_eclSimHitPy
std::vector< double > * m_eclSimHitPy
ECLSimHit PY.
Definition: ECLDataAnalysisModule.h:250
Belle2::ECLDataAnalysisModule::m_eclCalDigitToLM
std::vector< int > * m_eclCalDigitToLM
Index of LM related to that ECLCalDigit.
Definition: ECLDataAnalysisModule.h:223
Belle2::ECLDataAnalysisModule::m_eclClusterClosestTrackDist
std::vector< double > * m_eclClusterClosestTrackDist
Flag for charged clusters.
Definition: ECLDataAnalysisModule.h:303
Belle2::ECLDataAnalysisModule::m_eclSimHitY
std::vector< double > * m_eclSimHitY
ECLSimHit Y position.
Definition: ECLDataAnalysisModule.h:247
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodChargedHadron
std::vector< double > * m_eclPureCRLikelihoodChargedHadron
Connected Region Charged Hadron Likelihood, PureCsI option.
Definition: ECLDataAnalysisModule.h:361
Belle2::ECLDataAnalysisModule::m_eclSimHitMultip
int m_eclSimHitMultip
Number of ECLSimHits per event.
Definition: ECLDataAnalysisModule.h:239
Belle2::ECLDataAnalysisModule::m_rootFilePtr
TFile * m_rootFilePtr
members of ECLReconstructor Module
Definition: ECLDataAnalysisModule.h:84
Belle2::ECLDataAnalysisModule::m_eclClusterLAT
std::vector< double > * m_eclClusterLAT
Reconstructed LAT.
Definition: ECLDataAnalysisModule.h:310
Belle2::ECLDataAnalysisModule::m_eclShowerHighestE1mE2
std::vector< double > * m_eclShowerHighestE1mE2
Energy difference for 2 highest energy deposits in shower.
Definition: ECLDataAnalysisModule.h:502
Belle2::ECLDataAnalysisModule::m_eclClusterDeltaTime99
std::vector< double > * m_eclClusterDeltaTime99
DeltaTime99.
Definition: ECLDataAnalysisModule.h:311
Belle2::ECLDataAnalysisModule::m_eclHitCellId
std::vector< int > * m_eclHitCellId
ECLHit CellID.
Definition: ECLDataAnalysisModule.h:260
Belle2::ECLDataAnalysisModule::m_eventLevelClusteringInfo
StoreObjPtr< EventLevelClusteringInfo > m_eventLevelClusteringInfo
Store object pointer: EventLevelClusteringInfo.
Definition: ECLDataAnalysisModule.h:104
Belle2::ECLDataAnalysisModule::m_mcSecondaryPhysProc
std::vector< int > * m_mcSecondaryPhysProc
Flag for secondary physics process.
Definition: ECLDataAnalysisModule.h:521
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1Moth
std::vector< int > * m_eclShowerToMC1Moth
Mother index of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:430
Belle2::ECLDataAnalysisModule::m_eclShowerE1oE9
std::vector< double > * m_eclShowerE1oE9
Shower E1/E9.
Definition: ECLDataAnalysisModule.h:495
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3
std::vector< int > * m_eclShowerToMC3
Index of third MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:441
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1GMothPDG
std::vector< int > * m_eclShowerToMC1GMothPDG
PDG code of Gparent of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:433
Belle2::ECLDataAnalysisModule::m_mcProdVtxY
std::vector< double > * m_mcProdVtxY
MCParticle production vertex Y.
Definition: ECLDataAnalysisModule.h:519
Belle2::ECLDataAnalysisModule::m_eclClusterSecondMoment
std::vector< double > * m_eclClusterSecondMoment
Reconstructed Second Moment.
Definition: ECLDataAnalysisModule.h:309
Belle2::ECLDataAnalysisModule::m_eclPureClusterEnergyError
std::vector< double > * m_eclPureClusterEnergyError
Cluster energy error, PureCsI option.
Definition: ECLDataAnalysisModule.h:397
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2GMoth
std::vector< int > * m_eclShowerToMC2GMoth
GMother index of second MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:439
Belle2::ECLDataAnalysisModule::m_eclClusterE9oE21
std::vector< double > * m_eclClusterE9oE21
Ratio of 3x3 over 5x5 crystal matrices energies for ECLCluster.
Definition: ECLDataAnalysisModule.h:297
Belle2::ECLDataAnalysisModule::m_eclPureLMId
std::vector< int > * m_eclPureLMId
Local Maximum ID, PureCsI option.
Definition: ECLDataAnalysisModule.h:368
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4PDG
std::vector< int > * m_eclShowerToMC4PDG
PDG code of fourth MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:450
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC1
std::vector< int > * m_eclCalDigitToMC1
Index of first MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:199
Belle2::ECLDataAnalysisModule::m_eclPureClusterPhi
std::vector< double > * m_eclPureClusterPhi
Cluster azimuthal direction, PureCsI option.
Definition: ECLDataAnalysisModule.h:400
Belle2::ECLDataAnalysisModule::m_eclClusterCrystalHealth
std::vector< int > * m_eclClusterCrystalHealth
Crystal healt flag.
Definition: ECLDataAnalysisModule.h:301
Belle2::ECLDataAnalysisModule::m_eclClusterIsTrack
std::vector< bool > * m_eclClusterIsTrack
Flag for charged clusters.
Definition: ECLDataAnalysisModule.h:302
Belle2::ECLDataAnalysisModule::m_eclClusterToShower
std::vector< int > * m_eclClusterToShower
Index of ECLShower related to ECLCluster.
Definition: ECLDataAnalysisModule.h:286
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight3
std::vector< double > * m_eclCalDigitToMCWeight3
Energy contribution of third MCParticle related to ECLCalDigit.
Definition: ECLDataAnalysisModule.h:207
Belle2::ECLDataAnalysisModule::m_eclCalDigits
StoreArray< ECLCalDigit > m_eclCalDigits
Store array: ECLCalDigit.
Definition: ECLDataAnalysisModule.h:99
Belle2::ECLDataAnalysisModule::m_eclpidE9E21
std::vector< double > * m_eclpidE9E21
PID track ration of 3x3 over 5x5 crystal matrices energies.
Definition: ECLDataAnalysisModule.h:540
Belle2::ECLDataAnalysisModule::m_eclPureCRIsTrack
std::vector< int > * m_eclPureCRIsTrack
Int for Connected Region - Track Match, PureCsI option.
Definition: ECLDataAnalysisModule.h:359
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodNGamma
std::vector< double > * m_eclCRLikelihoodNGamma
Connected Region Gamma Likelihood.
Definition: ECLDataAnalysisModule.h:230
Belle2::ECLDataAnalysisModule::m_eclPureDigitTimeFit
std::vector< int > * m_eclPureDigitTimeFit
ECLDigit timing, PureCsI option.
Definition: ECLDataAnalysisModule.h:321
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC5
std::vector< int > * m_eclPureCalDigitToMC5
Index of fifth MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:343
Belle2::ECLDataAnalysisModule::m_trkPdg
std::vector< int > * m_trkPdg
Track PDG code.
Definition: ECLDataAnalysisModule.h:524
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight3
std::vector< double > * m_eclPureCalDigitToMCWeight3
Energy contribution of third MCParticle related to CalDigit, PureCsI option.
Definition: ECLDataAnalysisModule.h:338
Belle2::ECLDataAnalysisModule::m_eclClusterDeltaL
std::vector< double > * m_eclClusterDeltaL
Reconstructed Cluster DeltaL.
Definition: ECLDataAnalysisModule.h:304
Belle2::ECLDataAnalysisModule::m_mcGGMothPdg
std::vector< int > * m_mcGGMothPdg
MCParticle greand-grandmother particle PDG code.
Definition: ECLDataAnalysisModule.h:510
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1MothPDG
std::vector< int > * m_eclShowerToMC1MothPDG
PDG code of parent of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:431
Belle2::ECLDataAnalysisModule::m_nECLCalDigitsOutOfTimeBWD
uint16_t m_nECLCalDigitsOutOfTimeBWD
Number of out of time, energetic ECLCalDigits, BWD.
Definition: ECLDataAnalysisModule.h:180
Belle2::ECLDataAnalysisModule::m_eclPidLikelihoods
StoreArray< ECLPidLikelihood > m_eclPidLikelihoods
ECLPidLikelihood storeArray.
Definition: ECLDataAnalysisModule.h:95
Belle2::ECLDataAnalysisModule::eclSimHitArrayName
virtual const char * eclSimHitArrayName() const
Default name ECLCalDigits array.
Definition: ECLDataAnalysisModule.h:108
Belle2::ECLDataAnalysisModule::m_eclPureClusterCrystalHealth
std::vector< int > * m_eclPureClusterCrystalHealth
Crystal healt flag, PureCsI option.
Definition: ECLDataAnalysisModule.h:411
Belle2::ECLDataAnalysisModule::eclConnectedRegionArrayName
virtual const char * eclConnectedRegionArrayName() const
Default name ECLConnectedRegions array.
Definition: ECLDataAnalysisModule.h:126
Belle2::ECLDataAnalysisModule::m_eclShowerPhiError
std::vector< double > * m_eclShowerPhiError
Shower Phi Error.
Definition: ECLDataAnalysisModule.h:484
Belle2::ECLDataAnalysisModule::eclPureLocalMaximumArrayName
virtual const char * eclPureLocalMaximumArrayName() const
Default name ECLPureLocalMaxima array.
Definition: ECLDataAnalysisModule.h:162
Belle2::ECLDataAnalysisModule::m_eclpidEop
std::vector< double > * m_eclpidEop
PID track E/p.
Definition: ECLDataAnalysisModule.h:539
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1GMoth
std::vector< int > * m_eclShowerToMC1GMoth
GMother index of first MCParticle related to ECLShower.
Definition: ECLDataAnalysisModule.h:432
Belle2::ECLDataAnalysisModule::m_eclShowerAbsZernike40
std::vector< double > * m_eclShowerAbsZernike40
Shower Zernike40 Moment.
Definition: ECLDataAnalysisModule.h:491
Belle2::ECLDataAnalysisModule::eclLocalMaximumArrayName
virtual const char * eclLocalMaximumArrayName() const
Default name ECLLocalMaxima array.
Definition: ECLDataAnalysisModule.h:129
Belle2::ECLDataAnalysisModule::m_eclShowerNHits
std::vector< double > * m_eclShowerNHits
Shower NHits.
Definition: ECLDataAnalysisModule.h:475
Belle2::ECLDataAnalysisModule::m_eclShowerMultip
int m_eclShowerMultip
Number of ECLShowers per event.
Definition: ECLDataAnalysisModule.h:425
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight3
std::vector< double > * m_eclClusterToMCWeight3
Energy contribution of third MCParticle related to ECLCluster.
Definition: ECLDataAnalysisModule.h:275
Belle2::ECLDigit
Class to store ECL digitized hits (output of ECLDigi) relation to ECLHit filled in ecl/modules/eclDig...
Definition: ECLDigit.h:24
Belle2::ECLDigit::getAmp
int getAmp() const
Get Fitting Amplitude.
Definition: ECLDigit.h:70
Belle2::ECLDigit::getQuality
int getQuality() const
Get Fitting Quality.
Definition: ECLDigit.h:80
Belle2::ECLDigit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLDigit.h:64
Belle2::ECLDigit::getTimeFit
int getTimeFit() const
Get Fitting Time.
Definition: ECLDigit.h:75
Belle2::ECLHit
Class to store simulated hits which equate to average of ECLSImHit on crystals input for digitization...
Definition: ECLHit.h:25
Belle2::ECLHit::getTimeAve
double getTimeAve() const
Get average time.
Definition: ECLHit.h:75
Belle2::ECLHit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLHit.h:65
Belle2::ECLHit::getEnergyDep
double getEnergyDep() const
Get deposit energy.
Definition: ECLHit.h:70
Belle2::ECLLocalMaximum
Class to store local maxima (LM)
Definition: ECLLocalMaximum.h:22
Belle2::ECLLocalMaximum::getCellId
int getCellId() const
Get CellId.
Definition: ECLLocalMaximum.h:70
Belle2::ECLLocalMaximum::getLMId
int getLMId() const
Get LM identifier.
Definition: ECLLocalMaximum.h:60
Belle2::ECLLocalMaximum::getType
int getType() const
Get type.
Definition: ECLLocalMaximum.h:65
Belle2::ECLPidLikelihood
Container for likelihoods with ECL PID (ECLChargedPIDModule)
Definition: ECLPidLikelihood.h:22
Belle2::ECLShower
Class to store ECL Showers.
Definition: ECLShower.h:30
Belle2::ECLShower::getAbsZernikeMoment
double getAbsZernikeMoment(unsigned int n, unsigned int m) const
Get absolute value of Zernike Moment nm.
Definition: ECLShower.h:377
Belle2::ECLShower::getHypothesisId
int getHypothesisId() const
Get Hypothesis Id.
Definition: ECLShower.h:277
Belle2::ECLShower::getPhi
double getPhi() const
Get Phi.
Definition: ECLShower.h:302
Belle2::ECLShower::getLateralEnergy
double getLateralEnergy() const
Get Lateral Energy in Shower.
Definition: ECLShower.h:352
Belle2::ECLShower::getE1oE9
double getE1oE9() const
Get energy ratio E1oE9.
Definition: ECLShower.h:392
Belle2::ECLShower::getEnergy
double getEnergy() const
Get Energy.
Definition: ECLShower.h:287
Belle2::ECLShower::getShowerDepth
double getShowerDepth() const
path on track extrapolation to POCA to average cluster direction
Definition: ECLShower.h:367
Belle2::ECLShower::getConnectedRegionId
int getConnectedRegionId() const
Get Connected region Id.
Definition: ECLShower.h:272
Belle2::ECLShower::getR
double getR() const
Get R.
Definition: ECLShower.h:307
Belle2::ECLShower::getEnergyRaw
double getEnergyRaw() const
Get Energy Sum.
Definition: ECLShower.h:292
Belle2::ECLShower::getUncertaintyTheta
double getUncertaintyTheta() const
Get Error of theta.
Definition: ECLShower.h:327
Belle2::ECLShower::getE9oE21
double getE9oE21() const
Get energy ratio E9oE21.
Definition: ECLShower.h:397
Belle2::ECLShower::getNumberOfCrystalsForEnergy
double getNumberOfCrystalsForEnergy() const
Get number of crystals used for energy calculation.
Definition: ECLShower.h:417
Belle2::ECLShower::getUncertaintyEnergy
double getUncertaintyEnergy() const
Get Error of Energy.
Definition: ECLShower.h:322
Belle2::ECLShower::getTrkDepth
double getTrkDepth() const
path on track extrapolation to POCA to average cluster direction
Definition: ECLShower.h:362
Belle2::ECLShower::getMinTrkDistance
double getMinTrkDistance() const
Get distance to closest Track.
Definition: ECLShower.h:357
Belle2::ECLShower::getNumberOfCrystals
double getNumberOfCrystals() const
Get NofCrystals.
Definition: ECLShower.h:372
Belle2::ECLShower::getEnergyHighestCrystal
double getEnergyHighestCrystal() const
Get Highest Energy in Shower.
Definition: ECLShower.h:347
Belle2::ECLShower::getZernikeMVA
double getZernikeMVA() const
Get Zernike MVA.
Definition: ECLShower.h:382
Belle2::ECLShower::getIsTrack
bool getIsTrack() const
Get if matched with a Track.
Definition: ECLShower.h:257
Belle2::ECLShower::getUncertaintyPhi
double getUncertaintyPhi() const
Get Error of phi.
Definition: ECLShower.h:332
Belle2::ECLShower::getCentralCellId
int getCentralCellId() const
Get central cell Id.
Definition: ECLShower.h:282
Belle2::ECLShower::getSecondMoment
double getSecondMoment() const
Get second moment.
Definition: ECLShower.h:387
Belle2::ECLShower::getTheta
double getTheta() const
Get Theta.
Definition: ECLShower.h:297
Belle2::ECLShower::getDeltaTime99
double getDeltaTime99() const
Get Time Resolution.
Definition: ECLShower.h:342
Belle2::ECLShower::getTime
double getTime() const
Get Time.
Definition: ECLShower.h:337
Belle2::ECLSimHit
ClassECLSimHit - Geant4 simulated hit for the ECL.
Definition: ECLSimHit.h:29
Belle2::ECLSimHit::getPDGCode
int getPDGCode() const
Get Particle PDG (can be one of secondaries)
Definition: ECLSimHit.h:96
Belle2::ECLSimHit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLSimHit.h:86
Belle2::ECLSimHit::getFlightTime
double getFlightTime() const
Get Flight time from IP.
Definition: ECLSimHit.h:101
Belle2::ECLSimHit::getEnergyDep
double getEnergyDep() const
Get Deposit energy.
Definition: ECLSimHit.h:106
Belle2::ECLSimHit::getPosition
G4ThreeVector getPosition() const
Get Position.
Definition: ECLSimHit.h:126
Belle2::ECLSimHit::getMomentum
G4ThreeVector getMomentum() const
Get Momentum.
Definition: ECLSimHit.h:116
Belle2::MCParticle
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:32
Belle2::MCParticle::getEnergy
float getEnergy() const
Return particle energy in GeV.
Definition: MCParticle.h:147
Belle2::MCParticle::getIndex
int getIndex() const
Get 1-based index of the particle in the corresponding MCParticle list.
Definition: MCParticle.h:230
Belle2::MCParticle::getDecayVertex
ROOT::Math::XYZVector getDecayVertex() const
Return decay vertex.
Definition: MCParticle.h:219
Belle2::MCParticle::getArrayIndex
int getArrayIndex() const
Get 0-based index of the particle in the corresponding MCParticle list.
Definition: MCParticle.h:244
Belle2::MCParticle::getProductionVertex
ROOT::Math::XYZVector getProductionVertex() const
Return production vertex position.
Definition: MCParticle.h:189
Belle2::MCParticle::getPDG
int getPDG() const
Return PDG code of particle.
Definition: MCParticle.h:112
Belle2::MCParticle::getMomentum
ROOT::Math::XYZVector getMomentum() const
Return momentum.
Definition: MCParticle.h:198
Belle2::MCParticle::getSecondaryPhysicsProcess
int getSecondaryPhysicsProcess() const
Returns the physics process type of a secondary particle.
Definition: MCParticle.h:297
Belle2::Module
Base class for Modules.
Definition: Module.h:72
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
Belle2::RelationsInterface::getArrayIndex
int getArrayIndex() const
Returns this object's array index (in StoreArray), or -1 if not found.
Definition: RelationsObject.h:385
Belle2::RelationsInterface::getRelationsTo
RelationVector< TO > getRelationsTo(const std::string &name="", const std::string &namedRelation="") const
Get the relations that point from this object to another store array.
Definition: RelationsObject.h:197
Belle2::RelationsInterface::getRelated
T * getRelated(const std::string &name="", const std::string &namedRelation="") const
Get the object to or from which this object has a relation.
Definition: RelationsObject.h:278
Belle2::RelationsInterface::getRelatedTo
TO * getRelatedTo(const std::string &name="", const std::string &namedRelation="") const
Get the object to which this object has a relation.
Definition: RelationsObject.h:248
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
Belle2::TrackFitResult
Values of the result of a track fit with a given particle hypothesis.
Definition: TrackFitResult.h:49
Belle2::TrackFitResult::getChargeSign
short getChargeSign() const
Return track charge (1 or -1).
Definition: TrackFitResult.h:161
Belle2::TrackFitResult::getParticleType
Const::ParticleType getParticleType() const
Getter for ParticleType of the mass hypothesis of the track fit.
Definition: TrackFitResult.h:155
Belle2::TrackFitResult::getMomentum
ROOT::Math::XYZVector getMomentum() const
Getter for vector of momentum at closest approach of track in r/phi projection.
Definition: TrackFitResult.h:116
Belle2::TrackFitResult::getPosition
ROOT::Math::XYZVector getPosition() const
Getter for vector of position at closest approach of track in r/phi projection.
Definition: TrackFitResult.h:109
Belle2::Track
Class that bundles various TrackFitResults.
Definition: Track.h:25
Belle2::ECLCalDigit::isFailedFit
bool isFailedFit() const
Get Boolean Fit Failed Status.
Definition: ECLCalDigit.h:250
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:560
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:650
Belle2::MCParticle::getMother
MCParticle * getMother() const
Returns a pointer to the mother particle.
Definition: MCParticle.h:600
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17