Belle II Software development
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
37using namespace std;
38using namespace Belle2;
39
40//-----------------------------------------------------------------
41// Register the Module
42//-----------------------------------------------------------------
43
44REG_MODULE(ECLDataAnalysis);
45
46//-----------------------------------------------------------------
47// Implementation
48//-----------------------------------------------------------------
49
50ECLDataAnalysisModule::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 information 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 information 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 information for upgrade option'", bool(false));
432
433}
434
435ECLDataAnalysisModule::~ECLDataAnalysisModule()
436{
437}
438
439
440void 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
860void ECLDataAnalysisModule::beginRun()
861{
862}
863
864
865void 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
2384void ECLDataAnalysisModule::endRun()
2385{
2386}
2387
2388void 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:473
Belle2::Const::muon
static const ChargedStable muon
muon particle
Definition: Const.h:660
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition: Const.h:661
Belle2::Const::Klong
static const ParticleType Klong
K^0_L particle.
Definition: Const.h:678
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition: Const.h:659
Belle2::ECLCalDigit
Class to store calibrated ECLDigits: ECLCalDigits.
Definition: ECLCalDigit.h:23
Belle2::ECLCalDigit::getCellId
int getCellId() const
Get Cell ID.
Definition: ECLCalDigit.h:118
Belle2::ECLCalDigit::getEnergy
double getEnergy() const
Get Calibrated Energy.
Definition: ECLCalDigit.h:123
Belle2::ECLCalDigit::getTime
double getTime() const
Get Calibrated Time.
Definition: ECLCalDigit.h:163
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:351
Belle2::ECLCluster::getPhi
double getPhi() const
Return Corrected Phi of Shower (radian).
Definition: ECLCluster.h:304
Belle2::ECLCluster::getE1oE9
double getE1oE9() const
Return E1/E9 (shower shape variable).
Definition: ECLCluster.h:277
Belle2::ECLCluster::getDeltaL
double getDeltaL() const
Return deltaL.
Definition: ECLCluster.h:265
Belle2::ECLCluster::getR
double getR() const
Return R.
Definition: ECLCluster.h:310
Belle2::ECLCluster::getEnergyRaw
double getEnergyRaw() const
Return Uncorrected Energy deposited (GeV)
Definition: ECLCluster.h:316
Belle2::ECLCluster::getUncertaintyTheta
double getUncertaintyTheta() const
Return Uncertainty on Theta of Shower.
Definition: ECLCluster.h:325
Belle2::ECLCluster::getLAT
double getLAT() const
Return LAT (shower shape variable).
Definition: ECLCluster.h:292
Belle2::ECLCluster::getE9oE21
double getE9oE21() const
Return E9/E21 (shower shape variable).
Definition: ECLCluster.h:280
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:322
Belle2::ECLCluster::getMinTrkDistance
double getMinTrkDistance() const
Get distance between cluster COG and track extrapolation to ECL.
Definition: ECLCluster.h:259
Belle2::ECLCluster::getNumberOfCrystals
double getNumberOfCrystals() const
Return number of a crystals in a shower (sum of weights).
Definition: ECLCluster.h:295
Belle2::ECLCluster::getEnergyHighestCrystal
double getEnergyHighestCrystal() const
Return energy of highest energetic crystal in cluster (GeV)
Definition: ECLCluster.h:319
Belle2::ECLCluster::getZernikeMVA
double getZernikeMVA() const
Return MVA based hadron/photon value based on Zernike moments (shower shape variable).
Definition: ECLCluster.h:274
Belle2::ECLCluster::getUncertaintyPhi
double getUncertaintyPhi() const
Return Uncertainty on Phi of Shower.
Definition: ECLCluster.h:328
Belle2::ECLCluster::getAbsZernike40
double getAbsZernike40() const
Return Zernike moment 40 (shower shape variable).
Definition: ECLCluster.h:268
Belle2::ECLCluster::getSecondMoment
double getSecondMoment() const
Return second moment (shower shape variable).
Definition: ECLCluster.h:289
Belle2::ECLCluster::getTheta
double getTheta() const
Return Corrected Theta of Shower (radian).
Definition: ECLCluster.h:307
Belle2::ECLCluster::getDeltaTime99
double getDeltaTime99() const
Return cluster delta time 99.
Definition: ECLCluster.h:301
Belle2::ECLCluster::getTime
double getTime() const
Return cluster time.
Definition: ECLCluster.h:298
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:271
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 identifier.
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::eclShowerArrayName
virtual const char * eclShowerArrayName() const
Default name ECLShower array.
Definition: ECLDataAnalysisModule.h:120
Belle2::ECLDataAnalysisModule::m_eclLogLikeEl
std::vector< double > * m_eclLogLikeEl
PID track electron likelihood.
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::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::eclClusterArrayName
virtual const char * eclClusterArrayName() const
Default name ECLClusters array.
Definition: ECLDataAnalysisModule.h:123
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::ECLDataAnalysisModule
ECLDataAnalysisModule()
Constructor of the module.
Definition: ECLDataAnalysisModule.cc:50
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::eclSimHitArrayName
virtual const char * eclSimHitArrayName() const
Default name ECLCalDigits array.
Definition: ECLDataAnalysisModule.h:108
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::eclPureClusterArrayName
virtual const char * eclPureClusterArrayName() const
Default name ECLPureClusters array.
Definition: ECLDataAnalysisModule.h:156
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::eclHitArrayName
virtual const char * eclHitArrayName() const
Default name ECLCalDigits array.
Definition: ECLDataAnalysisModule.h:111
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::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::eclLocalMaximumArrayName
virtual const char * eclLocalMaximumArrayName() const
Default name ECLLocalMaxima array.
Definition: ECLDataAnalysisModule.h:129
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::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 likelihood.
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::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::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::eclPureDigitArrayName
virtual const char * eclPureDigitArrayName() const
Default name ECLPureDigits array.
Definition: ECLDataAnalysisModule.h:147
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::eclDigitArrayName
virtual const char * eclDigitArrayName() const
Default name ECLDigits array.
Definition: ECLDataAnalysisModule.h:114
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::eclConnectedRegionArrayName
virtual const char * eclConnectedRegionArrayName() const
Default name ECLConnectedRegions array.
Definition: ECLDataAnalysisModule.h:126
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::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::eclCalDigitArrayName
virtual const char * eclCalDigitArrayName() const
Default name ECLCalDigits array.
Definition: ECLDataAnalysisModule.h:117
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 associated to that ECLDigit.
Definition: ECLDataAnalysisModule.h:243
Belle2::ECLDataAnalysisModule::eclPureLocalMaximumArrayName
virtual const char * eclPureLocalMaximumArrayName() const
Default name ECLPureLocalMaxima array.
Definition: ECLDataAnalysisModule.h:162
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 likelihood.
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::m_eclPureClusterToMC4
std::vector< int > * m_eclPureClusterToMC4
Index of fourth MCParticle related to ECLCluster, PureCsI option.
Definition: ECLDataAnalysisModule.h:386
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::eclPureShowerArrayName
virtual const char * eclPureShowerArrayName() const
Default name ECLPureShower array.
Definition: ECLDataAnalysisModule.h:153
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::eclPureCalDigitArrayName
virtual const char * eclPureCalDigitArrayName() const
Default name ECLPureCalDigits array.
Definition: ECLDataAnalysisModule.h:150
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 health flag.
Definition: ECLDataAnalysisModule.h:301
Belle2::ECLDataAnalysisModule::m_eclClusterIsTrack
std::vector< bool > * m_eclClusterIsTrack
Flag for charged clusters.
Definition: ECLDataAnalysisModule.h:302
Belle2::ECLDataAnalysisModule::eclPureConnectedRegionArrayName
virtual const char * eclPureConnectedRegionArrayName() const
Default name ECLPureConnectedRegions array.
Definition: ECLDataAnalysisModule.h:159
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::m_eclPureClusterCrystalHealth
std::vector< int > * m_eclPureClusterCrystalHealth
Crystal health flag, PureCsI option.
Definition: ECLDataAnalysisModule.h:411
Belle2::ECLDataAnalysisModule::m_eclShowerPhiError
std::vector< double > * m_eclShowerPhiError
Shower Phi Error.
Definition: ECLDataAnalysisModule.h:484
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::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::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::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::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::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:273
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
std
STL namespace.