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
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
860
861void ECLDataAnalysisModule::event()
862{
863
864 B2DEBUG(1, " ++++++++++++++ ECLDataAnalysisModule");
865
866 //EventLevelClusteringInfo
867 m_nECLCalDigitsOutOfTimeFWD = 0;
868 m_nECLCalDigitsOutOfTimeBarrel = 0;
869 m_nECLCalDigitsOutOfTimeBWD = 0;
870 m_nECLShowersRejectedFWD = 0;
871 m_nECLShowersRejectedBarrel = 0;
872 m_nECLShowersRejectedBWD = 0;
873
874 if (m_doDigits == 1) {
876 m_eclDigitMultip = 0;
877 m_eclDigitIdx->clear();
878 m_eclDigitToMC->clear();
879 m_eclDigitCellId->clear();
880 m_eclDigitAmp->clear();
881 m_eclDigitTimeFit->clear();
882 m_eclDigitFitQuality->clear();
883 m_eclDigitToCalDigit->clear();
884
886 m_eclCalDigitMultip = 0;
887 m_eclCalDigitCellId->clear();
888 m_eclCalDigitAmp->clear();
889 m_eclCalDigitTimeFit->clear();
890 m_eclCalDigitFitQuality->clear();
891 m_eclCalDigitIdx->clear();
892 m_eclCalDigitToMC1->clear();
893 m_eclCalDigitToMCWeight1->clear();
894 m_eclCalDigitToMC2->clear();
895 m_eclCalDigitToMCWeight2->clear();
896 m_eclCalDigitToMC3->clear();
897 m_eclCalDigitToMCWeight3->clear();
898 m_eclCalDigitToMC4->clear();
899 m_eclCalDigitToMCWeight4->clear();
900 m_eclCalDigitToMC5->clear();
901 m_eclCalDigitToMCWeight5->clear();
902 m_eclCalDigitToMC1PDG->clear();
903 m_eclCalDigitToMC2PDG->clear();
904 m_eclCalDigitToMC3PDG->clear();
905 m_eclCalDigitToMC4PDG->clear();
906 m_eclCalDigitToMC5PDG->clear();
907 m_eclCalDigitToBkgWeight->clear();
908 m_eclCalDigitSimHitSum->clear();
909 m_eclCalDigitToShower->clear();
910 m_eclCalDigitToCR->clear();
911 m_eclCalDigitToLM->clear();
912 }
913
914 m_eclCRIdx->clear();
915 m_eclCRIsTrack->clear();
916 m_eclCRLikelihoodMIPNGamma->clear();
917 m_eclCRLikelihoodChargedHadron->clear();
918 m_eclCRLikelihoodElectronNGamma->clear();
919 m_eclCRLikelihoodNGamma->clear();
920 m_eclCRLikelihoodNeutralHadron->clear();
921 m_eclCRLikelihoodMergedPi0->clear();
922
923 if (m_doHits == 1) {
924 //SimHit
925 m_eclSimHitMultip = 0;
926 m_eclSimHitCellId->clear();
927 m_eclSimHitPdg->clear();
928 m_eclSimHitEnergyDep->clear();
929 m_eclSimHitFlightTime->clear();
930 m_eclSimHitIdx->clear();
931 m_eclSimHitToMC->clear();
932 m_eclSimHitX->clear();
933 m_eclSimHitY->clear();
934 m_eclSimHitZ->clear();
935 m_eclSimHitPx->clear();
936 m_eclSimHitPy->clear();
937 m_eclSimHitPz->clear();
938
940 m_eclHitMultip = 0;
941 m_eclHitCellId->clear();
942 m_eclHitEnergyDep->clear();
943 m_eclHitTimeAve->clear();
944 m_eclHitIdx->clear();
945 m_eclHitToMC->clear();
946 m_eclHitToDigit->clear();
947 m_eclHitToDigitAmp->clear();
948 }
949
950 m_eclLMMultip = 0;
951 m_eclLMId->clear();
952 m_eclLMType->clear();
953 m_eclLMCellId->clear();
954
956 m_eclClusterMultip = 0;
957 m_eclClusterTrueMultip = 0;
958 m_eclClusterGammaMultip = 0;
959 m_eclClusterEnergy->clear();
960 m_eclClusterEnergyError->clear();
961 m_eclClusterTheta->clear();
962 m_eclClusterThetaError->clear();
963 m_eclClusterPhi->clear();
964 m_eclClusterPhiError->clear();
965 m_eclClusterR->clear();
966 m_eclClusterIdx->clear();
967 m_eclClusterToMC1->clear();
968 m_eclClusterToMCWeight1->clear();
969 m_eclClusterToMC1PDG->clear();
970 m_eclClusterToMC2->clear();
971 m_eclClusterToMCWeight2->clear();
972 m_eclClusterToMC2PDG->clear();
973 m_eclClusterToMC3->clear();
974 m_eclClusterToMCWeight3->clear();
975 m_eclClusterToMC3PDG->clear();
976 m_eclClusterToMC4->clear();
977 m_eclClusterToMCWeight4->clear();
978 m_eclClusterToMC4PDG->clear();
979 m_eclClusterToMC5->clear();
980 m_eclClusterToMCWeight5->clear();
981 m_eclClusterToMC5PDG->clear();
982 m_eclClusterToBkgWeight->clear();
983 m_eclClusterSimHitSum->clear();
984 m_eclClusterEnergyDepSum->clear();
985 m_eclClusterTiming->clear();
986 m_eclClusterTimingError->clear();
987 m_eclClusterE9oE21->clear();
988 m_eclClusterHighestE->clear();
989 m_eclClusterCellId->clear();
990 m_eclClusterNofCrystals->clear();
991 m_eclClusterCrystalHealth->clear();
992 m_eclClusterIsTrack->clear();
993 m_eclClusterClosestTrackDist->clear();
994 m_eclClusterDeltaL->clear();
995 m_eclClusterToShower->clear();
996 m_eclClusterAbsZernike40->clear();
997 m_eclClusterAbsZernike51->clear();
998 m_eclClusterZernikeMVA->clear();
999 m_eclClusterE1oE9->clear();
1000 m_eclClusterSecondMoment->clear();
1001 m_eclClusterLAT->clear();
1002 m_eclClusterDeltaTime99->clear();
1003 m_eclClusterDetectorRegion->clear();
1004 m_eclClusterHasNPhotonHypothesis->clear();
1005 m_eclClusterHasNeutralHadronHypothesis->clear();
1006
1008 m_eclShowerMultip = 0;
1009 m_eclShowerIdx->clear();
1010 m_eclShowerToMC1->clear();
1011 m_eclShowerToMCWeight1->clear();
1012 m_eclShowerToMC1PDG->clear();
1013 m_eclShowerToMC1Moth->clear();
1014 m_eclShowerToMC1MothPDG->clear();
1015 m_eclShowerToMC1GMoth->clear();
1016 m_eclShowerToMC1GMothPDG->clear();
1017 m_eclShowerToMC2->clear();
1018 m_eclShowerToMCWeight2->clear();
1019 m_eclShowerToMC2PDG->clear();
1020 m_eclShowerToMC2Moth->clear();
1021 m_eclShowerToMC2MothPDG->clear();
1022 m_eclShowerToMC2GMoth->clear();
1023 m_eclShowerToMC2GMothPDG->clear();
1024 m_eclShowerToMC3->clear();
1025 m_eclShowerToMCWeight3->clear();
1026 m_eclShowerToMC3PDG->clear();
1027 m_eclShowerToMC3Moth->clear();
1028 m_eclShowerToMC3MothPDG->clear();
1029 m_eclShowerToMC3GMoth->clear();
1030 m_eclShowerToMC3GMothPDG->clear();
1031 m_eclShowerToMC4->clear();
1032 m_eclShowerToMCWeight4->clear();
1033 m_eclShowerToMC4PDG->clear();
1034 m_eclShowerToMC4Moth->clear();
1035 m_eclShowerToMC4MothPDG->clear();
1036 m_eclShowerToMC4GMoth->clear();
1037 m_eclShowerToMC4GMothPDG->clear();
1038 m_eclShowerToMC5->clear();
1039 m_eclShowerToMCWeight5->clear();
1040 m_eclShowerToMC5PDG->clear();
1041 m_eclShowerToMC5Moth->clear();
1042 m_eclShowerToMC5MothPDG->clear();
1043 m_eclShowerToMC5GMoth->clear();
1044 m_eclShowerToMC5GMothPDG->clear();
1045 m_eclShowerToBkgWeight->clear();
1046 m_eclShowerToLM1->clear();
1047 m_eclShowerToLM2->clear();
1048 m_eclShowerToLM3->clear();
1049 m_eclShowerToLM4->clear();
1050 m_eclShowerToLM5->clear();
1051 m_eclShowerSimHitSum->clear();
1052 m_eclShowerUncEnergy->clear();
1053 m_eclShowerEnergy->clear();
1054 m_eclShowerTheta->clear();
1055 m_eclShowerPhi->clear();
1056 m_eclShowerR->clear();
1057 m_eclShowerNHits->clear();
1058 m_eclShowerE9oE21->clear();
1059 m_eclShowerTime->clear();
1060 m_eclShowerT99->clear();
1061 m_eclShowerConnectedRegionId->clear();
1062 m_eclShowerHypothesisId->clear();
1063 m_eclShowerCentralCellId->clear();
1064 m_eclShowerEnergyError->clear();
1065 m_eclShowerThetaError->clear();
1066 m_eclShowerPhiError->clear();
1067 m_eclShowerTimeResolution->clear();
1068 m_eclShowerHighestEnergy->clear();
1069 m_eclShowerLateralEnergy->clear();
1070 m_eclShowerMinTrkDistance->clear();
1071 m_eclShowerTrkDepth->clear();
1072 m_eclShowerShowerDepth->clear();
1073 m_eclShowerAbsZernike40->clear();
1074 m_eclShowerAbsZernike51->clear();
1075 m_eclShowerZernikeMVA->clear();
1076 m_eclShowerSecondMoment->clear();
1077 m_eclShowerE1oE9->clear();
1078 m_eclShowerIsTrack->clear();
1079 m_eclShowerIsCluster->clear();
1080 m_eclShowerMCVtxInEcl->clear();
1081 m_eclShowerMCFlightMatch->clear();
1082 m_eclShowerMCFFlightMatch->clear();
1083 m_eclShowerHighestE1mE2->clear();
1084 m_eclShowerNumberOfCrystalsForEnergy->clear();
1085
1087 if (m_doPureCsI == true) {
1088 m_eclPureDigitMultip = 0;
1089 m_eclPureDigitIdx->clear();
1090 m_eclPureDigitToMC->clear();
1091 m_eclPureDigitCellId->clear();
1092 m_eclPureDigitAmp->clear();
1093 m_eclPureDigitTimeFit->clear();
1094 m_eclPureDigitFitQuality->clear();
1095 m_eclPureDigitToCluster->clear();
1096 m_eclHitToPureDigit->clear();
1097 m_eclHitToPureDigitAmp->clear();
1098
1099 //Pure CalDigits
1100 m_eclPureCalDigitMultip = 0;
1101 m_eclPureCalDigitCellId->clear();
1102 m_eclPureCalDigitAmp->clear();
1103 m_eclPureCalDigitTimeFit->clear();
1104 m_eclPureCalDigitFitQuality->clear();
1105 m_eclPureCalDigitIdx->clear();
1106 m_eclPureCalDigitToMC1->clear();
1107 m_eclPureCalDigitToMCWeight1->clear();
1108 m_eclPureCalDigitToMC2->clear();
1109 m_eclPureCalDigitToMCWeight2->clear();
1110 m_eclPureCalDigitToMC3->clear();
1111 m_eclPureCalDigitToMCWeight3->clear();
1112 m_eclPureCalDigitToMC4->clear();
1113 m_eclPureCalDigitToMCWeight4->clear();
1114 m_eclPureCalDigitToMC5->clear();
1115 m_eclPureCalDigitToMCWeight5->clear();
1116 m_eclPureCalDigitToMC1PDG->clear();
1117 m_eclPureCalDigitToMC2PDG->clear();
1118 m_eclPureCalDigitToMC3PDG->clear();
1119 m_eclPureCalDigitToMC4PDG->clear();
1120 m_eclPureCalDigitToMC5PDG->clear();
1121 m_eclPureCalDigitToBkgWeight->clear();
1122 m_eclPureCalDigitSimHitSum->clear();
1123 m_eclPureCalDigitToShower->clear();
1124 m_eclPureCalDigitToCR->clear();
1125 m_eclPureCalDigitToLM->clear();
1126
1127 m_eclPureCRIdx->clear();
1128 m_eclPureCRIsTrack->clear();
1129 m_eclPureCRLikelihoodMIPNGamma->clear();
1130 m_eclPureCRLikelihoodChargedHadron->clear();
1131 m_eclPureCRLikelihoodElectronNGamma->clear();
1132 m_eclPureCRLikelihoodNGamma->clear();
1133 m_eclPureCRLikelihoodNeutralHadron->clear();
1134 m_eclPureCRLikelihoodMergedPi0->clear();
1135
1136 m_eclPureLMMultip = 0;
1137 m_eclPureLMId->clear();
1138 m_eclPureLMType->clear();
1139 m_eclPureLMCellId->clear();
1140
1142 m_eclPureClusterMultip = 0;
1143 m_eclPureClusterToMC1->clear();
1144 m_eclPureClusterToMCWeight1->clear();
1145 m_eclPureClusterToMC1PDG->clear();
1146 m_eclPureClusterToMC2->clear();
1147 m_eclPureClusterToMCWeight2->clear();
1148 m_eclPureClusterToMC2PDG->clear();
1149 m_eclPureClusterToMC3->clear();
1150 m_eclPureClusterToMCWeight3->clear();
1151 m_eclPureClusterToMC3PDG->clear();
1152 m_eclPureClusterToMC4->clear();
1153 m_eclPureClusterToMCWeight4->clear();
1154 m_eclPureClusterToMC4PDG->clear();
1155 m_eclPureClusterToMC5->clear();
1156 m_eclPureClusterToMCWeight5->clear();
1157 m_eclPureClusterToMC5PDG->clear();
1158 m_eclPureClusterToBkgWeight->clear();
1159 m_eclPureClusterEnergy->clear();
1160 m_eclPureClusterEnergyError->clear();
1161 m_eclPureClusterTheta->clear();
1162 m_eclPureClusterEnergyDepSum->clear();
1163 m_eclPureClusterThetaError->clear();
1164 m_eclPureClusterPhi->clear();
1165 m_eclPureClusterPhiError->clear();
1166 m_eclPureClusterR->clear();
1167 m_eclPureClusterIdx->clear();
1168 m_eclPureClusterTiming->clear();
1169 m_eclPureClusterTimingError->clear();
1170 m_eclPureClusterE9oE21->clear();
1171 m_eclPureClusterHighestE->clear();
1172 m_eclPureClusterCellId->clear();
1173 m_eclPureClusterLat->clear();
1174 m_eclPureClusterNofCrystals->clear();
1175 m_eclPureClusterCrystalHealth->clear();
1176 m_eclPureClusterClosestTrackDist->clear();
1177 m_eclPureClusterAbsZernike40->clear();
1178 m_eclPureClusterAbsZernike51->clear();
1179 m_eclPureClusterZernikeMVA->clear();
1180 m_eclPureClusterSecondMoment->clear();
1181 m_eclPureClusterIsTrack->clear();
1182 m_eclPureClusterDeltaL->clear();
1183 m_eclPureClusterE1oE9->clear();
1184 m_eclPureClusterDeltaTime99->clear();
1185 m_eclPureClusterDetectorRegion->clear();
1186 m_eclPureClusterHasNPhotonHypothesis->clear();
1187 m_eclPureClusterHasNeutralHadronHypothesis->clear();
1188 }
1189
1191 m_mcMultip = 0;
1192 m_mcIdx->clear();
1193 m_mcPdg->clear();
1194 m_mcMothPdg->clear();
1195 m_mcGMothPdg->clear();
1196 m_mcGGMothPdg->clear();
1197 m_mcEnergy->clear();
1198 m_mcPx->clear();
1199 m_mcPy->clear();
1200 m_mcPz->clear();
1201 m_mcDecayVtxX->clear();
1202 m_mcDecayVtxY->clear();
1203 m_mcDecayVtxZ->clear();
1204 m_mcProdVtxX->clear();
1205 m_mcProdVtxY->clear();
1206 m_mcProdVtxZ->clear();
1207 m_mcSecondaryPhysProc->clear();
1208
1210 if (m_doTracking == true) {
1211 m_trkMultip = 0;
1212 m_trkIdx->clear();
1213 m_trkPdg->clear();
1214 m_trkCharge->clear();
1215 m_trkPx->clear();
1216 m_trkPy->clear();
1217 m_trkPz->clear();
1218 m_trkP->clear();
1219 m_trkPhi->clear();
1220 m_trkTheta->clear();
1221 m_trkPhi->clear();
1222 m_trkX->clear();
1223 m_trkY->clear();
1224 m_trkZ->clear();
1225
1227 m_eclpidtrkIdx->clear();
1228 m_eclpidEnergy->clear();
1229 m_eclpidEop->clear();
1230 m_eclpidE9E21->clear();
1231 m_eclpidNCrystals->clear();
1232 m_eclpidNClusters->clear();
1233 m_eclLogLikeEl->clear();
1234 m_eclLogLikeMu->clear();
1235 m_eclLogLikePi->clear();
1236 }
1237
1238
1239 if (m_eventmetadata) {
1240 m_iExperiment = m_eventmetadata->getExperiment();
1241 m_iRun = m_eventmetadata->getRun();
1242 m_iEvent = m_eventmetadata->getEvent();
1243 } else {
1244 m_iExperiment = -1;
1245 m_iRun = -1;
1246 m_iEvent = -1;
1247 }
1248
1249 //EventLevelClusteringInfo
1250 m_nECLCalDigitsOutOfTimeFWD = m_eventLevelClusteringInfo->getNECLCalDigitsOutOfTimeFWD();
1251 m_nECLCalDigitsOutOfTimeBarrel = m_eventLevelClusteringInfo->getNECLCalDigitsOutOfTimeBarrel();
1252 m_nECLCalDigitsOutOfTimeBWD = m_eventLevelClusteringInfo->getNECLCalDigitsOutOfTimeBWD();
1253 m_nECLShowersRejectedFWD = m_eventLevelClusteringInfo->getNECLShowersRejectedFWD();
1254 m_nECLShowersRejectedBarrel = m_eventLevelClusteringInfo->getNECLShowersRejectedBarrel();
1255 m_nECLShowersRejectedBWD = m_eventLevelClusteringInfo->getNECLShowersRejectedBWD();
1256
1257 if (m_doDigits == 1) {
1258 //DIGITS
1259 m_eclDigitMultip = m_eclDigits.getEntries();
1260 for (int idigits = 0; idigits < m_eclDigits.getEntries() ; idigits++) {
1261 ECLDigit* aECLDigits = m_eclDigits[idigits];
1262 m_eclDigitIdx->push_back(idigits);
1263 m_eclDigitCellId->push_back(aECLDigits->getCellId());
1264 m_eclDigitAmp->push_back(aECLDigits->getAmp());
1265 m_eclDigitTimeFit->push_back(aECLDigits->getTimeFit());
1266 m_eclDigitFitQuality->push_back(aECLDigits->getQuality());
1267
1268 if (aECLDigits->getRelated<MCParticle>() != (nullptr)) {
1269 const MCParticle* mc_digit = aECLDigits->getRelated<MCParticle>();
1270 m_eclDigitToMC->push_back(mc_digit->getArrayIndex());
1271 } else
1272 m_eclDigitToMC->push_back(-1);
1273
1274 if (aECLDigits->getRelated<ECLCalDigit>() != (nullptr)) {
1275 const ECLCalDigit* cal_digit = aECLDigits->getRelated<ECLCalDigit>();
1276 m_eclDigitToCalDigit->push_back(cal_digit->getArrayIndex());
1277 } else
1278 m_eclDigitToCalDigit->push_back(-1);
1279 }
1280
1281 //CAL DIGITS
1282 m_eclCalDigitMultip = m_eclCalDigits.getEntries();
1283 for (uint icaldigits = 0; icaldigits < (uint)m_eclCalDigits.getEntries() ; icaldigits++) {
1284 ECLCalDigit* aECLCalDigits = m_eclCalDigits[icaldigits];
1285
1286 m_eclCalDigitIdx->push_back(icaldigits);
1287 m_eclCalDigitCellId->push_back(aECLCalDigits->getCellId());
1288 m_eclCalDigitAmp->push_back(aECLCalDigits->getEnergy());
1289 m_eclCalDigitTimeFit->push_back(aECLCalDigits->getTime());
1290 m_eclCalDigitFitQuality->push_back(aECLCalDigits->isFailedFit());
1291
1292 double sumHit = 0;
1293 int idx[10];
1294 for (int i = 0; i < 10; i++)
1295 idx[i] = -1;
1296
1297 double wi[10];
1298 for (int i = 0; i < 10; i++)
1299 wi[i] = -1;
1300
1301 int ii = 0;
1302 sumHit = 0;
1303
1304 auto digitMCRelations = aECLCalDigits->getRelationsTo<MCParticle>();
1305 for (unsigned int i = 0; i < digitMCRelations.size(); ++i) {
1306 if (ii < 10) {
1307 const auto mcParticle = digitMCRelations.object(i);
1308 idx[ii] = mcParticle->getIndex() - 1;
1309 wi[ii] = digitMCRelations.weight(i);
1310 sumHit = sumHit + digitMCRelations.weight(i);
1311 ii++;
1312 }
1313 }
1314
1315 //Re-ordering based on contribution
1316 int y = 0;
1317 while (y < 10) {
1318 for (int i = 0; i < 9; i++) {
1319 if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1320 if (wi[i] < wi[i + 1]) {
1321 int temp = idx[i];
1322 idx[i] = idx[i + 1];
1323 idx[i + 1] = temp;
1324
1325 double wtemp = wi[i];
1326 wi[i] = wi[i + 1];
1327 wi[i + 1] = wtemp;
1328 }
1329 }
1330 }
1331 y++;
1332 }
1333
1334 m_eclCalDigitToBkgWeight->push_back(aECLCalDigits->getEnergy() - sumHit);
1335 m_eclCalDigitSimHitSum->push_back(sumHit);
1336 if (idx[0] > -1) {
1337 m_eclCalDigitToMCWeight1->push_back(wi[0]);
1338 m_eclCalDigitToMC1->push_back(idx[0]);
1339 const MCParticle* amcParticle = m_mcParticles[idx[0]];
1340 m_eclCalDigitToMC1PDG->push_back(amcParticle->getPDG());
1341 } else {
1342 m_eclCalDigitToMCWeight1->push_back(-1);
1343 m_eclCalDigitToMC1->push_back(-1);
1344 m_eclCalDigitToMC1PDG->push_back(-1);
1345 }
1346 if (idx[1] > -1) {
1347 m_eclCalDigitToMCWeight2->push_back(wi[1]);
1348 m_eclCalDigitToMC2->push_back(idx[1]);
1349 const MCParticle* amcParticle = m_mcParticles[idx[1]];
1350 m_eclCalDigitToMC2PDG->push_back(amcParticle->getPDG());
1351 } else {
1352 m_eclCalDigitToMCWeight2->push_back(-1);
1353 m_eclCalDigitToMC2->push_back(-1);
1354 m_eclCalDigitToMC2PDG->push_back(-1);
1355 }
1356 if (idx[2] > -1) {
1357 m_eclCalDigitToMCWeight3->push_back(wi[2]);
1358 m_eclCalDigitToMC3->push_back(idx[2]);
1359 const MCParticle* amcParticle = m_mcParticles[idx[2]];
1360 m_eclCalDigitToMC3PDG->push_back(amcParticle->getPDG());
1361 } else {
1362 m_eclCalDigitToMCWeight3->push_back(-1);
1363 m_eclCalDigitToMC3->push_back(-1);
1364 m_eclCalDigitToMC3PDG->push_back(-1);
1365 }
1366 if (idx[3] > -1) {
1367 m_eclCalDigitToMCWeight4->push_back(wi[3]);
1368 m_eclCalDigitToMC4->push_back(idx[3]);
1369 const MCParticle* amcParticle = m_mcParticles[idx[3]];
1370 m_eclCalDigitToMC4PDG->push_back(amcParticle->getPDG());
1371 } else {
1372 m_eclCalDigitToMCWeight4->push_back(-1);
1373 m_eclCalDigitToMC4->push_back(-1);
1374 m_eclCalDigitToMC4PDG->push_back(-1);
1375 }
1376 if (idx[4] > -1) {
1377 m_eclCalDigitToMCWeight5->push_back(wi[4]);
1378 m_eclCalDigitToMC5->push_back(idx[4]);
1379 const MCParticle* amcParticle = m_mcParticles[idx[4]];
1380 m_eclCalDigitToMC5PDG->push_back(amcParticle->getPDG());
1381 } else {
1382 m_eclCalDigitToMCWeight5->push_back(-1);
1383 m_eclCalDigitToMC5->push_back(-1);
1384 m_eclCalDigitToMC5PDG->push_back(-1);
1385 }
1386
1387 if (aECLCalDigits->getRelated<ECLShower>() != (nullptr)) {
1388 const ECLShower* shower_caldigit = aECLCalDigits->getRelated<ECLShower>();
1389 m_eclCalDigitToShower->push_back(shower_caldigit->getArrayIndex());
1390 } else
1391 m_eclCalDigitToShower->push_back(-1);
1392
1393 if (aECLCalDigits->getRelated<ECLConnectedRegion>() != (nullptr)) {
1394 const ECLConnectedRegion* cr_caldigit = aECLCalDigits->getRelated<ECLConnectedRegion>();
1395 m_eclCalDigitToCR->push_back(cr_caldigit->getCRId());
1396 } else
1397 m_eclCalDigitToCR->push_back(-1);
1398
1399 if (aECLCalDigits->getRelated<ECLLocalMaximum>() != (nullptr)) {
1400 const ECLLocalMaximum* lm_caldigit = aECLCalDigits->getRelated<ECLLocalMaximum>();
1401 m_eclCalDigitToLM->push_back(lm_caldigit->getLMId());
1402 } else
1403 m_eclCalDigitToLM->push_back(-1);
1404
1405 }
1406 }
1407
1408 //CR
1409 int CRmultip = m_eclConnectedRegions.getEntries();
1410 for (int i = 0; i < CRmultip; i++) {
1411 const ECLConnectedRegion* aECLCR = m_eclConnectedRegions[i];
1412 m_eclCRIdx->push_back(aECLCR->getCRId());
1413 m_eclCRIsTrack->push_back(aECLCR->isTrack());
1414 m_eclCRLikelihoodMIPNGamma->push_back(aECLCR->getLikelihoodMIPNGamma());
1415 m_eclCRLikelihoodChargedHadron->push_back(aECLCR->getLikelihoodChargedHadron());
1416 m_eclCRLikelihoodElectronNGamma->push_back(aECLCR->getLikelihoodElectronNGamma());
1417 m_eclCRLikelihoodNGamma->push_back(aECLCR->getLikelihoodNGamma());
1418 m_eclCRLikelihoodNeutralHadron->push_back(aECLCR->getLikelihoodNeutralHadron());
1419 m_eclCRLikelihoodMergedPi0->push_back(aECLCR->getLikelihoodMergedPi0());
1420 }
1421
1422 if (m_doHits == 1) {
1423
1424 //SIM HITS
1425 m_eclSimHitMultip = m_eclSimHits.getEntries();
1426 for (int isimhits = 0; isimhits < m_eclSimHits.getEntries() ; isimhits++) {
1427 ECLSimHit* aECLSimHits = m_eclSimHits[isimhits];
1428
1429 m_eclSimHitIdx->push_back(isimhits);
1430 m_eclSimHitCellId->push_back(aECLSimHits->getCellId());
1431 m_eclSimHitPdg->push_back(aECLSimHits->getPDGCode());
1432 m_eclSimHitEnergyDep->push_back(aECLSimHits->getEnergyDep());
1433 m_eclSimHitFlightTime->push_back(aECLSimHits->getFlightTime());
1434 m_eclSimHitX->push_back(aECLSimHits->getPosition().x());
1435 m_eclSimHitY->push_back(aECLSimHits->getPosition().y());
1436 m_eclSimHitZ->push_back(aECLSimHits->getPosition().z());
1437 m_eclSimHitPx->push_back(aECLSimHits->getMomentum().x());
1438 m_eclSimHitPy->push_back(aECLSimHits->getMomentum().y());
1439 m_eclSimHitPz->push_back(aECLSimHits->getMomentum().z());
1440
1441 if (aECLSimHits->getRelated<MCParticle>() != (nullptr)) {
1442 const MCParticle* mc_simhit = aECLSimHits->getRelated<MCParticle>();
1443 m_eclSimHitToMC->push_back(mc_simhit->getArrayIndex());
1444 } else
1445 m_eclSimHitToMC->push_back(-1);
1446 }
1447
1448 //HITS
1449 m_eclHitMultip = m_eclHits.getEntries();
1450 for (int ihits = 0; ihits < m_eclHits.getEntries() ; ihits++) {
1451 ECLHit* aECLHits = m_eclHits[ihits];
1452 m_eclHitIdx->push_back(ihits);
1453 m_eclHitCellId->push_back(aECLHits->getCellId());
1454 m_eclHitEnergyDep->push_back(aECLHits->getEnergyDep());
1455 m_eclHitTimeAve->push_back(aECLHits->getTimeAve());
1456
1457 if (aECLHits->getRelated<ECLDigit>() != (nullptr)) {
1458 const ECLDigit* hit_digit = aECLHits->getRelated<ECLDigit>();
1459 m_eclHitToDigit->push_back(hit_digit->getArrayIndex());
1460 m_eclHitToDigitAmp->push_back(hit_digit->getAmp());
1461 } else {
1462 m_eclHitToDigit->push_back(-1);
1463 m_eclHitToDigitAmp->push_back(-1);
1464 }
1465
1466 if (m_doPureCsI == true) {
1467 if (aECLHits->getRelated<ECLDigit>(eclPureDigitArrayName()) != (nullptr)) {
1468 const ECLDigit* hit_pdigit = aECLHits->getRelated<ECLDigit>(eclPureDigitArrayName());
1469 m_eclHitToPureDigit->push_back(hit_pdigit->getArrayIndex());
1470 m_eclHitToPureDigitAmp->push_back(hit_pdigit->getAmp());
1471 } else {
1472 m_eclHitToPureDigit->push_back(-1);
1473 m_eclHitToPureDigitAmp->push_back(-1);
1474 }
1475 }
1476
1477 if (aECLHits->getRelated<MCParticle>() != (nullptr)) {
1478 const MCParticle* mc_hit = aECLHits->getRelated<MCParticle>();
1479 m_eclHitToMC->push_back(mc_hit->getArrayIndex());
1480 } else
1481 m_eclHitToMC->push_back(-1);
1482 }
1483 }
1484
1485 //LM
1486 m_eclLMMultip = m_eclLocalMaximums.getEntries();
1487 for (unsigned int ilms = 0; ilms < (unsigned int)m_eclLocalMaximums.getEntries() ; ilms++) {
1488 const ECLLocalMaximum* aECLLMs = m_eclLocalMaximums[ilms];
1489 m_eclLMId->push_back(aECLLMs->getLMId());
1490 m_eclLMType->push_back(aECLLMs->getType());
1491 m_eclLMCellId->push_back(aECLLMs->getCellId());
1492 }
1493
1494 //CLUSTERS
1495 m_eclClusterMultip = m_eclClusters.getEntries();
1496 for (unsigned int iclusters = 0; iclusters < (unsigned int)m_eclClusters.getEntries() ; iclusters++) {
1497 ECLCluster* aECLClusters = m_eclClusters[iclusters];
1498 m_eclClusterIdx->push_back(iclusters);
1499
1500 double clusterE = 0.0;
1501 if (aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) clusterE = aECLClusters->getEnergy(
1502 ECLCluster::EHypothesisBit::c_nPhotons);
1503 else clusterE = aECLClusters->getEnergy(ECLCluster::EHypothesisBit::c_neutralHadron);
1504 m_eclClusterEnergy->push_back(clusterE);
1505
1506 m_eclClusterEnergyError->push_back(aECLClusters->getUncertaintyEnergy());
1507 m_eclClusterTheta->push_back(aECLClusters->getTheta());
1508 m_eclClusterThetaError->push_back(aECLClusters->getUncertaintyTheta());
1509 m_eclClusterPhi->push_back(aECLClusters->getPhi());
1510 m_eclClusterPhiError->push_back(aECLClusters->getUncertaintyPhi());
1511 m_eclClusterR->push_back(aECLClusters->getR());
1512 m_eclClusterEnergyDepSum->push_back(aECLClusters->getEnergyRaw());
1513 m_eclClusterTiming->push_back(aECLClusters->getTime());
1514 m_eclClusterTimingError->push_back(aECLClusters->getDeltaTime99());
1515 m_eclClusterE9oE21->push_back(aECLClusters->getE9oE21());
1516 m_eclClusterHighestE->push_back(aECLClusters->getEnergyHighestCrystal());
1517 m_eclClusterCellId->push_back(aECLClusters->getMaxECellId());
1518 m_eclClusterNofCrystals->push_back(aECLClusters->getNumberOfCrystals());
1519 m_eclClusterCrystalHealth->push_back(aECLClusters->getStatus());
1520
1521 m_eclClusterIsTrack->push_back(aECLClusters->isTrack());
1522 m_eclClusterClosestTrackDist->push_back(aECLClusters->getMinTrkDistance());
1523 m_eclClusterDeltaL->push_back(aECLClusters->getDeltaL());
1524
1525 m_eclClusterAbsZernike40->push_back(aECLClusters->getAbsZernike40());
1526 m_eclClusterAbsZernike51->push_back(aECLClusters->getAbsZernike51());
1527 m_eclClusterZernikeMVA->push_back(aECLClusters->getZernikeMVA());
1528 m_eclClusterE1oE9->push_back(aECLClusters->getE1oE9());
1529 m_eclClusterSecondMoment->push_back(aECLClusters->getSecondMoment());
1530 m_eclClusterLAT->push_back(aECLClusters->getLAT());
1531 m_eclClusterDeltaTime99->push_back(aECLClusters->getDeltaTime99());
1532 m_eclClusterDetectorRegion->push_back(aECLClusters->getDetectorRegion());
1533 m_eclClusterHasNPhotonHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons));
1534 m_eclClusterHasNeutralHadronHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_neutralHadron));
1535
1536 if (aECLClusters->getRelated<ECLShower>() != (nullptr)) {
1537 const ECLShower* shower_cluster = aECLClusters->getRelated<ECLShower>();
1538 m_eclClusterToShower->push_back(shower_cluster->getArrayIndex());
1539 } else
1540 m_eclClusterToShower->push_back(-1);
1541
1542 //Dump MC Info - Multiple Matching
1543 double sumHit = 0;
1544 int idx[10];
1545 for (int i = 0; i < 10; i++)
1546 idx[i] = -1;
1547
1548 double wi[10];
1549 for (int i = 0; i < 10; i++)
1550 wi[i] = -1;
1551
1552 int ii = 0;
1553 sumHit = 0;
1554
1555 auto clusterMCRelations = aECLClusters->getRelationsTo<MCParticle>();
1556 for (unsigned int i = 0; i < clusterMCRelations.size(); ++i) {
1557 if (ii < 10) {
1558 const auto mcParticle = clusterMCRelations.object(i);
1559 idx[ii] = mcParticle->getIndex() - 1;
1560 wi[ii] = clusterMCRelations.weight(i);
1561 sumHit = sumHit + clusterMCRelations.weight(i);
1562 ii++;
1563 }
1564 }
1565
1566 //Re-ordering based on contribution
1567 int y = 0;
1568 while (y < 10) {
1569 for (int i = 0; i < 9; i++) {
1570 if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1571 if (wi[i] < wi[i + 1]) {
1572 int temp = idx[i];
1573 idx[i] = idx[i + 1];
1574 idx[i + 1] = temp;
1575
1576 double wtemp = wi[i];
1577 wi[i] = wi[i + 1];
1578 wi[i + 1] = wtemp;
1579 }
1580 }
1581 }
1582 y++;
1583 }
1584
1585 m_eclClusterToBkgWeight->push_back(clusterE - sumHit);
1586 m_eclClusterSimHitSum->push_back(sumHit);
1587 if (idx[0] > -1) {
1588 m_eclClusterToMCWeight1->push_back(wi[0]);
1589 m_eclClusterToMC1->push_back(idx[0]);
1590 const MCParticle* amcParticle = m_mcParticles[idx[0]];
1591 m_eclClusterToMC1PDG->push_back(amcParticle->getPDG());
1592 } else {
1593 m_eclClusterToMCWeight1->push_back(-1);
1594 m_eclClusterToMC1->push_back(-1);
1595 m_eclClusterToMC1PDG->push_back(-1);
1596 }
1597 if (idx[1] > -1) {
1598 m_eclClusterToMCWeight2->push_back(wi[1]);
1599 m_eclClusterToMC2->push_back(idx[1]);
1600 const MCParticle* amcParticle = m_mcParticles[idx[1]];
1601 m_eclClusterToMC2PDG->push_back(amcParticle->getPDG());
1602 } else {
1603 m_eclClusterToMCWeight2->push_back(-1);
1604 m_eclClusterToMC2->push_back(-1);
1605 m_eclClusterToMC2PDG->push_back(-1);
1606 }
1607 if (idx[2] > -1) {
1608 m_eclClusterToMCWeight3->push_back(wi[2]);
1609 m_eclClusterToMC3->push_back(idx[2]);
1610 const MCParticle* amcParticle = m_mcParticles[idx[2]];
1611 m_eclClusterToMC3PDG->push_back(amcParticle->getPDG());
1612 } else {
1613 m_eclClusterToMCWeight3->push_back(-1);
1614 m_eclClusterToMC3->push_back(-1);
1615 m_eclClusterToMC3PDG->push_back(-1);
1616 }
1617 if (idx[3] > -1) {
1618 m_eclClusterToMCWeight4->push_back(wi[3]);
1619 m_eclClusterToMC4->push_back(idx[3]);
1620 const MCParticle* amcParticle = m_mcParticles[idx[3]];
1621 m_eclClusterToMC4PDG->push_back(amcParticle->getPDG());
1622 } else {
1623 m_eclClusterToMCWeight4->push_back(-1);
1624 m_eclClusterToMC4->push_back(-1);
1625 m_eclClusterToMC4PDG->push_back(-1);
1626 }
1627 if (idx[4] > -1) {
1628 m_eclClusterToMCWeight5->push_back(wi[4]);
1629 m_eclClusterToMC5->push_back(idx[4]);
1630 const MCParticle* amcParticle = m_mcParticles[idx[4]];
1631 m_eclClusterToMC5PDG->push_back(amcParticle->getPDG());
1632 } else {
1633 m_eclClusterToMCWeight5->push_back(-1);
1634 m_eclClusterToMC5->push_back(-1);
1635 m_eclClusterToMC5PDG->push_back(-1);
1636 }
1637
1638 }
1639
1640 if (m_doPureCsI == true) {
1641
1642 m_eclPureDigitMultip = m_eclPureDigits.getEntries();
1643 for (int idigits = 0; idigits < m_eclPureDigits.getEntries() ; idigits++) {
1644 ECLDigit* aECLPureDigits = m_eclPureDigits[idigits];
1645
1646 m_eclPureDigitIdx->push_back(idigits);
1647 m_eclPureDigitCellId->push_back(aECLPureDigits->getCellId());
1648 m_eclPureDigitAmp->push_back(aECLPureDigits->getAmp());
1649 m_eclPureDigitTimeFit->push_back(aECLPureDigits->getTimeFit());
1650 m_eclPureDigitFitQuality->push_back(aECLPureDigits->getQuality());
1651
1652 if (aECLPureDigits->getRelated<MCParticle>() != (nullptr)) {
1653 const MCParticle* mc_digit = aECLPureDigits->getRelated<MCParticle>();
1654 m_eclPureDigitToMC->push_back(mc_digit->getArrayIndex());
1655 } else
1656 m_eclPureDigitToMC->push_back(-1);
1657 }
1658
1659 //PURE CAL DIGITS
1660 m_eclPureCalDigitMultip = m_eclPureCalDigits.getEntries();
1661 for (uint icaldigits = 0; icaldigits < (uint)m_eclPureCalDigits.getEntries() ; icaldigits++) {
1662 ECLCalDigit* aECLPureCalDigits = m_eclPureCalDigits[icaldigits];
1663
1664 m_eclPureCalDigitIdx->push_back(icaldigits);
1665 m_eclPureCalDigitCellId->push_back(aECLPureCalDigits->getCellId());
1666 m_eclPureCalDigitAmp->push_back(aECLPureCalDigits->getEnergy());
1667 m_eclPureCalDigitTimeFit->push_back(aECLPureCalDigits->getTime());
1668 m_eclPureCalDigitFitQuality->push_back(aECLPureCalDigits->isFailedFit());
1669
1670 double sumHit = 0;
1671 int idx[10];
1672 for (int i = 0; i < 10; i++)
1673 idx[i] = -1;
1674
1675 double wi[10];
1676 for (int i = 0; i < 10; i++)
1677 wi[i] = -1;
1678
1679 int ii = 0;
1680 sumHit = 0;
1681
1682 auto digitMCRelations = aECLPureCalDigits->getRelationsTo<MCParticle>();
1683 for (unsigned int i = 0; i < digitMCRelations.size(); ++i) {
1684 if (ii < 10) {
1685 const auto mcParticle = digitMCRelations.object(i);
1686 idx[ii] = mcParticle->getIndex() - 1;
1687 wi[ii] = digitMCRelations.weight(i);
1688 sumHit = sumHit + digitMCRelations.weight(i);
1689 ii++;
1690 }
1691 }
1692
1693 //Re-ordering based on contribution
1694 int y = 0;
1695 while (y < 10) {
1696 for (int i = 0; i < 9; i++) {
1697 if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1698 if (wi[i] < wi[i + 1]) {
1699 int temp = idx[i];
1700 idx[i] = idx[i + 1];
1701 idx[i + 1] = temp;
1702
1703 double wtemp = wi[i];
1704 wi[i] = wi[i + 1];
1705 wi[i + 1] = wtemp;
1706 }
1707 }
1708 }
1709 y++;
1710 }
1711
1712 m_eclPureCalDigitToBkgWeight->push_back(aECLPureCalDigits->getEnergy() - sumHit);
1713 m_eclPureCalDigitSimHitSum->push_back(sumHit);
1714 if (idx[0] > -1) {
1715 m_eclPureCalDigitToMCWeight1->push_back(wi[0]);
1716 m_eclPureCalDigitToMC1->push_back(idx[0]);
1717 const MCParticle* amcParticle = m_mcParticles[idx[0]];
1718 m_eclPureCalDigitToMC1PDG->push_back(amcParticle->getPDG());
1719 } else {
1720 m_eclPureCalDigitToMCWeight1->push_back(-1);
1721 m_eclPureCalDigitToMC1->push_back(-1);
1722 m_eclPureCalDigitToMC1PDG->push_back(-1);
1723 }
1724 if (idx[1] > -1) {
1725 m_eclPureCalDigitToMCWeight2->push_back(wi[1]);
1726 m_eclPureCalDigitToMC2->push_back(idx[1]);
1727 const MCParticle* amcParticle = m_mcParticles[idx[1]];
1728 m_eclPureCalDigitToMC2PDG->push_back(amcParticle->getPDG());
1729 } else {
1730 m_eclPureCalDigitToMCWeight2->push_back(-1);
1731 m_eclPureCalDigitToMC2->push_back(-1);
1732 m_eclPureCalDigitToMC2PDG->push_back(-1);
1733 }
1734 if (idx[2] > -1) {
1735 m_eclPureCalDigitToMCWeight3->push_back(wi[2]);
1736 m_eclPureCalDigitToMC3->push_back(idx[2]);
1737 const MCParticle* amcParticle = m_mcParticles[idx[2]];
1738 m_eclPureCalDigitToMC3PDG->push_back(amcParticle->getPDG());
1739 } else {
1740 m_eclPureCalDigitToMCWeight3->push_back(-1);
1741 m_eclPureCalDigitToMC3->push_back(-1);
1742 m_eclPureCalDigitToMC3PDG->push_back(-1);
1743 }
1744 if (idx[3] > -1) {
1745 m_eclPureCalDigitToMCWeight4->push_back(wi[3]);
1746 m_eclPureCalDigitToMC4->push_back(idx[3]);
1747 const MCParticle* amcParticle = m_mcParticles[idx[3]];
1748 m_eclPureCalDigitToMC4PDG->push_back(amcParticle->getPDG());
1749 } else {
1750 m_eclPureCalDigitToMCWeight4->push_back(-1);
1751 m_eclPureCalDigitToMC4->push_back(-1);
1752 m_eclPureCalDigitToMC4PDG->push_back(-1);
1753 }
1754 if (idx[4] > -1) {
1755 m_eclPureCalDigitToMCWeight5->push_back(wi[4]);
1756 m_eclPureCalDigitToMC5->push_back(idx[4]);
1757 const MCParticle* amcParticle = m_mcParticles[idx[4]];
1758 m_eclPureCalDigitToMC5PDG->push_back(amcParticle->getPDG());
1759 } else {
1760 m_eclPureCalDigitToMCWeight5->push_back(-1);
1761 m_eclPureCalDigitToMC5->push_back(-1);
1762 m_eclPureCalDigitToMC5PDG->push_back(-1);
1763 }
1764
1765 if (aECLPureCalDigits->getRelated<ECLShower>() != (nullptr)) {
1766 const ECLShower* shower_caldigit = aECLPureCalDigits->getRelated<ECLShower>();
1767 m_eclPureCalDigitToShower->push_back(shower_caldigit->getArrayIndex());
1768 } else
1769 m_eclPureCalDigitToShower->push_back(-1);
1770
1771 if (aECLPureCalDigits->getRelated<ECLConnectedRegion>(eclPureConnectedRegionArrayName()) != (nullptr)) {
1772 const ECLConnectedRegion* cr_caldigit = aECLPureCalDigits->getRelated<ECLConnectedRegion>(eclPureConnectedRegionArrayName());
1773 m_eclPureCalDigitToCR->push_back(cr_caldigit->getCRId());
1774 } else
1775 m_eclPureCalDigitToCR->push_back(-1);
1776
1777 if (aECLPureCalDigits->getRelated<ECLLocalMaximum>(eclPureLocalMaximumArrayName()) != (nullptr)) {
1778 const ECLLocalMaximum* lm_caldigit = aECLPureCalDigits->getRelated<ECLLocalMaximum>(eclPureLocalMaximumArrayName());
1779 m_eclPureCalDigitToLM->push_back(lm_caldigit->getLMId());
1780 } else
1781 m_eclPureCalDigitToLM->push_back(-1);
1782
1783 }
1784
1785 //CR
1786 int PureCRmultip = m_eclPureConnectedRegions.getEntries();
1787 for (int i = 0; i < PureCRmultip; i++) {
1788 const ECLConnectedRegion* aECLPureCR = m_eclPureConnectedRegions[i];
1789 m_eclPureCRIdx->push_back(aECLPureCR->getCRId());
1790 m_eclPureCRIsTrack->push_back(aECLPureCR->isTrack());
1791 m_eclPureCRLikelihoodMIPNGamma->push_back(aECLPureCR->getLikelihoodMIPNGamma());
1792 m_eclPureCRLikelihoodChargedHadron->push_back(aECLPureCR->getLikelihoodChargedHadron());
1793 m_eclPureCRLikelihoodElectronNGamma->push_back(aECLPureCR->getLikelihoodElectronNGamma());
1794 m_eclPureCRLikelihoodNGamma->push_back(aECLPureCR->getLikelihoodNGamma());
1795 m_eclPureCRLikelihoodNeutralHadron->push_back(aECLPureCR->getLikelihoodNeutralHadron());
1796 m_eclPureCRLikelihoodMergedPi0->push_back(aECLPureCR->getLikelihoodMergedPi0());
1797 }
1798
1799 //LM
1800 m_eclPureLMMultip = m_eclPureLocalMaximums.getEntries();
1801 for (unsigned int pure_ilms = 0; pure_ilms < (unsigned int)m_eclPureLocalMaximums.getEntries() ; pure_ilms++) {
1802 const ECLLocalMaximum* aECLLMs = m_eclPureLocalMaximums[pure_ilms];
1803 m_eclPureLMId->push_back(aECLLMs->getLMId());
1804 m_eclPureLMType->push_back(aECLLMs->getType());
1805 m_eclPureLMCellId->push_back(aECLLMs->getCellId());
1806 }
1807
1808 m_eclPureClusterMultip = m_eclPureClusters.getEntries();
1809 for (unsigned int iclusters = 0; iclusters < (unsigned int)m_eclPureClusters.getEntries() ; iclusters++) {
1810 ECLCluster* aECLClusters = m_eclPureClusters[iclusters];
1811 m_eclPureClusterIdx->push_back(iclusters);
1812
1813 double clusterE = 0.0;
1814 if (aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons)) clusterE = aECLClusters->getEnergy(
1815 ECLCluster::EHypothesisBit::c_nPhotons);
1816 else clusterE = aECLClusters->getEnergy(ECLCluster::EHypothesisBit::c_neutralHadron);
1817 m_eclPureClusterEnergy->push_back(clusterE);
1818
1819 m_eclPureClusterEnergyError->push_back(aECLClusters->getUncertaintyEnergy());
1820 m_eclPureClusterTheta->push_back(aECLClusters->getTheta());
1821 m_eclPureClusterThetaError->push_back(aECLClusters->getUncertaintyTheta());
1822 m_eclPureClusterPhi->push_back(aECLClusters->getPhi());
1823 m_eclPureClusterPhiError->push_back(aECLClusters->getUncertaintyPhi());
1824 m_eclPureClusterR->push_back(aECLClusters->getR());
1825 m_eclPureClusterEnergyDepSum->push_back(aECLClusters->getEnergyRaw());
1826 m_eclPureClusterTiming->push_back(aECLClusters->getTime());
1827 m_eclPureClusterTimingError->push_back(aECLClusters->getDeltaTime99());
1828 m_eclPureClusterE9oE21->push_back(aECLClusters->getE9oE21());
1829 m_eclPureClusterHighestE->push_back(aECLClusters->getEnergyHighestCrystal());
1830 m_eclPureClusterCellId->push_back(aECLClusters->getMaxECellId());
1831 m_eclPureClusterLat->push_back(aECLClusters->getLAT());
1832 m_eclPureClusterNofCrystals->push_back(aECLClusters->getNumberOfCrystals());
1833 m_eclPureClusterCrystalHealth->push_back(aECLClusters->getStatus());
1834
1835 m_eclPureClusterClosestTrackDist->push_back(aECLClusters->getMinTrkDistance());
1836 m_eclPureClusterAbsZernike40->push_back(aECLClusters->getAbsZernike40());
1837 m_eclPureClusterAbsZernike51->push_back(aECLClusters->getAbsZernike51());
1838 m_eclPureClusterZernikeMVA->push_back(aECLClusters->getZernikeMVA());
1839 m_eclPureClusterSecondMoment->push_back(aECLClusters->getSecondMoment());
1840
1841 m_eclPureClusterIsTrack->push_back(aECLClusters->isTrack());
1842 m_eclPureClusterDeltaL->push_back(aECLClusters->getDeltaL());
1843
1844 m_eclPureClusterE1oE9->push_back(aECLClusters->getE1oE9());
1845 m_eclPureClusterDeltaTime99->push_back(aECLClusters->getDeltaTime99());
1846 m_eclPureClusterDetectorRegion->push_back(aECLClusters->getDetectorRegion());
1847 m_eclPureClusterHasNPhotonHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_nPhotons));
1848 m_eclPureClusterHasNeutralHadronHypothesis->push_back(aECLClusters->hasHypothesis(ECLCluster::EHypothesisBit::c_neutralHadron));
1849
1850 //Dump MC Info - Multiple Matching
1851 double sumHit = 0;
1852 int idx[10];
1853 for (int i = 0; i < 10; i++)
1854 idx[i] = -1;
1855
1856 double wi[10];
1857 for (int i = 0; i < 10; i++)
1858 wi[i] = -1;
1859
1860 int ii = 0;
1861 sumHit = 0;
1862
1863 auto clusterMCRelations = aECLClusters->getRelationsTo<MCParticle>();
1864 for (unsigned int i = 0; i < clusterMCRelations.size(); ++i) {
1865 if (ii < 10) {
1866 const auto mcParticle = clusterMCRelations.object(i);
1867 idx[ii] = mcParticle->getIndex() - 1;
1868 wi[ii] = clusterMCRelations.weight(i);
1869 sumHit = sumHit + clusterMCRelations.weight(i);
1870 ii++;
1871 }
1872 }
1873
1874 //Re-ordering based on contribution
1875 int y = 0;
1876 while (y < 10) {
1877 for (int i = 0; i < 9; i++) {
1878 if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
1879 if (wi[i] < wi[i + 1]) {
1880 int temp = idx[i];
1881 idx[i] = idx[i + 1];
1882 idx[i + 1] = temp;
1883
1884 double wtemp = wi[i];
1885 wi[i] = wi[i + 1];
1886 wi[i + 1] = wtemp;
1887 }
1888 }
1889 }
1890 y++;
1891 }
1892
1893 m_eclPureClusterToBkgWeight->push_back(clusterE - sumHit);
1894 if (idx[0] > -1) {
1895 m_eclPureClusterToMCWeight1->push_back(wi[0]);
1896 m_eclPureClusterToMC1->push_back(idx[0]);
1897 const MCParticle* amcParticle = m_mcParticles[idx[0]];
1898 m_eclPureClusterToMC1PDG->push_back(amcParticle->getPDG());
1899 } else {
1900 m_eclPureClusterToMCWeight1->push_back(-1);
1901 m_eclPureClusterToMC1->push_back(-1);
1902 m_eclPureClusterToMC1PDG->push_back(-1);
1903 }
1904 if (idx[1] > -1) {
1905 m_eclPureClusterToMCWeight2->push_back(wi[1]);
1906 m_eclPureClusterToMC2->push_back(idx[1]);
1907 const MCParticle* amcParticle = m_mcParticles[idx[1]];
1908 m_eclPureClusterToMC2PDG->push_back(amcParticle->getPDG());
1909 } else {
1910 m_eclPureClusterToMCWeight2->push_back(-1);
1911 m_eclPureClusterToMC2->push_back(-1);
1912 m_eclPureClusterToMC2PDG->push_back(-1);
1913 }
1914 if (idx[2] > -1) {
1915 m_eclPureClusterToMCWeight3->push_back(wi[2]);
1916 m_eclPureClusterToMC3->push_back(idx[2]);
1917 const MCParticle* amcParticle = m_mcParticles[idx[2]];
1918 m_eclPureClusterToMC3PDG->push_back(amcParticle->getPDG());
1919 } else {
1920 m_eclPureClusterToMCWeight3->push_back(-1);
1921 m_eclPureClusterToMC3->push_back(-1);
1922 m_eclPureClusterToMC3PDG->push_back(-1);
1923 }
1924 if (idx[3] > -1) {
1925 m_eclPureClusterToMCWeight4->push_back(wi[3]);
1926 m_eclPureClusterToMC4->push_back(idx[3]);
1927 const MCParticle* amcParticle = m_mcParticles[idx[3]];
1928 m_eclPureClusterToMC4PDG->push_back(amcParticle->getPDG());
1929 } else {
1930 m_eclPureClusterToMCWeight4->push_back(-1);
1931 m_eclPureClusterToMC4->push_back(-1);
1932 m_eclPureClusterToMC4PDG->push_back(-1);
1933 }
1934 if (idx[4] > -1) {
1935 m_eclPureClusterToMCWeight5->push_back(wi[4]);
1936 m_eclPureClusterToMC5->push_back(idx[4]);
1937 const MCParticle* amcParticle = m_mcParticles[idx[4]];
1938 m_eclPureClusterToMC5PDG->push_back(amcParticle->getPDG());
1939 } else {
1940 m_eclPureClusterToMCWeight5->push_back(-1);
1941 m_eclPureClusterToMC5->push_back(-1);
1942 m_eclPureClusterToMC5PDG->push_back(-1);
1943 }
1944
1945 }
1946 }
1947
1948 m_eclShowerMultip = m_eclShowers.getEntries();
1949 for (uint ishowers = 0; ishowers < (uint)m_eclShowers.getEntries() ; ishowers++) {
1950 ECLShower* aECLShowers = m_eclShowers[ishowers];
1951 m_eclShowerIdx->push_back(ishowers);
1952 m_eclShowerEnergy->push_back(aECLShowers->getEnergy());
1953 m_eclShowerTheta->push_back(aECLShowers->getTheta());
1954 m_eclShowerPhi->push_back(aECLShowers->getPhi());
1955 m_eclShowerR->push_back(aECLShowers->getR());
1956 m_eclShowerNHits->push_back(aECLShowers->getNumberOfCrystals());
1957 m_eclShowerE9oE21->push_back(aECLShowers->getE9oE21());
1958 m_eclShowerUncEnergy->push_back(aECLShowers->getEnergyRaw());
1959 m_eclShowerTime->push_back(aECLShowers->getTime());
1960 m_eclShowerT99->push_back(aECLShowers->getDeltaTime99());
1961 m_eclShowerConnectedRegionId->push_back(aECLShowers->getConnectedRegionId());
1962 m_eclShowerHypothesisId->push_back(aECLShowers->getHypothesisId());
1963 m_eclShowerCentralCellId->push_back(aECLShowers->getCentralCellId());
1964 m_eclShowerEnergyError->push_back(aECLShowers->getUncertaintyEnergy());
1965 m_eclShowerThetaError->push_back(aECLShowers->getUncertaintyTheta());
1966 m_eclShowerPhiError->push_back(aECLShowers->getUncertaintyPhi());
1967 m_eclShowerTimeResolution->push_back(aECLShowers->getDeltaTime99());
1968 m_eclShowerHighestEnergy->push_back(aECLShowers->getEnergyHighestCrystal());
1969 m_eclShowerLateralEnergy->push_back(aECLShowers->getLateralEnergy());
1970 m_eclShowerMinTrkDistance->push_back(aECLShowers->getMinTrkDistance());
1971 m_eclShowerTrkDepth->push_back(aECLShowers->getTrkDepth());
1972 m_eclShowerShowerDepth->push_back(aECLShowers->getShowerDepth());
1973 m_eclShowerAbsZernike40->push_back(aECLShowers->getAbsZernikeMoment(4, 0));
1974 m_eclShowerAbsZernike51->push_back(aECLShowers->getAbsZernikeMoment(5, 1));
1975 m_eclShowerZernikeMVA->push_back(aECLShowers->getZernikeMVA());
1976 m_eclShowerSecondMoment->push_back(aECLShowers->getSecondMoment());
1977 m_eclShowerE1oE9->push_back(aECLShowers->getE1oE9());
1978 m_eclShowerIsTrack->push_back(aECLShowers->getIsTrack());
1979 m_eclShowerNumberOfCrystalsForEnergy->push_back(aECLShowers->getNumberOfCrystalsForEnergy());
1980
1981 double fe = 0.;
1982 double se = 0.;
1983
1984 auto showerDigitRelations = aECLShowers->getRelationsTo<ECLCalDigit>();
1985 for (unsigned int i = 0; i < showerDigitRelations.size(); ++i) {
1986 const auto aECLCalDigits = showerDigitRelations.object(i);
1987 if (aECLCalDigits->getEnergy() > fe) {
1988 se = fe;
1989 fe = aECLCalDigits->getEnergy();
1990 }
1991 }
1992 if (fe > 0 && se > 0)
1993 m_eclShowerHighestE1mE2->push_back(fe - se);
1994 else
1995 m_eclShowerHighestE1mE2->push_back(-1);
1996
1997 int lm1[5] = { -1, -1, -1, -1, -1};
1998
1999 auto showerLMRelations = aECLShowers->getRelationsTo<ECLLocalMaximum>();
2000 for (unsigned int i = 0; i < showerLMRelations.size(); ++i) {
2001 const auto aECLLM = showerLMRelations.object(i);
2002 lm1[i] = aECLLM->getLMId();
2003 }
2004 m_eclShowerToLM1->push_back(lm1[0]);
2005 m_eclShowerToLM2->push_back(lm1[1]);
2006 m_eclShowerToLM3->push_back(lm1[2]);
2007 m_eclShowerToLM4->push_back(lm1[3]);
2008 m_eclShowerToLM5->push_back(lm1[4]);
2009
2010 double sumHit = 0;
2011
2012 int idx[10];
2013 for (int i = 0; i < 10; i++)
2014 idx[i] = -1;
2015
2016 double wi[10];
2017 for (int i = 0; i < 10; i++)
2018 wi[i] = -1;
2019
2020 int ii = 0;
2021 sumHit = 0;
2022
2023 auto showerMCRelations = aECLShowers->getRelationsTo<MCParticle>();
2024 for (unsigned int i = 0; i < showerMCRelations.size(); ++i) {
2025 if (ii < 10) {
2026 const auto mcParticle = showerMCRelations.object(i);
2027 idx[ii] = mcParticle->getIndex() - 1;
2028 wi[ii] = showerMCRelations.weight(i);
2029 sumHit = sumHit + showerMCRelations.weight(i);
2030 ii++;
2031 }
2032 }
2033
2034 //Re-ordering based on contribution
2035 int y = 0;
2036 while (y < 10) {
2037 for (int i = 0; i < 9; i++) {
2038 if (((idx[i]) > -1) && ((idx[i + 1]) > -1)) {
2039 if (wi[i] < wi[i + 1]) {
2040 int temp = idx[i];
2041 idx[i] = idx[i + 1];
2042 idx[i + 1] = temp;
2043
2044 double wtemp = wi[i];
2045 wi[i] = wi[i + 1];
2046 wi[i + 1] = wtemp;
2047 }
2048 }
2049 }
2050 y++;
2051 }
2052
2053 int no_Primary = 1;
2054
2055 for (unsigned int i = 0; i < showerMCRelations.size(); ++i) {
2056 const auto mcParticle = showerMCRelations.object(i);
2057 if (mcParticle->getSecondaryPhysicsProcess() == 0 && mcParticle->getPDG() == Const::Klong.getPDGCode()) {
2058 double vtxx = mcParticle->getDecayVertex().X();
2059 double vtxy = mcParticle->getDecayVertex().Y();
2060 double vtxz = mcParticle->getDecayVertex().Z();
2061 if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16))
2062 no_Primary = 0;
2063 } else if (mcParticle->getSecondaryPhysicsProcess() != 0 && mcParticle->getMother()->getPDG() == Const::Klong.getPDGCode()) {
2064 double vtxx = mcParticle->getProductionVertex().X();
2065 double vtxy = mcParticle->getProductionVertex().Y();
2066 double vtxz = mcParticle->getProductionVertex().Z();
2067 if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16))
2068 no_Primary = 0;
2069 }
2070 }
2071
2072 if (no_Primary == 0)
2073 m_eclShowerMCVtxInEcl->push_back(1);
2074 else
2075 m_eclShowerMCVtxInEcl->push_back(0);
2076
2077 double no_fMatch = 0;
2078 double no_fFMatch = 0;
2079
2080 for (unsigned int i = 0; i < showerMCRelations.size(); ++i) {
2081 const auto mcParticle = showerMCRelations.object(i);
2082 if (mcParticle->getSecondaryPhysicsProcess() == 0) {
2083 double vtxx = mcParticle->getDecayVertex().X();
2084 double vtxy = mcParticle->getDecayVertex().Y();
2085 double vtxz = mcParticle->getDecayVertex().Z();
2086 double px = mcParticle->getMomentum().X();
2087 double py = mcParticle->getMomentum().Y();
2088 double pz = mcParticle->getMomentum().Z();
2089 double p = TMath::Sqrt(px * px + py * py + pz * pz);
2090 double pTheta = TMath::ACos(pz / p);
2091 double pPhi = 10.;
2092 if (py > 0) {
2093 if (px > 0)
2094 pPhi = TMath::ATan(py / px);
2095 if (px < 0)
2096 pPhi = TMath::ATan(py / px) + M_PI;
2097 } else {
2098 if (px > 0)
2099 pPhi = TMath::ATan(py / px) ;
2100 if (px < 0)
2101 pPhi = TMath::ATan(py / px) - M_PI;
2102 }
2103 if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16)) {
2104 if (TMath::Abs(aECLShowers->getTheta() - pTheta) < 0.05 && TMath::Abs(aECLShowers->getPhi() - pPhi) < 0.05)
2105 no_fMatch = 1;
2106 no_fFMatch = 1;
2107 }
2108 } else if (mcParticle->getMother()->getPDG() == Const::Klong.getPDGCode()) {
2109 double vtxx = mcParticle->getProductionVertex().X();
2110 double vtxy = mcParticle->getProductionVertex().Y();
2111 double vtxz = mcParticle->getProductionVertex().Z();
2112 const MCParticle* amcParticle = mcParticle->getMother();
2113 double px = amcParticle->getMomentum().X();
2114 double py = amcParticle->getMomentum().Y();
2115 double pz = amcParticle->getMomentum().Z();
2116 double p = TMath::Sqrt(px * px + py * py + pz * pz);
2117 double pTheta = TMath::ACos(pz / p);
2118 double pPhi = 10.;
2119 if (py > 0) {
2120 if (px > 0)
2121 pPhi = TMath::ATan(py / px);
2122 if (px < 0)
2123 pPhi = TMath::ATan(py / px) + M_PI;
2124 } else {
2125 if (px > 0)
2126 pPhi = TMath::ATan(py / px) ;
2127 if (px < 0)
2128 pPhi = TMath::ATan(py / px) - M_PI;
2129 }
2130 if ((TMath::Sqrt(vtxx * vtxx + vtxy * vtxy) > 118) || (vtxz > 196.16) || (vtxz < -102.16)) {
2131 if (TMath::Abs(aECLShowers->getTheta() - pTheta) < 0.05 && TMath::Abs(aECLShowers->getPhi() - pPhi) < 0.05)
2132 no_fMatch = 1;
2133 }
2134 }
2135 }
2136
2137 if (no_fMatch == 1)
2138 m_eclShowerMCFlightMatch->push_back(1);
2139 else
2140 m_eclShowerMCFlightMatch->push_back(0);
2141
2142 if (no_fFMatch == 1)
2143 m_eclShowerMCFFlightMatch->push_back(1);
2144 else
2145 m_eclShowerMCFFlightMatch->push_back(0);
2146
2147 if (idx[0] > -1) {
2148 m_eclShowerToMCWeight1->push_back(wi[0]);
2149 m_eclShowerToMC1->push_back(idx[0]);
2150 const MCParticle* amcParticle = m_mcParticles[idx[0]];
2151 m_eclShowerToMC1PDG->push_back(amcParticle->getPDG());
2152 if (amcParticle->getMother() != nullptr) {
2153 m_eclShowerToMC1Moth->push_back(amcParticle->getMother()->getIndex());
2154 m_eclShowerToMC1MothPDG->push_back(amcParticle->getMother()->getPDG());
2155 if (amcParticle->getMother()->getMother() != nullptr) {
2156 m_eclShowerToMC1GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2157 m_eclShowerToMC1GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2158 } else {
2159 m_eclShowerToMC1GMoth->push_back(-999);
2160 m_eclShowerToMC1GMothPDG->push_back(-999);
2161 }
2162 } else {
2163 m_eclShowerToMC1Moth->push_back(-999);
2164 m_eclShowerToMC1MothPDG->push_back(-999);
2165 m_eclShowerToMC1GMoth->push_back(-999);
2166 m_eclShowerToMC1GMothPDG->push_back(-999);
2167 }
2168 } else {
2169 m_eclShowerToMCWeight1->push_back(-1);
2170 m_eclShowerToMC1->push_back(-1);
2171 m_eclShowerToMC1PDG->push_back(-1);
2172 m_eclShowerToMC1Moth->push_back(-1);
2173 m_eclShowerToMC1MothPDG->push_back(-1);
2174 m_eclShowerToMC1GMoth->push_back(-1);
2175 m_eclShowerToMC1GMothPDG->push_back(-1);
2176 }
2177 if (idx[1] > -1) {
2178 m_eclShowerToMCWeight2->push_back(wi[1]);
2179 m_eclShowerToMC2->push_back(idx[1]);
2180 const MCParticle* amcParticle = m_mcParticles[idx[1]];
2181 m_eclShowerToMC2PDG->push_back(amcParticle->getPDG());
2182 if (amcParticle->getMother() != nullptr) {
2183 m_eclShowerToMC2Moth->push_back(amcParticle->getMother()->getIndex());
2184 m_eclShowerToMC2MothPDG->push_back(amcParticle->getMother()->getPDG());
2185 if (amcParticle->getMother()->getMother() != nullptr) {
2186 m_eclShowerToMC2GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2187 m_eclShowerToMC2GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2188 } else {
2189 m_eclShowerToMC2GMoth->push_back(-999);
2190 m_eclShowerToMC2GMothPDG->push_back(-999);
2191 }
2192 } else {
2193 m_eclShowerToMC2Moth->push_back(-999);
2194 m_eclShowerToMC2MothPDG->push_back(-999);
2195 m_eclShowerToMC2GMoth->push_back(-999);
2196 m_eclShowerToMC2GMothPDG->push_back(-999);
2197 };
2198 } else {
2199 m_eclShowerToMCWeight2->push_back(-1);
2200 m_eclShowerToMC2->push_back(-1);
2201 m_eclShowerToMC2PDG->push_back(-1);
2202 m_eclShowerToMC2Moth->push_back(-1);
2203 m_eclShowerToMC2MothPDG->push_back(-1);
2204 m_eclShowerToMC2GMoth->push_back(-1);
2205 m_eclShowerToMC2GMothPDG->push_back(-1);
2206 }
2207 if (idx[2] > -1) {
2208 m_eclShowerToMCWeight3->push_back(wi[2]);
2209 m_eclShowerToMC3->push_back(idx[2]);
2210 const MCParticle* amcParticle = m_mcParticles[idx[2]];
2211 m_eclShowerToMC3PDG->push_back(amcParticle->getPDG());
2212 if (amcParticle->getMother() != nullptr) {
2213 m_eclShowerToMC3Moth->push_back(amcParticle->getMother()->getIndex());
2214 m_eclShowerToMC3MothPDG->push_back(amcParticle->getMother()->getPDG());
2215 if (amcParticle->getMother()->getMother() != nullptr) {
2216 m_eclShowerToMC3GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2217 m_eclShowerToMC3GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2218 } else {
2219 m_eclShowerToMC3GMoth->push_back(-999);
2220 m_eclShowerToMC3GMothPDG->push_back(-999);
2221 }
2222 } else {
2223 m_eclShowerToMC3Moth->push_back(-999);
2224 m_eclShowerToMC3MothPDG->push_back(-999);
2225 m_eclShowerToMC3GMoth->push_back(-999);
2226 m_eclShowerToMC3GMothPDG->push_back(-999);
2227 }
2228 } else {
2229 m_eclShowerToMCWeight3->push_back(-1);
2230 m_eclShowerToMC3->push_back(-1);
2231 m_eclShowerToMC3PDG->push_back(-1);
2232 m_eclShowerToMC3Moth->push_back(-1);
2233 m_eclShowerToMC3MothPDG->push_back(-1);
2234 m_eclShowerToMC3GMoth->push_back(-1);
2235 m_eclShowerToMC3GMothPDG->push_back(-1);
2236 }
2237 if (idx[3] > -1) {
2238 m_eclShowerToMCWeight4->push_back(wi[3]);
2239 m_eclShowerToMC4->push_back(idx[3]);
2240 const MCParticle* amcParticle = m_mcParticles[idx[3]];
2241 m_eclShowerToMC4PDG->push_back(amcParticle->getPDG());
2242 if (amcParticle->getMother() != nullptr) {
2243 m_eclShowerToMC4Moth->push_back(amcParticle->getMother()->getIndex());
2244 m_eclShowerToMC4MothPDG->push_back(amcParticle->getMother()->getPDG());
2245 if (amcParticle->getMother()->getMother() != nullptr) {
2246 m_eclShowerToMC4GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2247 m_eclShowerToMC4GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2248 } else {
2249 m_eclShowerToMC4GMoth->push_back(-999);
2250 m_eclShowerToMC4GMothPDG->push_back(-999);
2251 }
2252 } else {
2253 m_eclShowerToMC4Moth->push_back(-999);
2254 m_eclShowerToMC4MothPDG->push_back(-999);
2255 m_eclShowerToMC4GMoth->push_back(-999);
2256 m_eclShowerToMC4GMothPDG->push_back(-999);
2257 }
2258 } else {
2259 m_eclShowerToMCWeight4->push_back(-1);
2260 m_eclShowerToMC4->push_back(-1);
2261 m_eclShowerToMC4PDG->push_back(-1);
2262 m_eclShowerToMC4Moth->push_back(-1);
2263 m_eclShowerToMC4MothPDG->push_back(-1);
2264 m_eclShowerToMC4GMoth->push_back(-1);
2265 m_eclShowerToMC4GMothPDG->push_back(-1);
2266 }
2267 if (idx[4] > -1) {
2268 m_eclShowerToMCWeight5->push_back(wi[4]);
2269 m_eclShowerToMC5->push_back(idx[4]);
2270 const MCParticle* amcParticle = m_mcParticles[idx[4]];
2271 m_eclShowerToMC5PDG->push_back(amcParticle->getPDG());
2272 if (amcParticle->getMother() != nullptr) {
2273 m_eclShowerToMC5Moth->push_back(amcParticle->getMother()->getIndex());
2274 m_eclShowerToMC5MothPDG->push_back(amcParticle->getMother()->getPDG());
2275 if (amcParticle->getMother()->getMother() != nullptr) {
2276 m_eclShowerToMC5GMoth->push_back(amcParticle->getMother()->getMother()->getIndex());
2277 m_eclShowerToMC5GMothPDG->push_back(amcParticle->getMother()->getMother()->getPDG());
2278 } else {
2279 m_eclShowerToMC5GMoth->push_back(-999);
2280 m_eclShowerToMC5GMothPDG->push_back(-999);
2281 }
2282 } else {
2283 m_eclShowerToMC5Moth->push_back(-999);
2284 m_eclShowerToMC5MothPDG->push_back(-999);
2285 m_eclShowerToMC5GMoth->push_back(-999);
2286 m_eclShowerToMC5GMothPDG->push_back(-999);
2287 }
2288 } else {
2289 m_eclShowerToMCWeight5->push_back(-1);
2290 m_eclShowerToMC5->push_back(-1);
2291 m_eclShowerToMC5PDG->push_back(-1);
2292 m_eclShowerToMC5Moth->push_back(-1);
2293 m_eclShowerToMC5MothPDG->push_back(-1);
2294 m_eclShowerToMC5GMoth->push_back(-1);
2295 m_eclShowerToMC5GMothPDG->push_back(-1);
2296 }
2297 m_eclShowerToBkgWeight->push_back(aECLShowers->getEnergy() - sumHit);
2298 }
2299
2300 m_mcMultip = m_mcParticles.getEntries();
2301 for (int imcpart = 0; imcpart < m_mcParticles.getEntries(); imcpart++) {
2302 const MCParticle* amcParticle = m_mcParticles[imcpart];
2303 m_mcIdx->push_back(amcParticle->getArrayIndex());
2304 m_mcPdg->push_back(amcParticle->getPDG());
2305 if (amcParticle->getMother() != nullptr) m_mcMothPdg->push_back(amcParticle->getMother()->getPDG());
2306 else m_mcMothPdg->push_back(-999);
2307 if (amcParticle->getMother() != nullptr
2308 && amcParticle->getMother()->getMother() != nullptr) m_mcGMothPdg->push_back(amcParticle->getMother()->getMother()->getPDG());
2309 else m_mcGMothPdg->push_back(-999);
2310 if (amcParticle->getMother() != nullptr && amcParticle->getMother()->getMother() != nullptr
2311 && amcParticle->getMother()->getMother()->getMother() != nullptr)
2312 m_mcGGMothPdg->push_back(amcParticle->getMother()->getMother()->getMother()->getPDG());
2313 else m_mcGGMothPdg->push_back(-999);
2314 m_mcEnergy->push_back(amcParticle->getEnergy());
2315 m_mcSecondaryPhysProc->push_back(amcParticle->getSecondaryPhysicsProcess());
2316
2317 m_mcPx->push_back(amcParticle->getMomentum().X());
2318 m_mcPy->push_back(amcParticle->getMomentum().Y());
2319 m_mcPz->push_back(amcParticle->getMomentum().Z());
2320
2321 m_mcDecayVtxX->push_back(amcParticle->getDecayVertex().X());
2322 m_mcDecayVtxY->push_back(amcParticle->getDecayVertex().Y());
2323 m_mcDecayVtxZ->push_back(amcParticle->getDecayVertex().Z());
2324
2325 m_mcProdVtxX->push_back(amcParticle->getProductionVertex().X());
2326 m_mcProdVtxY->push_back(amcParticle->getProductionVertex().Y());
2327 m_mcProdVtxZ->push_back(amcParticle->getProductionVertex().Z());
2328
2329 }
2330
2331 if (m_doTracking == true) {
2332 m_trkMultip = 0;
2333 for (const Track& itrk : m_tracks) {
2334 const TrackFitResult* atrk = itrk.getTrackFitResult(Const::pion);
2335 if (atrk == nullptr) continue;
2336
2337 m_trkIdx->push_back(m_trkMultip);
2338 m_trkPdg->push_back(atrk->getParticleType().getPDGCode());
2339 m_trkCharge->push_back(atrk->getChargeSign());
2340 m_trkPx->push_back(atrk->getMomentum().X());
2341 m_trkPy->push_back(atrk->getMomentum().Y());
2342 m_trkPz->push_back(atrk->getMomentum().Z());
2343 m_trkP->push_back(atrk->getMomentum().R());
2344 m_trkTheta->push_back(atrk->getMomentum().Theta());
2345 m_trkPhi->push_back(atrk->getMomentum().Phi());
2346 m_trkX->push_back(atrk->getPosition().X());
2347 m_trkY->push_back(atrk->getPosition().Y());
2348 m_trkZ->push_back(atrk->getPosition().Z());
2349
2350 const ECLPidLikelihood* eclpid = itrk.getRelatedTo<ECLPidLikelihood>() ;
2351
2352 if (eclpid != nullptr) {
2353 m_eclpidtrkIdx -> push_back(m_trkMultip);
2354 m_eclpidEnergy -> push_back(eclpid-> energy());
2355 m_eclpidEop -> push_back(eclpid-> eop());
2356 m_eclpidE9E21 -> push_back(eclpid-> e9e25());
2357 m_eclpidNCrystals -> push_back(eclpid-> nCrystals());
2358 m_eclpidNClusters -> push_back(eclpid-> nClusters());
2359 m_eclLogLikeEl -> push_back(eclpid-> getLogLikelihood(Const::electron));
2360 m_eclLogLikeMu -> push_back(eclpid-> getLogLikelihood(Const::muon));
2361 m_eclLogLikePi -> push_back(eclpid-> getLogLikelihood(Const::pion));
2362 } else {
2363 m_eclpidtrkIdx -> push_back(m_trkMultip);
2364 m_eclpidEnergy -> push_back(0);
2365 m_eclpidEop -> push_back(0);
2366 m_eclpidE9E21 -> push_back(0);
2367 m_eclpidNCrystals -> push_back(0);
2368 m_eclpidNClusters -> push_back(0);
2369 m_eclLogLikeEl -> push_back(0);
2370 m_eclLogLikeMu -> push_back(0);
2371 m_eclLogLikePi -> push_back(0);
2372 }
2373 m_trkMultip++;
2374 }
2375 }
2376
2377 m_tree->Fill();
2378}
2379
2380void ECLDataAnalysisModule::terminate()
2381{
2382
2383 if (m_rootFilePtr != nullptr) {
2384 m_rootFilePtr->cd();
2385 m_tree->Write();
2386 }
2387
2388}
Belle2::Const::ParticleType::getPDGCode
int getPDGCode() const
PDG code.
Definition Const.h:474
Belle2::Const::muon
static const ChargedStable muon
muon particle
Definition Const.h:661
Belle2::Const::pion
static const ChargedStable pion
charged pion particle
Definition Const.h:662
Belle2::Const::Klong
static const ParticleType Klong
K^0_L particle.
Definition Const.h:679
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition Const.h:660
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:256
Belle2::ECLCluster::isTrack
bool isTrack() const
Return true if the cluster matches with track.
Definition ECLCluster.h:244
Belle2::ECLCluster::hasHypothesis
bool hasHypothesis(EHypothesisBit bitmask) const
Return if specific hypothesis bit is set.
Definition ECLCluster.h:360
Belle2::ECLCluster::getPhi
double getPhi() const
Return Corrected Phi of Shower (radian).
Definition ECLCluster.h:313
Belle2::ECLCluster::getE1oE9
double getE1oE9() const
Return E1/E9 (shower shape variable).
Definition ECLCluster.h:286
Belle2::ECLCluster::getDeltaL
double getDeltaL() const
Return deltaL.
Definition ECLCluster.h:274
Belle2::ECLCluster::getR
double getR() const
Return R.
Definition ECLCluster.h:319
Belle2::ECLCluster::getEnergyRaw
double getEnergyRaw() const
Return Uncorrected Energy deposited (GeV)
Definition ECLCluster.h:325
Belle2::ECLCluster::getUncertaintyTheta
double getUncertaintyTheta() const
Return Uncertainty on Theta of Shower.
Definition ECLCluster.h:334
Belle2::ECLCluster::getLAT
double getLAT() const
Return LAT (shower shape variable).
Definition ECLCluster.h:301
Belle2::ECLCluster::getE9oE21
double getE9oE21() const
Return E9/E21 (shower shape variable).
Definition ECLCluster.h:289
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:250
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:331
Belle2::ECLCluster::getMinTrkDistance
double getMinTrkDistance() const
Get distance between cluster COG and track extrapolation to ECL.
Definition ECLCluster.h:268
Belle2::ECLCluster::getNumberOfCrystals
double getNumberOfCrystals() const
Return number of a crystals in a shower (sum of weights).
Definition ECLCluster.h:304
Belle2::ECLCluster::getEnergyHighestCrystal
double getEnergyHighestCrystal() const
Return energy of highest energetic crystal in cluster (GeV)
Definition ECLCluster.h:328
Belle2::ECLCluster::getZernikeMVA
double getZernikeMVA() const
Return MVA based hadron/photon value based on Zernike moments (shower shape variable).
Definition ECLCluster.h:283
Belle2::ECLCluster::getUncertaintyPhi
double getUncertaintyPhi() const
Return Uncertainty on Phi of Shower.
Definition ECLCluster.h:337
Belle2::ECLCluster::getAbsZernike40
double getAbsZernike40() const
Return Zernike moment 40 (shower shape variable).
Definition ECLCluster.h:277
Belle2::ECLCluster::getSecondMoment
double getSecondMoment() const
Return second moment (shower shape variable).
Definition ECLCluster.h:298
Belle2::ECLCluster::getTheta
double getTheta() const
Return Corrected Theta of Shower (radian).
Definition ECLCluster.h:316
Belle2::ECLCluster::getDeltaTime99
double getDeltaTime99() const
Return cluster delta time 99.
Definition ECLCluster.h:310
Belle2::ECLCluster::getTime
double getTime() const
Return cluster time.
Definition ECLCluster.h:307
Belle2::ECLCluster::EHypothesisBit::c_nPhotons
@ c_nPhotons
CR is split into n photons (N1)
Definition ECLCluster.h:41
Belle2::ECLCluster::EHypothesisBit::c_neutralHadron
@ c_neutralHadron
CR is reconstructed as a neutral hadron (N2)
Definition ECLCluster.h:43
Belle2::ECLCluster::getAbsZernike51
double getAbsZernike51() const
Return Zernike moment 51 (shower shape variable).
Definition ECLCluster.h:280
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:275
Belle2::ECLDataAnalysisModule::m_eclShowerToLM5
std::vector< int > * m_eclShowerToLM5
Index of 5th maximum related to ECLShower.
Definition ECLDataAnalysisModule.h:464
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2PDG
std::vector< int > * m_eclShowerToMC2PDG
PDG code of second MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:432
Belle2::ECLDataAnalysisModule::m_eclShowerTimeResolution
std::vector< double > * m_eclShowerTimeResolution
Shower Time Resolution.
Definition ECLDataAnalysisModule.h:481
Belle2::ECLDataAnalysisModule::m_doPureCsI
bool m_doPureCsI
if true, info on pureCsI upgrade is stored
Definition ECLDataAnalysisModule.h:84
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC5PDG
std::vector< int > * m_eclPureCalDigitToMC5PDG
PDG code of fifth MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:340
Belle2::ECLDataAnalysisModule::m_rootFileName
std::string m_rootFileName
name of the root file
Definition ECLDataAnalysisModule.h:81
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight5
std::vector< double > * m_eclPureCalDigitToMCWeight5
Energy contribution of fifth MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:342
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5GMothPDG
std::vector< int > * m_eclShowerToMC5GMothPDG
PDG code of Gparent of fifth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:457
Belle2::ECLDataAnalysisModule::eclShowerArrayName
virtual const char * eclShowerArrayName() const
Default name ECLShower array.
Definition ECLDataAnalysisModule.h:116
Belle2::ECLDataAnalysisModule::m_eclLogLikeEl
std::vector< double > * m_eclLogLikeEl
PID track electron likelihood.
Definition ECLDataAnalysisModule.h:539
Belle2::ECLDataAnalysisModule::m_eclDigitMultip
int m_eclDigitMultip
Number of ECLDigits per event.
Definition ECLDataAnalysisModule.h:184
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight5
std::vector< double > * m_eclClusterToMCWeight5
Energy contribution of 5th MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:277
Belle2::ECLDataAnalysisModule::m_doHits
bool m_doHits
if true, info on Hits and SimHits is stored
Definition ECLDataAnalysisModule.h:85
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4MothPDG
std::vector< int > * m_eclShowerToMC4MothPDG
PDG code of parent of fourth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:448
Belle2::ECLDataAnalysisModule::m_mcPy
std::vector< double > * m_mcPy
MCParticle momentum Y direction.
Definition ECLDataAnalysisModule.h:509
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight1
std::vector< double > * m_eclCalDigitToMCWeight1
Energy contribution of first MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:197
Belle2::ECLDataAnalysisModule::m_eclClusterTheta
std::vector< double > * m_eclClusterTheta
ECLCluster polar direction.
Definition ECLDataAnalysisModule.h:285
Belle2::ECLDataAnalysisModule::m_eclClusterNofCrystals
std::vector< int > * m_eclClusterNofCrystals
Number of crystals in ECLCluster.
Definition ECLDataAnalysisModule.h:296
Belle2::ECLDataAnalysisModule::m_eclPureClusterToBkgWeight
std::vector< double > * m_eclPureClusterToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLCluster,...
Definition ECLDataAnalysisModule.h:391
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodNeutralHadron
std::vector< double > * m_eclPureCRLikelihoodNeutralHadron
Connected Region Neutral Hadron Likelihood, PureCsI option.
Definition ECLDataAnalysisModule.h:360
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC3PDG
std::vector< int > * m_eclPureCalDigitToMC3PDG
PDG code of third MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:332
Belle2::ECLDataAnalysisModule::eclClusterArrayName
virtual const char * eclClusterArrayName() const
Default name ECLClusters array.
Definition ECLDataAnalysisModule.h:119
Belle2::ECLDataAnalysisModule::m_eclClusterDetectorRegion
std::vector< int > * m_eclClusterDetectorRegion
Cluster Detector Region.
Definition ECLDataAnalysisModule.h:308
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC2
std::vector< int > * m_eclPureCalDigitToMC2
Index of second MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:327
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight2
std::vector< double > * m_eclCalDigitToMCWeight2
Energy contribution of second MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:200
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:221
Belle2::ECLDataAnalysisModule::m_eclClusterCellId
std::vector< int > * m_eclClusterCellId
CellId with highest energy deposit in ECLCluster.
Definition ECLDataAnalysisModule.h:295
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToShower
std::vector< int > * m_eclPureCalDigitToShower
Index of ECLShower related to that CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:346
Belle2::ECLDataAnalysisModule::m_eclHitToMC
std::vector< int > * m_eclHitToMC
Index of MCParticle related to ECLHit.
Definition ECLDataAnalysisModule.h:251
Belle2::ECLDataAnalysisModule::m_eclClusterToMC3PDG
std::vector< int > * m_eclClusterToMC3PDG
PDG code of third MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:272
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodElectronNGamma
std::vector< double > * m_eclCRLikelihoodElectronNGamma
Connected Region Electron Likelihood.
Definition ECLDataAnalysisModule.h:225
Belle2::ECLDataAnalysisModule::m_eclCalDigitTimeFit
std::vector< double > * m_eclCalDigitTimeFit
ECLCalDigit timing.
Definition ECLDataAnalysisModule.h:216
Belle2::ECLDataAnalysisModule::m_eclPureClusterDeltaL
std::vector< double > * m_eclPureClusterDeltaL
Reconstructed Cluster DeltaL, PureCsI option.
Definition ECLDataAnalysisModule.h:409
Belle2::ECLDataAnalysisModule::m_tree
TTree * m_tree
Root tree and file for saving the output.
Definition ECLDataAnalysisModule.h:163
Belle2::ECLDataAnalysisModule::m_eclShowers
StoreArray< ECLShower > m_eclShowers
Store array: ECLShower.
Definition ECLDataAnalysisModule.h:97
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight5
std::vector< double > * m_eclCalDigitToMCWeight5
Energy contribution of fifth MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:209
Belle2::ECLDataAnalysisModule::m_eclSimHitFlightTime
std::vector< double > * m_eclSimHitFlightTime
ECLSimhit Flight Time.
Definition ECLDataAnalysisModule.h:241
Belle2::ECLDataAnalysisModule::m_eclClusterIdx
std::vector< int > * m_eclClusterIdx
ECLCluster index.
Definition ECLDataAnalysisModule.h:263
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC5
std::vector< int > * m_eclPureClusterToMC5
Index of fifth MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:386
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToBkgWeight
std::vector< double > * m_eclPureCalDigitToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to CalDigit,...
Definition ECLDataAnalysisModule.h:344
Belle2::ECLDataAnalysisModule::m_eclShowerEnergyError
std::vector< double > * m_eclShowerEnergyError
Shower Energy Error.
Definition ECLDataAnalysisModule.h:478
Belle2::ECLDataAnalysisModule::m_eclConnectedRegions
StoreArray< ECLConnectedRegion > m_eclConnectedRegions
Store array: ECLConnectedRegion.
Definition ECLDataAnalysisModule.h:96
Belle2::ECLDataAnalysisModule::m_eclShowerTime
std::vector< double > * m_eclShowerTime
Shower Timing.
Definition ECLDataAnalysisModule.h:473
Belle2::ECLDataAnalysisModule::m_eclShowerTheta
std::vector< double > * m_eclShowerTheta
Shower Theta.
Definition ECLDataAnalysisModule.h:468
Belle2::ECLDataAnalysisModule::m_eclShowerShowerDepth
std::vector< double > * m_eclShowerShowerDepth
Shower Depth.
Definition ECLDataAnalysisModule.h:486
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4GMoth
std::vector< int > * m_eclShowerToMC4GMoth
GMother index of fourth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:449
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight4
std::vector< double > * m_eclCalDigitToMCWeight4
Energy contribution of fourth MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:206
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitCellId
std::vector< int > * m_eclPureCalDigitCellId
Number of CalDigit CellId, PureCsI option.
Definition ECLDataAnalysisModule.h:347
Belle2::ECLDataAnalysisModule::m_eclClusterR
std::vector< double > * m_eclClusterR
ECLCluster distance from IP.
Definition ECLDataAnalysisModule.h:289
Belle2::ECLDataAnalysisModule::eclSimHitArrayName
virtual const char * eclSimHitArrayName() const
Default name ECLCalDigits array.
Definition ECLDataAnalysisModule.h:104
Belle2::ECLDataAnalysisModule::m_eclPureClusterIsTrack
std::vector< bool > * m_eclPureClusterIsTrack
Flag for charged clusters, PureCsI option.
Definition ECLDataAnalysisModule.h:408
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC1
std::vector< int > * m_eclPureCalDigitToMC1
Index of first MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:323
Belle2::ECLDataAnalysisModule::m_writeToRoot
bool m_writeToRoot
if true, a rootFile named by m_rootFileName will be filled with info
Definition ECLDataAnalysisModule.h:82
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC5PDG
std::vector< int > * m_eclPureClusterToMC5PDG
PDG code of fifth MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:389
Belle2::ECLDataAnalysisModule::m_eclShowerE9oE21
std::vector< double > * m_eclShowerE9oE21
Shower E9oE21.
Definition ECLDataAnalysisModule.h:472
Belle2::ECLDataAnalysisModule::m_eclPureClusterTimingError
std::vector< double > * m_eclPureClusterTimingError
Cluster time error, PureCsI option.
Definition ECLDataAnalysisModule.h:401
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC3
std::vector< int > * m_eclPureClusterToMC3
Index of third MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:378
Belle2::ECLDataAnalysisModule::m_eclPureDigitToCluster
std::vector< int > * m_eclPureDigitToCluster
ECLDigit To Cluster, PureCsI option.
Definition ECLDataAnalysisModule.h:319
Belle2::ECLDataAnalysisModule::m_doDigits
bool m_doDigits
if true, info on Digits and CalDigits is stored
Definition ECLDataAnalysisModule.h:86
Belle2::ECLDataAnalysisModule::m_eclPureClusterEnergyDepSum
std::vector< double > * m_eclPureClusterEnergyDepSum
Cluster simulated energy, PureCsI option.
Definition ECLDataAnalysisModule.h:399
Belle2::ECLDataAnalysisModule::eclPureClusterArrayName
virtual const char * eclPureClusterArrayName() const
Default name ECLPureClusters array.
Definition ECLDataAnalysisModule.h:152
Belle2::ECLDataAnalysisModule::m_eclShowerNumberOfCrystalsForEnergy
std::vector< double > * m_eclShowerNumberOfCrystalsForEnergy
Number of crystals used for energy calculation.
Definition ECLDataAnalysisModule.h:499
Belle2::ECLDataAnalysisModule::m_eclShowerIsCluster
std::vector< bool > * m_eclShowerIsCluster
Shower Cluster Match.
Definition ECLDataAnalysisModule.h:493
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC3PDG
std::vector< int > * m_eclPureClusterToMC3PDG
PDG code of third MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:381
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC2PDG
std::vector< int > * m_eclCalDigitToMC2PDG
PDG code of second MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:199
Belle2::ECLDataAnalysisModule::m_mcDecayVtxZ
std::vector< double > * m_mcDecayVtxZ
MCParticle decay vertex Z.
Definition ECLDataAnalysisModule.h:513
Belle2::ECLDataAnalysisModule::m_eclPureDigitToMC
std::vector< int > * m_eclPureDigitToMC
Index of MCParticle related to that ECLDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:314
Belle2::ECLDataAnalysisModule::m_eclClusterToMC5PDG
std::vector< int > * m_eclClusterToMC5PDG
PDG code of fifth MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:278
Belle2::ECLDataAnalysisModule::m_eclPureClusterZernikeMVA
std::vector< double > * m_eclPureClusterZernikeMVA
Output of MVA classifier based on Zernike Momenta, PureCsI option.
Definition ECLDataAnalysisModule.h:413
Belle2::ECLDataAnalysisModule::m_eclSimHitX
std::vector< double > * m_eclSimHitX
ECLSimHit X position.
Definition ECLDataAnalysisModule.h:242
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:198
Belle2::ECLDataAnalysisModule::m_eclPureCalDigits
StoreArray< ECLCalDigit > m_eclPureCalDigits
Store array: ECLPureCalDigit.
Definition ECLDataAnalysisModule.h:132
Belle2::ECLDataAnalysisModule::m_eclShowerHypothesisId
std::vector< int > * m_eclShowerHypothesisId
Shower Particle Hypothesis ID.
Definition ECLDataAnalysisModule.h:476
Belle2::ECLDataAnalysisModule::m_eclSimHitPz
std::vector< double > * m_eclSimHitPz
ECLSimHit PZ.
Definition ECLDataAnalysisModule.h:247
Belle2::ECLDataAnalysisModule::m_eclShowerMCVtxInEcl
std::vector< int > * m_eclShowerMCVtxInEcl
Int, 1 if particle decays (interacts) in ECL, 0 otherwise.
Definition ECLDataAnalysisModule.h:494
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToCR
std::vector< int > * m_eclPureCalDigitToCR
Index of CR related to that CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:351
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight4
std::vector< double > * m_eclShowerToMCWeight4
Energy contribution of fourth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:445
Belle2::ECLDataAnalysisModule::m_eclPureClusterDeltaTime99
std::vector< double > * m_eclPureClusterDeltaTime99
Reconstructed DeltaT99, PureCsI option.
Definition ECLDataAnalysisModule.h:416
Belle2::ECLDataAnalysisModule::m_eclHitMultip
int m_eclHitMultip
Number of ECLHits per event.
Definition ECLDataAnalysisModule.h:249
Belle2::ECLDataAnalysisModule::m_eclClusterZernikeMVA
std::vector< double > * m_eclClusterZernikeMVA
Zernike MVA.
Definition ECLDataAnalysisModule.h:303
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5PDG
std::vector< int > * m_eclShowerToMC5PDG
PDG code of fifth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:453
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3PDG
std::vector< int > * m_eclShowerToMC3PDG
PDG code of third MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:439
Belle2::ECLDataAnalysisModule::m_eclPureLMType
std::vector< int > * m_eclPureLMType
Local Maximum type, PureCsI option.
Definition ECLDataAnalysisModule.h:365
Belle2::ECLDataAnalysisModule::m_trkCharge
std::vector< int > * m_trkCharge
Track charge.
Definition ECLDataAnalysisModule.h:522
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2
std::vector< int > * m_eclShowerToMC2
Index of second MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:430
Belle2::ECLDataAnalysisModule::m_eclShowerToBkgWeight
std::vector< double > * m_eclShowerToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLShower.
Definition ECLDataAnalysisModule.h:459
Belle2::ECLDataAnalysisModule::m_trkPx
std::vector< double > * m_trkPx
Track momentum along X direction.
Definition ECLDataAnalysisModule.h:523
Belle2::ECLDataAnalysisModule::m_eclPureClusterAbsZernike51
std::vector< double > * m_eclPureClusterAbsZernike51
Reconstructed Zernike51, PureCsI option.
Definition ECLDataAnalysisModule.h:412
Belle2::ECLDataAnalysisModule::m_eclDigitToMC
std::vector< int > * m_eclDigitToMC
Index of MCParticle related to that ECLDigit.
Definition ECLDataAnalysisModule.h:186
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodMergedPi0
std::vector< double > * m_eclPureCRLikelihoodMergedPi0
Connected Region Merged Pi0 Likelihood, PureCsI option.
Definition ECLDataAnalysisModule.h:361
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodMIPNGamma
std::vector< double > * m_eclCRLikelihoodMIPNGamma
Connected Region MIP Likelihood.
Definition ECLDataAnalysisModule.h:223
Belle2::ECLDataAnalysisModule::m_eclClusterToMC4
std::vector< int > * m_eclClusterToMC4
Index of fourth MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:273
Belle2::ECLDataAnalysisModule::eclHitArrayName
virtual const char * eclHitArrayName() const
Default name ECLCalDigits array.
Definition ECLDataAnalysisModule.h:107
Belle2::ECLDataAnalysisModule::m_eclSimHitCellId
std::vector< int > * m_eclSimHitCellId
ECLSimHit CellId.
Definition ECLDataAnalysisModule.h:238
Belle2::ECLDataAnalysisModule::m_eclLocalMaximums
StoreArray< ECLLocalMaximum > m_eclLocalMaximums
Store array: ECLLocalMaximum.
Definition ECLDataAnalysisModule.h:99
Belle2::ECLDataAnalysisModule::event
virtual void event() override
event
Definition ECLDataAnalysisModule.cc:861
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodNeutralHadron
std::vector< double > * m_eclCRLikelihoodNeutralHadron
Connected Region Neutral Hadron Likelihood.
Definition ECLDataAnalysisModule.h:227
Belle2::ECLDataAnalysisModule::m_eclPureClusterTiming
std::vector< double > * m_eclPureClusterTiming
Cluster time, PureCsI option.
Definition ECLDataAnalysisModule.h:400
Belle2::ECLDataAnalysisModule::m_trkZ
std::vector< double > * m_trkZ
Track DOCA Z (?)
Definition ECLDataAnalysisModule.h:531
Belle2::ECLDataAnalysisModule::m_eclCalDigitSimHitSum
std::vector< double > * m_eclCalDigitSimHitSum
Full energy contribution related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:212
Belle2::ECLDataAnalysisModule::m_eclPureClusterHasNPhotonHypothesis
std::vector< int > * m_eclPureClusterHasNPhotonHypothesis
Cluster has n-photon hypothesis, PureCsI option.
Definition ECLDataAnalysisModule.h:418
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight4
std::vector< double > * m_eclPureCalDigitToMCWeight4
Energy contribution of fourth MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:338
Belle2::ECLDataAnalysisModule::eclLocalMaximumArrayName
virtual const char * eclLocalMaximumArrayName() const
Default name ECLLocalMaxima array.
Definition ECLDataAnalysisModule.h:125
Belle2::ECLDataAnalysisModule::m_eclCalDigitFitQuality
std::vector< int > * m_eclCalDigitFitQuality
ECLCalDigit fit quality.
Definition ECLDataAnalysisModule.h:217
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5GMoth
std::vector< int > * m_eclShowerToMC5GMoth
GMother index of fifth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:456
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC4
std::vector< int > * m_eclCalDigitToMC4
Index of fourth MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:204
Belle2::ECLDataAnalysisModule::m_eclHitEnergyDep
std::vector< double > * m_eclHitEnergyDep
ECLHit energy.
Definition ECLDataAnalysisModule.h:257
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodChargedHadron
std::vector< double > * m_eclCRLikelihoodChargedHadron
Connected Region Charged Hadron Likelihood.
Definition ECLDataAnalysisModule.h:224
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:495
Belle2::ECLDataAnalysisModule::m_eclClusterPhi
std::vector< double > * m_eclClusterPhi
ECLCluster azimuthal direction.
Definition ECLDataAnalysisModule.h:287
Belle2::ECLDataAnalysisModule::m_eclClusterAbsZernike40
std::vector< double > * m_eclClusterAbsZernike40
Reconstructed Abs Zernike40.
Definition ECLDataAnalysisModule.h:301
Belle2::ECLDataAnalysisModule::m_eclCalDigitMultip
int m_eclCalDigitMultip
Number of ECLCalDigits per event.
Definition ECLDataAnalysisModule.h:193
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4Moth
std::vector< int > * m_eclShowerToMC4Moth
Mother index of fourth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:447
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3GMoth
std::vector< int > * m_eclShowerToMC3GMoth
GMother index of third MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:442
Belle2::ECLDataAnalysisModule::m_eclPureClusterHighestE
std::vector< double > * m_eclPureClusterHighestE
Highest energy deposit (per crystal) in Cluster, PureCsI option.
Definition ECLDataAnalysisModule.h:403
Belle2::ECLDataAnalysisModule::m_eclClusterHasNPhotonHypothesis
std::vector< int > * m_eclClusterHasNPhotonHypothesis
Cluster has n-photon hypothesis.
Definition ECLDataAnalysisModule.h:309
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC2PDG
std::vector< int > * m_eclPureClusterToMC2PDG
PDG code of second MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:377
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight2
std::vector< double > * m_eclShowerToMCWeight2
Energy contribution of second MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:431
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1PDG
std::vector< int > * m_eclShowerToMC1PDG
PDG code of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:425
Belle2::ECLDataAnalysisModule::m_nECLCalDigitsOutOfTimeFWD
uint16_t m_nECLCalDigitsOutOfTimeFWD
Number of out of time, energetic ECLCalDigits, FWD.
Definition ECLDataAnalysisModule.h:172
Belle2::ECLDataAnalysisModule::m_eclSimHitEnergyDep
std::vector< double > * m_eclSimHitEnergyDep
Energy deposition of ECLSimHit.
Definition ECLDataAnalysisModule.h:240
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC2PDG
std::vector< int > * m_eclPureCalDigitToMC2PDG
PDG code of second MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:328
Belle2::ECLDataAnalysisModule::m_trkPz
std::vector< double > * m_trkPz
Track momentum along Z direction.
Definition ECLDataAnalysisModule.h:525
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight1
std::vector< double > * m_eclClusterToMCWeight1
Energy contribution of first MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:265
Belle2::ECLDataAnalysisModule::m_eclShowerToLM2
std::vector< int > * m_eclShowerToLM2
Index of 2nd maximum related to ECLShower.
Definition ECLDataAnalysisModule.h:461
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC4
std::vector< int > * m_eclPureCalDigitToMC4
Index of fourth MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:335
Belle2::ECLDataAnalysisModule::m_eclPureClusterNofCrystals
std::vector< int > * m_eclPureClusterNofCrystals
Number of crystals in Cluster, PureCsI option.
Definition ECLDataAnalysisModule.h:406
Belle2::ECLDataAnalysisModule::m_eclHitToPureDigit
std::vector< int > * m_eclHitToPureDigit
Index of ECLDigit related to ECLHit, PureCsI option.
Definition ECLDataAnalysisModule.h:254
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3GMothPDG
std::vector< int > * m_eclShowerToMC3GMothPDG
PDG code of Gparent of third MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:443
Belle2::ECLDataAnalysisModule::m_eclPureClusterMultip
int m_eclPureClusterMultip
Number of ECLClusterss per event, PureCsI option.
Definition ECLDataAnalysisModule.h:368
Belle2::ECLDataAnalysisModule::m_eclShowerMinTrkDistance
std::vector< double > * m_eclShowerMinTrkDistance
Shower Min Dist to Track.
Definition ECLDataAnalysisModule.h:484
Belle2::ECLDataAnalysisModule::m_eclSimHitPx
std::vector< double > * m_eclSimHitPx
ECLSimHit PX.
Definition ECLDataAnalysisModule.h:245
Belle2::ECLDataAnalysisModule::m_eclPureClusterCellId
std::vector< int > * m_eclPureClusterCellId
CellId with highest energy deposit in Cluster, PureCsI option.
Definition ECLDataAnalysisModule.h:404
Belle2::ECLDataAnalysisModule::m_eclCalDigitToShower
std::vector< int > * m_eclCalDigitToShower
Index of ECLShower related to that ECLCalDigit.
Definition ECLDataAnalysisModule.h:213
Belle2::ECLDataAnalysisModule::m_eclSimHitZ
std::vector< double > * m_eclSimHitZ
ECLSimHit Z position.
Definition ECLDataAnalysisModule.h:244
Belle2::ECLDataAnalysisModule::m_eclClusterThetaError
std::vector< double > * m_eclClusterThetaError
ECLCluster error on polar direction.
Definition ECLDataAnalysisModule.h:286
Belle2::ECLDataAnalysisModule::m_nECLShowersRejectedBWD
uint8_t m_nECLShowersRejectedBWD
Number of photon showers that are rejected before storing to mdst (max.
Definition ECLDataAnalysisModule.h:182
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC2
std::vector< int > * m_eclPureClusterToMC2
Index of second MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:374
Belle2::ECLDataAnalysisModule::m_eclClusterAbsZernike51
std::vector< double > * m_eclClusterAbsZernike51
Reconstructed Abs Zernike51.
Definition ECLDataAnalysisModule.h:302
Belle2::ECLDataAnalysisModule::m_trackFitResults
StoreArray< TrackFitResult > m_trackFitResults
TrackFitResult storeArray.
Definition ECLDataAnalysisModule.h:90
Belle2::ECLDataAnalysisModule::m_eclDigitAmp
std::vector< int > * m_eclDigitAmp
ECLDigit amplitude.
Definition ECLDataAnalysisModule.h:188
Belle2::ECLDataAnalysisModule::m_trkPy
std::vector< double > * m_trkPy
Track momentum along Y direction.
Definition ECLDataAnalysisModule.h:524
Belle2::ECLDataAnalysisModule::m_eclClusterEnergyDepSum
std::vector< double > * m_eclClusterEnergyDepSum
ECLCluster simulated energy.
Definition ECLDataAnalysisModule.h:290
Belle2::ECLDataAnalysisModule::m_eclPureClusterThetaError
std::vector< double > * m_eclPureClusterThetaError
Cluster error on polar direction, PureCsI option.
Definition ECLDataAnalysisModule.h:395
Belle2::ECLDataAnalysisModule::m_eclPureDigitIdx
std::vector< int > * m_eclPureDigitIdx
ECLDigit index, PureCsI option.
Definition ECLDataAnalysisModule.h:313
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2GMothPDG
std::vector< int > * m_eclShowerToMC2GMothPDG
PDG code of Gparent of second MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:436
Belle2::ECLDataAnalysisModule::m_mcPdg
std::vector< int > * m_mcPdg
MCParticle PDG code.
Definition ECLDataAnalysisModule.h:503
Belle2::ECLDataAnalysisModule::m_eclShowerSecondMoment
std::vector< double > * m_eclShowerSecondMoment
Shower Second Moment.
Definition ECLDataAnalysisModule.h:490
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5
std::vector< int > * m_eclShowerToMC5
Index of fifth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:451
Belle2::ECLDataAnalysisModule::terminate
virtual void terminate() override
Termination action.
Definition ECLDataAnalysisModule.cc:2380
Belle2::ECLDataAnalysisModule::m_mcDecayVtxY
std::vector< double > * m_mcDecayVtxY
MCParticle decay vertex Y.
Definition ECLDataAnalysisModule.h:512
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3MothPDG
std::vector< int > * m_eclShowerToMC3MothPDG
PDG code of parent of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:441
Belle2::ECLDataAnalysisModule::m_eclSimHits
StoreArray< ECLSimHit > m_eclSimHits
Store array: ECLSimHit.
Definition ECLDataAnalysisModule.h:92
Belle2::ECLDataAnalysisModule::m_eclClusterToMC5
std::vector< int > * m_eclClusterToMC5
Index of fifth MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:276
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4GMothPDG
std::vector< int > * m_eclShowerToMC4GMothPDG
PDG code of Gparent of fourth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:450
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight5
std::vector< double > * m_eclPureClusterToMCWeight5
Energy contribution of 5th MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:388
Belle2::ECLDataAnalysisModule::m_eclShowerToLM3
std::vector< int > * m_eclShowerToLM3
Index of 3rd maximum related to ECLShower.
Definition ECLDataAnalysisModule.h:462
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight1
std::vector< double > * m_eclPureClusterToMCWeight1
Energy contribution of first MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:372
Belle2::ECLDataAnalysisModule::m_eclPureDigitFitQuality
std::vector< int > * m_eclPureDigitFitQuality
ECLDigit fit quality, PureCsI option.
Definition ECLDataAnalysisModule.h:318
Belle2::ECLDataAnalysisModule::m_eclDigits
StoreArray< ECLDigit > m_eclDigits
Store array: ECLDigit.
Definition ECLDataAnalysisModule.h:94
Belle2::ECLDataAnalysisModule::m_eclClusterEnergyError
std::vector< double > * m_eclClusterEnergyError
ECLCluster energy error.
Definition ECLDataAnalysisModule.h:284
Belle2::ECLDataAnalysisModule::m_eclClusterPhiError
std::vector< double > * m_eclClusterPhiError
ECLCluster error on azimuthal direction.
Definition ECLDataAnalysisModule.h:288
Belle2::ECLDataAnalysisModule::m_trkIdx
std::vector< int > * m_trkIdx
Track index.
Definition ECLDataAnalysisModule.h:521
Belle2::ECLDataAnalysisModule::m_eclCalDigitToCR
std::vector< int > * m_eclCalDigitToCR
Index of CR related to that ECLCalDigit.
Definition ECLDataAnalysisModule.h:218
Belle2::ECLDataAnalysisModule::m_eclClusterToMC3
std::vector< int > * m_eclClusterToMC3
Index of third MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:270
Belle2::ECLDataAnalysisModule::m_eclClusterSimHitSum
std::vector< double > * m_eclClusterSimHitSum
Energy contribution of 1st MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:281
Belle2::ECLDataAnalysisModule::~ECLDataAnalysisModule
virtual ~ECLDataAnalysisModule() override
Destructor of the module.
Definition ECLDataAnalysisModule.cc:435
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitFitQuality
std::vector< int > * m_eclPureCalDigitFitQuality
CalDigit fit quality, PureCsI option.
Definition ECLDataAnalysisModule.h:350
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC1PDG
std::vector< int > * m_eclPureCalDigitToMC1PDG
PDG code of first MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:324
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodNGamma
std::vector< double > * m_eclPureCRLikelihoodNGamma
Connected Region Gamma Likelihood, PureCsI option.
Definition ECLDataAnalysisModule.h:359
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC3
std::vector< int > * m_eclPureCalDigitToMC3
Index of third MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:331
Belle2::ECLDataAnalysisModule::m_eclPureLMMultip
int m_eclPureLMMultip
Local Maxima multiplicity, PureCsI option.
Definition ECLDataAnalysisModule.h:363
Belle2::ECLDataAnalysisModule::m_mcMothPdg
std::vector< int > * m_mcMothPdg
MCParticle mother particle PDG code.
Definition ECLDataAnalysisModule.h:504
Belle2::ECLDataAnalysisModule::m_eclClusterToMC1
std::vector< int > * m_eclClusterToMC1
Index of first MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:264
Belle2::ECLDataAnalysisModule::m_eclShowerToLM4
std::vector< int > * m_eclShowerToLM4
Index of 4th maximum related to ECLShower.
Definition ECLDataAnalysisModule.h:463
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight2
std::vector< double > * m_eclClusterToMCWeight2
Energy contribution of second MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:268
Belle2::ECLDataAnalysisModule::m_eclLogLikePi
std::vector< double > * m_eclLogLikePi
PID track pion likelihood.
Definition ECLDataAnalysisModule.h:541
Belle2::ECLDataAnalysisModule::m_eclClusterE1oE9
std::vector< double > * m_eclClusterE1oE9
Reconstructed E1 over E9.
Definition ECLDataAnalysisModule.h:304
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitTimeFit
std::vector< double > * m_eclPureCalDigitTimeFit
CalDigit timing, PureCsI option.
Definition ECLDataAnalysisModule.h:349
Belle2::ECLDataAnalysisModule::m_eclShowerUncEnergy
std::vector< double > * m_eclShowerUncEnergy
Shower bare energy.
Definition ECLDataAnalysisModule.h:466
Belle2::ECLDataAnalysisModule::m_eclCalDigitToBkgWeight
std::vector< double > * m_eclCalDigitToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:211
Belle2::ECLDataAnalysisModule::m_eclHitToDigit
std::vector< int > * m_eclHitToDigit
Index of ECLDigit related to ECLHit.
Definition ECLDataAnalysisModule.h:252
Belle2::ECLDataAnalysisModule::m_eclPureDigits
StoreArray< ECLDigit > m_eclPureDigits
Store array: ECLPureDigit.
Definition ECLDataAnalysisModule.h:130
Belle2::ECLDataAnalysisModule::m_eclClusterHasNeutralHadronHypothesis
std::vector< int > * m_eclClusterHasNeutralHadronHypothesis
Cluster has neutral hadron hypothesis.
Definition ECLDataAnalysisModule.h:310
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2Moth
std::vector< int > * m_eclShowerToMC2Moth
Mother index of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:433
Belle2::ECLDataAnalysisModule::m_eclShowerT99
std::vector< double > * m_eclShowerT99
Shower T99.
Definition ECLDataAnalysisModule.h:474
Belle2::ECLDataAnalysisModule::m_eclShowerToLM1
std::vector< int > * m_eclShowerToLM1
Index of first maximum related to ECLShower.
Definition ECLDataAnalysisModule.h:460
Belle2::ECLDataAnalysisModule::m_eclLMCellId
std::vector< int > * m_eclLMCellId
Local Maximum Cell ID.
Definition ECLDataAnalysisModule.h:233
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight3
std::vector< double > * m_eclShowerToMCWeight3
Energy contribution of third MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:438
Belle2::ECLDataAnalysisModule::m_eclHitToDigitAmp
std::vector< int > * m_eclHitToDigitAmp
Amplitude of ECLDigit related to ECLHit.
Definition ECLDataAnalysisModule.h:253
Belle2::ECLDataAnalysisModule::m_eclClusterTrueMultip
int m_eclClusterTrueMultip
Number of ECLClusters per event.
Definition ECLDataAnalysisModule.h:261
Belle2::ECLDataAnalysisModule::m_eclDigitTimeFit
std::vector< int > * m_eclDigitTimeFit
ECLDigit timing.
Definition ECLDataAnalysisModule.h:189
Belle2::ECLDataAnalysisModule::m_eclPureClusterClosestTrackDist
std::vector< double > * m_eclPureClusterClosestTrackDist
Reconstructed Distance to Closest Track, PureCsI option.
Definition ECLDataAnalysisModule.h:410
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight4
std::vector< double > * m_eclClusterToMCWeight4
Energy contribution of fourth MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:274
Belle2::ECLDataAnalysisModule::m_eclShowerHighestEnergy
std::vector< double > * m_eclShowerHighestEnergy
Shower Highest Energy Crystal Energy.
Definition ECLDataAnalysisModule.h:482
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodElectronNGamma
std::vector< double > * m_eclPureCRLikelihoodElectronNGamma
Connected Region Electron Likelihood, PureCsI option.
Definition ECLDataAnalysisModule.h:358
Belle2::ECLDataAnalysisModule::m_eclClusterToMC2
std::vector< int > * m_eclClusterToMC2
Index of second MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:267
Belle2::ECLDataAnalysisModule::m_eclShowerIdx
std::vector< int > * m_eclShowerIdx
Shower Index.
Definition ECLDataAnalysisModule.h:422
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitIdx
std::vector< int > * m_eclPureCalDigitIdx
ECLCalDigit index, PureCsI option.
Definition ECLDataAnalysisModule.h:322
Belle2::ECLDataAnalysisModule::m_eclSimHitToMC
std::vector< int > * m_eclSimHitToMC
Index of MCParticle related to that ECLSimHit.
Definition ECLDataAnalysisModule.h:237
Belle2::ECLDataAnalysisModule::m_eclClusterToBkgWeight
std::vector< double > * m_eclClusterToBkgWeight
Remaining energy contribution not associated to first five MCParticles related to ECLCluster.
Definition ECLDataAnalysisModule.h:280
Belle2::ECLDataAnalysisModule::m_eclDigitToCalDigit
std::vector< int > * m_eclDigitToCalDigit
Index of CalDigit related to that ECLDigit.
Definition ECLDataAnalysisModule.h:191
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3Moth
std::vector< int > * m_eclShowerToMC3Moth
Mother index of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:440
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight2
std::vector< double > * m_eclPureCalDigitToMCWeight2
Energy contribution of second MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:330
Belle2::ECLDataAnalysisModule::m_eclDigitIdx
std::vector< int > * m_eclDigitIdx
ECLDigit index.
Definition ECLDataAnalysisModule.h:185
Belle2::ECLDataAnalysisModule::m_eclClusterGammaMultip
int m_eclClusterGammaMultip
Number of ECLClusters per event.
Definition ECLDataAnalysisModule.h:262
Belle2::ECLDataAnalysisModule::m_eclPureClusterE1oE9
std::vector< double > * m_eclPureClusterE1oE9
Reconstructed E1oE9, PureCsI option.
Definition ECLDataAnalysisModule.h:415
Belle2::ECLDataAnalysisModule::m_eclShowerThetaError
std::vector< double > * m_eclShowerThetaError
Shower Theta Error.
Definition ECLDataAnalysisModule.h:479
Belle2::ECLDataAnalysisModule::m_eclShowerSimHitSum
std::vector< double > * m_eclShowerSimHitSum
Full energy contribution related to ECLShower.
Definition ECLDataAnalysisModule.h:465
Belle2::ECLDataAnalysisModule::m_tracks
StoreArray< Track > m_tracks
Tracks storeArray.
Definition ECLDataAnalysisModule.h:89
Belle2::ECLDataAnalysisModule::eclPureDigitArrayName
virtual const char * eclPureDigitArrayName() const
Default name ECLPureDigits array.
Definition ECLDataAnalysisModule.h:143
Belle2::ECLDataAnalysisModule::m_eclPureLocalMaximums
StoreArray< ECLLocalMaximum > m_eclPureLocalMaximums
Store array: ECLPureLocalMaximum.
Definition ECLDataAnalysisModule.h:140
Belle2::ECLDataAnalysisModule::m_eclPureLMCellId
std::vector< int > * m_eclPureLMCellId
Local Maximum Cell ID, PureCsI option.
Definition ECLDataAnalysisModule.h:366
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC5PDG
std::vector< int > * m_eclCalDigitToMC5PDG
PDG code of fifth MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:208
Belle2::ECLDataAnalysisModule::m_eclShowerIsTrack
std::vector< int > * m_eclShowerIsTrack
Shower Track Match.
Definition ECLDataAnalysisModule.h:492
Belle2::ECLDataAnalysisModule::m_mcGMothPdg
std::vector< int > * m_mcGMothPdg
MCParticle grandmother particle PDG code.
Definition ECLDataAnalysisModule.h:505
Belle2::ECLDataAnalysisModule::m_eclpidEnergy
std::vector< double > * m_eclpidEnergy
PID track energy.
Definition ECLDataAnalysisModule.h:534
Belle2::ECLDataAnalysisModule::m_eclpidNClusters
std::vector< int > * m_eclpidNClusters
PID track number of clusters.
Definition ECLDataAnalysisModule.h:538
Belle2::ECLDataAnalysisModule::m_eclShowerPhi
std::vector< double > * m_eclShowerPhi
Shower Phi.
Definition ECLDataAnalysisModule.h:469
Belle2::ECLDataAnalysisModule::m_mcMultip
int m_mcMultip
Multiplicity of MCParticles.
Definition ECLDataAnalysisModule.h:501
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodMIPNGamma
std::vector< double > * m_eclPureCRLikelihoodMIPNGamma
Connected Region MIP Likelihood, PureCsI option.
Definition ECLDataAnalysisModule.h:356
Belle2::ECLDataAnalysisModule::m_eclPureClusterE9oE21
std::vector< double > * m_eclPureClusterE9oE21
Ratio of 3x3 over 5x5 crystal matrices energies for Cluster, PureCsI option.
Definition ECLDataAnalysisModule.h:402
Belle2::ECLDataAnalysisModule::m_eclLMType
std::vector< int > * m_eclLMType
Local Maximum type.
Definition ECLDataAnalysisModule.h:232
Belle2::ECLDataAnalysisModule::m_eclShowerTrkDepth
std::vector< double > * m_eclShowerTrkDepth
Shower Track Depth.
Definition ECLDataAnalysisModule.h:485
Belle2::ECLDataAnalysisModule::m_eclLMId
std::vector< int > * m_eclLMId
Local Maximum ID.
Definition ECLDataAnalysisModule.h:231
Belle2::ECLDataAnalysisModule::m_trkP
std::vector< double > * m_trkP
Track momentum.
Definition ECLDataAnalysisModule.h:526
Belle2::ECLDataAnalysisModule::m_eclPureClusterEnergy
std::vector< double > * m_eclPureClusterEnergy
Cluster energy, PureCsI option.
Definition ECLDataAnalysisModule.h:392
Belle2::ECLDataAnalysisModule::m_eclHitToPureDigitAmp
std::vector< int > * m_eclHitToPureDigitAmp
Amplitude of ECLDigit related to ECLHit, PureCsI option.
Definition ECLDataAnalysisModule.h:255
Belle2::ECLDataAnalysisModule::m_eclClusterTimingError
std::vector< double > * m_eclClusterTimingError
ECLCluster time error.
Definition ECLDataAnalysisModule.h:292
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4
std::vector< int > * m_eclShowerToMC4
Index of fourth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:444
Belle2::ECLDataAnalysisModule::m_mcProdVtxZ
std::vector< double > * m_mcProdVtxZ
MCParticle production vertex Z.
Definition ECLDataAnalysisModule.h:516
Belle2::ECLDataAnalysisModule::m_mcEnergy
std::vector< double > * m_mcEnergy
MCParticle energyx.
Definition ECLDataAnalysisModule.h:507
Belle2::ECLDataAnalysisModule::m_eclpidtrkIdx
std::vector< int > * m_eclpidtrkIdx
PID track index.
Definition ECLDataAnalysisModule.h:533
Belle2::ECLDataAnalysisModule::m_eclShowerCentralCellId
std::vector< int > * m_eclShowerCentralCellId
Cell ID for most energetic crystal.
Definition ECLDataAnalysisModule.h:477
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight1
std::vector< double > * m_eclShowerToMCWeight1
Energy contribution of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:424
Belle2::ECLDataAnalysisModule::m_eclClusters
StoreArray< ECLCluster > m_eclClusters
Store array: ECLCluster.
Definition ECLDataAnalysisModule.h:98
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC3
std::vector< int > * m_eclCalDigitToMC3
Index of third MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:201
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC4PDG
std::vector< int > * m_eclPureCalDigitToMC4PDG
PDG code of fourth MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:336
Belle2::ECLDataAnalysisModule::m_eclHitIdx
std::vector< int > * m_eclHitIdx
Index of ECLHits.
Definition ECLDataAnalysisModule.h:250
Belle2::ECLDataAnalysisModule::m_eclClusterToMC1PDG
std::vector< int > * m_eclClusterToMC1PDG
PDG code of first MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:266
Belle2::ECLDataAnalysisModule::m_eclPureClusterDetectorRegion
std::vector< int > * m_eclPureClusterDetectorRegion
Clusters detector region, PureCsI option.
Definition ECLDataAnalysisModule.h:417
Belle2::ECLDataAnalysisModule::m_mcDecayVtxX
std::vector< double > * m_mcDecayVtxX
MCParticle decay vertex X.
Definition ECLDataAnalysisModule.h:511
Belle2::ECLDataAnalysisModule::m_trkY
std::vector< double > * m_trkY
Track DOCA Y (?)
Definition ECLDataAnalysisModule.h:530
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5Moth
std::vector< int > * m_eclShowerToMC5Moth
Mother index of fifth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:454
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitAmp
std::vector< double > * m_eclPureCalDigitAmp
CalDigit amplitude, PureCsI option.
Definition ECLDataAnalysisModule.h:348
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToLM
std::vector< int > * m_eclPureCalDigitToLM
Index of LM related to that CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:352
Belle2::ECLDataAnalysisModule::m_eclCalDigitIdx
std::vector< int > * m_eclCalDigitIdx
ECLCalDigit index.
Definition ECLDataAnalysisModule.h:194
Belle2::ECLDataAnalysisModule::m_eclSimHitIdx
std::vector< int > * m_eclSimHitIdx
Index of ECLSimHit.
Definition ECLDataAnalysisModule.h:236
Belle2::ECLDataAnalysisModule::m_eclClusterToMC2PDG
std::vector< int > * m_eclClusterToMC2PDG
PDG code of second MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:269
Belle2::ECLDataAnalysisModule::m_eclPureConnectedRegions
StoreArray< ECLConnectedRegion > m_eclPureConnectedRegions
Store array: ECLPureConnectedRegion.
Definition ECLDataAnalysisModule.h:134
Belle2::ECLDataAnalysisModule::m_eclPureDigitCellId
std::vector< int > * m_eclPureDigitCellId
Number of ECLDigit CellId, PureCsI option.
Definition ECLDataAnalysisModule.h:315
Belle2::ECLDataAnalysisModule::m_eclDigitFitQuality
std::vector< int > * m_eclDigitFitQuality
ECLDigit fit quality.
Definition ECLDataAnalysisModule.h:190
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitMultip
int m_eclPureCalDigitMultip
Number of ECLCalDigits per event, PureCsI option.
Definition ECLDataAnalysisModule.h:321
Belle2::ECLDataAnalysisModule::m_eclPureClusterLat
std::vector< double > * m_eclPureClusterLat
Cluster shape parameter LAT, PureCsI option.
Definition ECLDataAnalysisModule.h:405
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC4PDG
std::vector< int > * m_eclPureClusterToMC4PDG
PDG code of fourth MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:385
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:497
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC1PDG
std::vector< int > * m_eclCalDigitToMC1PDG
PDG code of first MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:196
Belle2::ECLDataAnalysisModule::m_eclCalDigitAmp
std::vector< double > * m_eclCalDigitAmp
ECLCalDigit amplitude.
Definition ECLDataAnalysisModule.h:215
Belle2::ECLDataAnalysisModule::m_mcPx
std::vector< double > * m_mcPx
MCParticle momentum X direction.
Definition ECLDataAnalysisModule.h:508
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2MothPDG
std::vector< int > * m_eclShowerToMC2MothPDG
PDG code of parent of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:434
Belle2::ECLDataAnalysisModule::m_eclpidNCrystals
std::vector< int > * m_eclpidNCrystals
PID track number of crystals.
Definition ECLDataAnalysisModule.h:537
Belle2::ECLDataAnalysisModule::m_mcIdx
std::vector< int > * m_mcIdx
MCParticle index.
Definition ECLDataAnalysisModule.h:502
Belle2::ECLDataAnalysisModule::m_eclPureShowers
StoreArray< ECLShower > m_eclPureShowers
Store array: ECLPureShower.
Definition ECLDataAnalysisModule.h:136
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC1PDG
std::vector< int > * m_eclPureClusterToMC1PDG
PDG code of first MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:373
Belle2::ECLDataAnalysisModule::m_eclShowerZernikeMVA
std::vector< double > * m_eclShowerZernikeMVA
Shower ZernikeMVA.
Definition ECLDataAnalysisModule.h:489
Belle2::ECLDataAnalysisModule::m_eclPureClusterAbsZernike40
std::vector< double > * m_eclPureClusterAbsZernike40
Reconstructed Zernike40, PureCsI option.
Definition ECLDataAnalysisModule.h:411
Belle2::ECLDataAnalysisModule::m_eclPureClusterSecondMoment
std::vector< double > * m_eclPureClusterSecondMoment
Reconstructed Cluster Second Moment, PureCsI option.
Definition ECLDataAnalysisModule.h:414
Belle2::ECLDataAnalysisModule::m_eclPureDigitMultip
int m_eclPureDigitMultip
Number of ECLDigits per event, PureCsI option.
Definition ECLDataAnalysisModule.h:312
Belle2::ECLDataAnalysisModule::m_nECLShowersRejectedBarrel
uint8_t m_nECLShowersRejectedBarrel
Number of photon showers that are rejected before storing to mdst (max.
Definition ECLDataAnalysisModule.h:180
Belle2::ECLDataAnalysisModule::eclDigitArrayName
virtual const char * eclDigitArrayName() const
Default name ECLDigits array.
Definition ECLDataAnalysisModule.h:110
Belle2::ECLDataAnalysisModule::m_eclClusterTiming
std::vector< double > * m_eclClusterTiming
ECLCluster time.
Definition ECLDataAnalysisModule.h:291
Belle2::ECLDataAnalysisModule::m_eclCalDigitCellId
std::vector< int > * m_eclCalDigitCellId
Number of ECLCalDigit CellId.
Definition ECLDataAnalysisModule.h:214
Belle2::ECLDataAnalysisModule::m_mcProdVtxX
std::vector< double > * m_mcProdVtxX
MCParticle production vertex X.
Definition ECLDataAnalysisModule.h:514
Belle2::ECLDataAnalysisModule::m_eclShowerEnergy
std::vector< double > * m_eclShowerEnergy
Shower Energy.
Definition ECLDataAnalysisModule.h:467
Belle2::ECLDataAnalysisModule::m_eclHits
StoreArray< ECLHit > m_eclHits
Store array: ECLHit.
Definition ECLDataAnalysisModule.h:93
Belle2::ECLDataAnalysisModule::m_eclPureCRIdx
std::vector< int > * m_eclPureCRIdx
Connected Region ID, PureCsI option.
Definition ECLDataAnalysisModule.h:354
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodMergedPi0
std::vector< double > * m_eclCRLikelihoodMergedPi0
Connected Region Merged Pi0 Likelihood.
Definition ECLDataAnalysisModule.h:228
Belle2::ECLDataAnalysisModule::m_nECLShowersRejectedFWD
uint8_t m_nECLShowersRejectedFWD
Number of photon showers that are rejected before storing to mdst (max.
Definition ECLDataAnalysisModule.h:178
Belle2::ECLDataAnalysisModule::eclConnectedRegionArrayName
virtual const char * eclConnectedRegionArrayName() const
Default name ECLConnectedRegions array.
Definition ECLDataAnalysisModule.h:122
Belle2::ECLDataAnalysisModule::m_eclShowerToMC5MothPDG
std::vector< int > * m_eclShowerToMC5MothPDG
PDG code of parent of fifth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:455
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight2
std::vector< double > * m_eclPureClusterToMCWeight2
Energy contribution of second MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:376
Belle2::ECLDataAnalysisModule::m_trkX
std::vector< double > * m_trkX
Track DOCA X (?)
Definition ECLDataAnalysisModule.h:529
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight3
std::vector< double > * m_eclPureClusterToMCWeight3
Energy contribution of third MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:380
Belle2::ECLDataAnalysisModule::m_eclClusterMultip
int m_eclClusterMultip
Number of ECLClusters per event.
Definition ECLDataAnalysisModule.h:260
Belle2::ECLDataAnalysisModule::m_eclShowerLateralEnergy
std::vector< double > * m_eclShowerLateralEnergy
Shower Lateral Energy.
Definition ECLDataAnalysisModule.h:483
Belle2::ECLDataAnalysisModule::m_mcPz
std::vector< double > * m_mcPz
MCParticle momentum Z direction.
Definition ECLDataAnalysisModule.h:510
Belle2::ECLDataAnalysisModule::m_eclPureClusterHasNeutralHadronHypothesis
std::vector< int > * m_eclPureClusterHasNeutralHadronHypothesis
Cluster has neutral hadron hypothesis, PureCsI option.
Definition ECLDataAnalysisModule.h:419
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitSimHitSum
std::vector< double > * m_eclPureCalDigitSimHitSum
Full energy contribution related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:345
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC5
std::vector< int > * m_eclCalDigitToMC5
Index of fifth MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:207
Belle2::ECLDataAnalysisModule::m_mcParticles
StoreArray< MCParticle > m_mcParticles
MCParticles StoreArray.
Definition ECLDataAnalysisModule.h:161
Belle2::ECLDataAnalysisModule::m_eclClusterHighestE
std::vector< double > * m_eclClusterHighestE
Highest energy deposit (per crystal) in ECLCluster.
Definition ECLDataAnalysisModule.h:294
Belle2::ECLDataAnalysisModule::m_eclPureDigitAmp
std::vector< int > * m_eclPureDigitAmp
ECLDigit amplitude, PureCsI option.
Definition ECLDataAnalysisModule.h:316
Belle2::ECLDataAnalysisModule::m_eventmetadata
StoreObjPtr< EventMetaData > m_eventmetadata
Store object pointer: EventMetaData.
Definition ECLDataAnalysisModule.h:101
Belle2::ECLDataAnalysisModule::m_eclCRIsTrack
std::vector< int > * m_eclCRIsTrack
Int for Connected Region - Track Match.
Definition ECLDataAnalysisModule.h:222
Belle2::ECLDataAnalysisModule::m_eclShowerConnectedRegionId
std::vector< int > * m_eclShowerConnectedRegionId
Matched Connetcted Region Idx.
Definition ECLDataAnalysisModule.h:475
Belle2::ECLDataAnalysisModule::eclCalDigitArrayName
virtual const char * eclCalDigitArrayName() const
Default name ECLCalDigits array.
Definition ECLDataAnalysisModule.h:113
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMCWeight4
std::vector< double > * m_eclPureClusterToMCWeight4
Energy contribution of fourth MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:384
Belle2::ECLDataAnalysisModule::m_eclPureClusterPhiError
std::vector< double > * m_eclPureClusterPhiError
Cluster error on azimuthal direction, PureCsI option.
Definition ECLDataAnalysisModule.h:397
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:83
Belle2::ECLDataAnalysisModule::m_eclShowerAbsZernike51
std::vector< double > * m_eclShowerAbsZernike51
Shower Zernike51 Moment.
Definition ECLDataAnalysisModule.h:488
Belle2::ECLDataAnalysisModule::m_eclShowerR
std::vector< double > * m_eclShowerR
Shower R.
Definition ECLDataAnalysisModule.h:470
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC1
std::vector< int > * m_eclPureClusterToMC1
Index of first MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:370
Belle2::ECLDataAnalysisModule::m_eclShowerToMCWeight5
std::vector< double > * m_eclShowerToMCWeight5
Energy contribution of fifth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:452
Belle2::ECLDataAnalysisModule::m_eclHitTimeAve
std::vector< double > * m_eclHitTimeAve
ECLHit time.
Definition ECLDataAnalysisModule.h:258
Belle2::ECLDataAnalysisModule::m_eclPureClusters
StoreArray< ECLCluster > m_eclPureClusters
Store array: ECLPureCluster.
Definition ECLDataAnalysisModule.h:138
Belle2::ECLDataAnalysisModule::m_eclLMMultip
int m_eclLMMultip
Local Maxima multiplicity.
Definition ECLDataAnalysisModule.h:230
Belle2::ECLDataAnalysisModule::m_eclSimHitPdg
std::vector< int > * m_eclSimHitPdg
PDG code of MCParticle associated to that ECLDigit.
Definition ECLDataAnalysisModule.h:239
Belle2::ECLDataAnalysisModule::eclPureLocalMaximumArrayName
virtual const char * eclPureLocalMaximumArrayName() const
Default name ECLPureLocalMaxima array.
Definition ECLDataAnalysisModule.h:158
Belle2::ECLDataAnalysisModule::m_trkPhi
std::vector< double > * m_trkPhi
Track azimuthal direction.
Definition ECLDataAnalysisModule.h:528
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC3PDG
std::vector< int > * m_eclCalDigitToMC3PDG
PDG code of third MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:202
Belle2::ECLDataAnalysisModule::m_eclDigitCellId
std::vector< int > * m_eclDigitCellId
Number of ECLDigit CellId.
Definition ECLDataAnalysisModule.h:187
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight1
std::vector< double > * m_eclPureCalDigitToMCWeight1
Energy contribution of first MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:326
Belle2::ECLDataAnalysisModule::m_eclPureClusterR
std::vector< double > * m_eclPureClusterR
Cluster distance from IP, PureCsI option.
Definition ECLDataAnalysisModule.h:398
Belle2::ECLDataAnalysisModule::m_eclPureClusterTheta
std::vector< double > * m_eclPureClusterTheta
Cluster polar direction, PureCsI option.
Definition ECLDataAnalysisModule.h:394
Belle2::ECLDataAnalysisModule::m_trkTheta
std::vector< double > * m_trkTheta
Track polar direction.
Definition ECLDataAnalysisModule.h:527
Belle2::ECLDataAnalysisModule::m_nECLCalDigitsOutOfTimeBarrel
uint16_t m_nECLCalDigitsOutOfTimeBarrel
Number of out of time, energetic ECLCalDigits, Barrel.
Definition ECLDataAnalysisModule.h:174
Belle2::ECLDataAnalysisModule::m_eclLogLikeMu
std::vector< double > * m_eclLogLikeMu
PID track muon likelihood.
Definition ECLDataAnalysisModule.h:540
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC4PDG
std::vector< int > * m_eclCalDigitToMC4PDG
PDG code of fourth MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:205
Belle2::ECLDataAnalysisModule::m_eclPureClusterToMC4
std::vector< int > * m_eclPureClusterToMC4
Index of fourth MCParticle related to ECLCluster, PureCsI option.
Definition ECLDataAnalysisModule.h:382
Belle2::ECLDataAnalysisModule::m_eclPureClusterIdx
std::vector< int > * m_eclPureClusterIdx
ECLCluster index, PureCsI option.
Definition ECLDataAnalysisModule.h:369
Belle2::ECLDataAnalysisModule::m_eclClusterEnergy
std::vector< double > * m_eclClusterEnergy
ECLCluster energy.
Definition ECLDataAnalysisModule.h:283
Belle2::ECLDataAnalysisModule::eclPureShowerArrayName
virtual const char * eclPureShowerArrayName() const
Default name ECLPureShower array.
Definition ECLDataAnalysisModule.h:149
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1
std::vector< int > * m_eclShowerToMC1
Index of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:423
Belle2::ECLDataAnalysisModule::m_eclSimHitPy
std::vector< double > * m_eclSimHitPy
ECLSimHit PY.
Definition ECLDataAnalysisModule.h:246
Belle2::ECLDataAnalysisModule::m_eclCalDigitToLM
std::vector< int > * m_eclCalDigitToLM
Index of LM related to that ECLCalDigit.
Definition ECLDataAnalysisModule.h:219
Belle2::ECLDataAnalysisModule::m_eclClusterClosestTrackDist
std::vector< double > * m_eclClusterClosestTrackDist
Flag for charged clusters.
Definition ECLDataAnalysisModule.h:299
Belle2::ECLDataAnalysisModule::m_eclSimHitY
std::vector< double > * m_eclSimHitY
ECLSimHit Y position.
Definition ECLDataAnalysisModule.h:243
Belle2::ECLDataAnalysisModule::m_eclPureCRLikelihoodChargedHadron
std::vector< double > * m_eclPureCRLikelihoodChargedHadron
Connected Region Charged Hadron Likelihood, PureCsI option.
Definition ECLDataAnalysisModule.h:357
Belle2::ECLDataAnalysisModule::m_eclSimHitMultip
int m_eclSimHitMultip
Number of ECLSimHits per event.
Definition ECLDataAnalysisModule.h:235
Belle2::ECLDataAnalysisModule::m_rootFilePtr
TFile * m_rootFilePtr
members of ECLReconstructor Module
Definition ECLDataAnalysisModule.h:80
Belle2::ECLDataAnalysisModule::m_eclClusterLAT
std::vector< double > * m_eclClusterLAT
Reconstructed LAT.
Definition ECLDataAnalysisModule.h:306
Belle2::ECLDataAnalysisModule::m_eclShowerHighestE1mE2
std::vector< double > * m_eclShowerHighestE1mE2
Energy difference for 2 highest energy deposits in shower.
Definition ECLDataAnalysisModule.h:498
Belle2::ECLDataAnalysisModule::m_eclClusterDeltaTime99
std::vector< double > * m_eclClusterDeltaTime99
DeltaTime99.
Definition ECLDataAnalysisModule.h:307
Belle2::ECLDataAnalysisModule::m_eclHitCellId
std::vector< int > * m_eclHitCellId
ECLHit CellID.
Definition ECLDataAnalysisModule.h:256
Belle2::ECLDataAnalysisModule::m_eventLevelClusteringInfo
StoreObjPtr< EventLevelClusteringInfo > m_eventLevelClusteringInfo
Store object pointer: EventLevelClusteringInfo.
Definition ECLDataAnalysisModule.h:100
Belle2::ECLDataAnalysisModule::m_mcSecondaryPhysProc
std::vector< int > * m_mcSecondaryPhysProc
Flag for secondary physics process.
Definition ECLDataAnalysisModule.h:517
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1Moth
std::vector< int > * m_eclShowerToMC1Moth
Mother index of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:426
Belle2::ECLDataAnalysisModule::m_eclShowerE1oE9
std::vector< double > * m_eclShowerE1oE9
Shower E1/E9.
Definition ECLDataAnalysisModule.h:491
Belle2::ECLDataAnalysisModule::m_eclShowerToMC3
std::vector< int > * m_eclShowerToMC3
Index of third MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:437
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1GMothPDG
std::vector< int > * m_eclShowerToMC1GMothPDG
PDG code of Gparent of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:429
Belle2::ECLDataAnalysisModule::m_mcProdVtxY
std::vector< double > * m_mcProdVtxY
MCParticle production vertex Y.
Definition ECLDataAnalysisModule.h:515
Belle2::ECLDataAnalysisModule::m_eclClusterSecondMoment
std::vector< double > * m_eclClusterSecondMoment
Reconstructed Second Moment.
Definition ECLDataAnalysisModule.h:305
Belle2::ECLDataAnalysisModule::m_eclPureClusterEnergyError
std::vector< double > * m_eclPureClusterEnergyError
Cluster energy error, PureCsI option.
Definition ECLDataAnalysisModule.h:393
Belle2::ECLDataAnalysisModule::m_eclShowerToMC2GMoth
std::vector< int > * m_eclShowerToMC2GMoth
GMother index of second MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:435
Belle2::ECLDataAnalysisModule::m_eclClusterE9oE21
std::vector< double > * m_eclClusterE9oE21
Ratio of 3x3 over 5x5 crystal matrices energies for ECLCluster.
Definition ECLDataAnalysisModule.h:293
Belle2::ECLDataAnalysisModule::m_eclPureLMId
std::vector< int > * m_eclPureLMId
Local Maximum ID, PureCsI option.
Definition ECLDataAnalysisModule.h:364
Belle2::ECLDataAnalysisModule::eclPureCalDigitArrayName
virtual const char * eclPureCalDigitArrayName() const
Default name ECLPureCalDigits array.
Definition ECLDataAnalysisModule.h:146
Belle2::ECLDataAnalysisModule::m_eclShowerToMC4PDG
std::vector< int > * m_eclShowerToMC4PDG
PDG code of fourth MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:446
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMC1
std::vector< int > * m_eclCalDigitToMC1
Index of first MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:195
Belle2::ECLDataAnalysisModule::m_eclPureClusterPhi
std::vector< double > * m_eclPureClusterPhi
Cluster azimuthal direction, PureCsI option.
Definition ECLDataAnalysisModule.h:396
Belle2::ECLDataAnalysisModule::m_eclClusterCrystalHealth
std::vector< int > * m_eclClusterCrystalHealth
Crystal health flag.
Definition ECLDataAnalysisModule.h:297
Belle2::ECLDataAnalysisModule::m_eclClusterIsTrack
std::vector< bool > * m_eclClusterIsTrack
Flag for charged clusters.
Definition ECLDataAnalysisModule.h:298
Belle2::ECLDataAnalysisModule::eclPureConnectedRegionArrayName
virtual const char * eclPureConnectedRegionArrayName() const
Default name ECLPureConnectedRegions array.
Definition ECLDataAnalysisModule.h:155
Belle2::ECLDataAnalysisModule::m_eclClusterToShower
std::vector< int > * m_eclClusterToShower
Index of ECLShower related to ECLCluster.
Definition ECLDataAnalysisModule.h:282
Belle2::ECLDataAnalysisModule::m_eclCalDigitToMCWeight3
std::vector< double > * m_eclCalDigitToMCWeight3
Energy contribution of third MCParticle related to ECLCalDigit.
Definition ECLDataAnalysisModule.h:203
Belle2::ECLDataAnalysisModule::m_eclCalDigits
StoreArray< ECLCalDigit > m_eclCalDigits
Store array: ECLCalDigit.
Definition ECLDataAnalysisModule.h:95
Belle2::ECLDataAnalysisModule::m_eclpidE9E21
std::vector< double > * m_eclpidE9E21
PID track ration of 3x3 over 5x5 crystal matrices energies.
Definition ECLDataAnalysisModule.h:536
Belle2::ECLDataAnalysisModule::m_eclPureCRIsTrack
std::vector< int > * m_eclPureCRIsTrack
Int for Connected Region - Track Match, PureCsI option.
Definition ECLDataAnalysisModule.h:355
Belle2::ECLDataAnalysisModule::m_eclCRLikelihoodNGamma
std::vector< double > * m_eclCRLikelihoodNGamma
Connected Region Gamma Likelihood.
Definition ECLDataAnalysisModule.h:226
Belle2::ECLDataAnalysisModule::m_eclPureDigitTimeFit
std::vector< int > * m_eclPureDigitTimeFit
ECLDigit timing, PureCsI option.
Definition ECLDataAnalysisModule.h:317
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMC5
std::vector< int > * m_eclPureCalDigitToMC5
Index of fifth MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:339
Belle2::ECLDataAnalysisModule::m_trkPdg
std::vector< int > * m_trkPdg
Track PDG code.
Definition ECLDataAnalysisModule.h:520
Belle2::ECLDataAnalysisModule::m_eclPureCalDigitToMCWeight3
std::vector< double > * m_eclPureCalDigitToMCWeight3
Energy contribution of third MCParticle related to CalDigit, PureCsI option.
Definition ECLDataAnalysisModule.h:334
Belle2::ECLDataAnalysisModule::m_eclClusterDeltaL
std::vector< double > * m_eclClusterDeltaL
Reconstructed Cluster DeltaL.
Definition ECLDataAnalysisModule.h:300
Belle2::ECLDataAnalysisModule::m_mcGGMothPdg
std::vector< int > * m_mcGGMothPdg
MCParticle greand-grandmother particle PDG code.
Definition ECLDataAnalysisModule.h:506
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1MothPDG
std::vector< int > * m_eclShowerToMC1MothPDG
PDG code of parent of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:427
Belle2::ECLDataAnalysisModule::m_nECLCalDigitsOutOfTimeBWD
uint16_t m_nECLCalDigitsOutOfTimeBWD
Number of out of time, energetic ECLCalDigits, BWD.
Definition ECLDataAnalysisModule.h:176
Belle2::ECLDataAnalysisModule::m_eclPidLikelihoods
StoreArray< ECLPidLikelihood > m_eclPidLikelihoods
ECLPidLikelihood storeArray.
Definition ECLDataAnalysisModule.h:91
Belle2::ECLDataAnalysisModule::m_eclPureClusterCrystalHealth
std::vector< int > * m_eclPureClusterCrystalHealth
Crystal health flag, PureCsI option.
Definition ECLDataAnalysisModule.h:407
Belle2::ECLDataAnalysisModule::m_eclShowerPhiError
std::vector< double > * m_eclShowerPhiError
Shower Phi Error.
Definition ECLDataAnalysisModule.h:480
Belle2::ECLDataAnalysisModule::m_eclpidEop
std::vector< double > * m_eclpidEop
PID track E/p.
Definition ECLDataAnalysisModule.h:535
Belle2::ECLDataAnalysisModule::m_eclShowerToMC1GMoth
std::vector< int > * m_eclShowerToMC1GMoth
GMother index of first MCParticle related to ECLShower.
Definition ECLDataAnalysisModule.h:428
Belle2::ECLDataAnalysisModule::m_eclShowerAbsZernike40
std::vector< double > * m_eclShowerAbsZernike40
Shower Zernike40 Moment.
Definition ECLDataAnalysisModule.h:487
Belle2::ECLDataAnalysisModule::m_eclShowerNHits
std::vector< double > * m_eclShowerNHits
Shower NHits.
Definition ECLDataAnalysisModule.h:471
Belle2::ECLDataAnalysisModule::m_eclShowerMultip
int m_eclShowerMultip
Number of ECLShowers per event.
Definition ECLDataAnalysisModule.h:421
Belle2::ECLDataAnalysisModule::m_eclClusterToMCWeight3
std::vector< double > * m_eclClusterToMCWeight3
Energy contribution of third MCParticle related to ECLCluster.
Definition ECLDataAnalysisModule.h:271
Belle2::ECLDigit
Class to store ECL digitized hits (output of ECLDigi) relation to ECLHit filled in ecl/modules/eclDig...
Definition ECLDigit.h:25
Belle2::ECLDigit::getAmp
int getAmp() const
Get Fitting Amplitude.
Definition ECLDigit.h:102
Belle2::ECLDigit::getQuality
int getQuality() const
Get Fitting Quality.
Definition ECLDigit.h:112
Belle2::ECLDigit::getCellId
int getCellId() const
Get Cell ID.
Definition ECLDigit.h:97
Belle2::ECLDigit::getTimeFit
int getTimeFit() const
Get Fitting Time.
Definition ECLDigit.h:107
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:136
Belle2::MCParticle::getIndex
int getIndex() const
Get 1-based index of the particle in the corresponding MCParticle list.
Definition MCParticle.h:219
Belle2::MCParticle::getDecayVertex
ROOT::Math::XYZVector getDecayVertex() const
Return decay vertex.
Definition MCParticle.h:208
Belle2::MCParticle::getArrayIndex
int getArrayIndex() const
Get 0-based index of the particle in the corresponding MCParticle list.
Definition MCParticle.h:234
Belle2::MCParticle::getProductionVertex
ROOT::Math::XYZVector getProductionVertex() const
Return production vertex position.
Definition MCParticle.h:178
Belle2::MCParticle::getPDG
int getPDG() const
Return PDG code of particle.
Definition MCParticle.h:101
Belle2::MCParticle::getMomentum
ROOT::Math::XYZVector getMomentum() const
Return momentum.
Definition MCParticle.h:187
Belle2::MCParticle::getSecondaryPhysicsProcess
int getSecondaryPhysicsProcess() const
Returns the physics process type of a secondary particle.
Definition MCParticle.h:287
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
Belle2::Module::Module
Module()
Constructor.
Definition Module.cc:30
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::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:274
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:559
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Belle2::MCParticle::getMother
MCParticle * getMother() const
Returns a pointer to the mother particle.
Definition MCParticle.h:591
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17
std
STL namespace.