Belle II Software development
TrgEclCluster.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//---------------------------------------------------------------
10// Description :
11// -A class to make cluster from TC Hit
12// -ICN Logic ( function name : setICN(tcid) )
13// Isolate cluster counting logic used in Belle for 3x3 TCs
14//
15// |5|1|6|
16// |2|0|3| ICN = [ 0 and !(1 or 2) and !(4 and 7) ]
17// |7|4|8|
18//
19// 3x3 TC
20//
21// -Clustering Logic (Function name : setICN(tcid, tcenergy, tctiming) )
22// 1.Find TC Hit (0) satisfying ICN logic
23// 2.Find the most energetic TC Hit in the neghbor TCs with 0 (9 TCs)
24// 3.Bind neighbor TC hits with the most energetic TC (Center TC) as a Cluster
25// 4.Cluster energy : Total energy in Cluster
26// 5.Timing : Timing of the most energetic TC in a cluster or Energy weighted timing in a cluster
27//
28// -The limit number of Cluster is 6 due to hardware limitation (ETM)
29// -The cluster information (energy, timing) is saved in the order of barrel, forward endcap and backwrd endcap
30//---------------------------------------------------------------
31
32#define TRG_SHORT_NAMES
33#define TRGECLCLUSTER_SHORT_NAMES
34
35#include <framework/datastore/StoreArray.h>
36
37#include <trg/ecl/TrgEclCluster.h>
38#include "trg/ecl/dataobjects/TRGECLCluster.h"
39
40using namespace std;
41using namespace Belle2;
42//
43//
44//
45TrgEclCluster::TrgEclCluster():
46 _BRICN(0), _FWDICN(0), _BWDICN(0),
47 _BRNofCluster(0), _FWDNofCluster(0), _BWDNofCluster(0),
48 _EventId(0), _Method(1), _LimitNCluster(6), _Position(1)
49{
50 // initialize All parameters
51
52 _icnfwbrbw.clear();
53 _BrCluster.clear();
54 _FwCluster.clear();
55 _BwCluster.clear();
56 _Quadrant.clear();
57
58 TCId.clear();
59 Timing.clear();
60 Energy.clear();
61
62 ClusterTiming.clear();
63 ClusterEnergy.clear();
64 ClusterPositionX.clear();
65 ClusterPositionY.clear();
66 ClusterPositionZ.clear();
67 NofTCinCluster.clear();
68 MaxTCId.clear();
69 TempCluster.clear();
70
71 _icnfwbrbw.resize(3, 0);
72 TempCluster.resize(9);
73 _Quadrant.resize(3, std::vector<int>(4, 0.0));
74
75 ClusterTiming.resize(3);
76 ClusterEnergy.resize(3);
77 ClusterPositionX.resize(3);
78 ClusterPositionY.resize(3);
79 ClusterPositionZ.resize(3);
80 NofTCinCluster.resize(3);
81 MaxTCId.resize(3);
82
83
84 _TCMap = new TrgEclMapping();
85
86
87
88}
89//
90//
91//
92TrgEclCluster::~TrgEclCluster()
93{
94 delete _TCMap;
95}
96//
97//
98//
99int
100TrgEclCluster::getICNFwBr(void)
101{
102 // get ICN in Barrel and Forward Endcap except for the most inner (=Physics region : Theta Id 2 ~ 15)
103 return _icnfwbrbw[0] + _icnfwbrbw[1];
104
105}
106//
107//
108//
109int
110TrgEclCluster::getICNSub(int FwBrBw)
111{
112 // get ICN in Barrel and Backward endcap, Forward Endcap except for the most inner (=Physics region : Theta Id 2 ~ 15)
113
114 return _icnfwbrbw[FwBrBw];
115
116}
117//
118//
119//
120int
121TrgEclCluster::getBrICNCluster(int ICNId, int location)
122{
123 // get the # of Cluster in Barrel.
124 return _BrCluster[ICNId][location];
125
126}
127//
128//
129//
130int
131TrgEclCluster::getBwICNCluster(int ICNId, int location)
132{
133
134 return _BwCluster[ICNId][location];
135
136}
137//
138//
139//
140int
141TrgEclCluster::getFwICNCluster(int ICNId, int location)
142{
143
144 return _FwCluster[ICNId][location];
145
146}
147//
148//
149//
150void
151TrgEclCluster::setICN(const std::vector<int>& tcid)
152{
153 TCId = tcid ;
154 _Quadrant.clear();
155 _Quadrant.resize(3, std::vector<int>(4, 0.0));
156 _icnfwbrbw.clear();
157 _icnfwbrbw.resize(3, 0);
158 _BRICN = 0 ;
159 _FWDICN = 0;
160 _BWDICN = 0;
161
162 _icnfwbrbw[1] = setBarrelICN();
163 _icnfwbrbw[0] = setForwardICN();
164 _icnfwbrbw[2] = setBackwardICN();
165
166 return;
167}
168//
169//
170//
171void
172TrgEclCluster::setICN(const std::vector<int>& tcid,
173 const std::vector<double>& tcenergy,
174 const std::vector<double>& tctiming)
175{
176 TCId = tcid ;
177 Energy = tcenergy;
178 Timing = tctiming;
179
180 setBarrelICN(_Method);
181 setForwardICN(_Method);
182 setBackwardICN(_Method);
183
184 save(_EventId);
185
186 return;
187}
188//
189//
190//
191void
192TrgEclCluster::save(int m_nEvent)
193{
194 // Save Cluster
195 // Save order : Barrel, Forward, Backward
196
197 int m_hitNum = 0;
198 int clusterId = 0;
199 int counter = 0;
200 for (int iposition = 0; iposition < 3 ; iposition ++) {
201 const int Ncluster = ClusterEnergy[iposition].size();
202 for (int icluster = 0; icluster < Ncluster; icluster++) {
203 if (ClusterEnergy[iposition][icluster] <= 0) {continue;}
204
205 if (counter >= _LimitNCluster) {
206 continue;
207 } else {
208 counter ++;
209 }
210
211 StoreArray<TRGECLCluster> ClusterArray;
212 ClusterArray.appendNew();
213 m_hitNum = ClusterArray.getEntries() - 1;
214 ClusterArray[m_hitNum]->setEventId(m_nEvent);
215 ClusterArray[m_hitNum]->setClusterId(clusterId);
216 ClusterArray[m_hitNum]->setMaxTCId(MaxTCId[iposition][icluster]);
217 ClusterArray[m_hitNum]->setMaxThetaId(_TCMap->getTCThetaIdFromTCId(MaxTCId[iposition][icluster]));
218 ClusterArray[m_hitNum]->setMaxPhiId(_TCMap->getTCPhiIdFromTCId(MaxTCId[iposition][icluster]));
219 ClusterArray[m_hitNum]->setNofTCinCluster(NofTCinCluster[iposition][icluster]);
220 ClusterArray[m_hitNum]->setEnergyDep(ClusterEnergy[iposition][icluster]);
221 ClusterArray[m_hitNum]->setTimeAve(ClusterTiming[iposition][icluster]);
222
223 ClusterArray[m_hitNum]->setPositionX(ClusterPositionX[iposition][icluster]);
224 ClusterArray[m_hitNum]->setPositionY(ClusterPositionY[iposition][icluster]);
225 ClusterArray[m_hitNum]->setPositionZ(ClusterPositionZ[iposition][icluster]);
226 clusterId ++;
227 }
228 }
229
230
231}
232//
233//
234//
235void TrgEclCluster::setBarrelICN(int Method)
236{
237
238 std::vector<int> TCFire;
239 std::vector<double> TCFireEnergy;
240 std::vector<double> TCFireTiming;
241 std::vector<std::vector<double>> TCFirePosition;
242
243 TCFire.clear();
244 TCFireEnergy.clear();
245 TCFireTiming.clear();
246 TCFirePosition.clear();
247
248 TCFire.resize(432, 0);
249 TCFireEnergy.resize(432, 0.);
250 TCFireTiming.resize(432, 0.);
251 TCFirePosition.resize(432, std::vector<double>(3, 0.));
252
253 const int hit_size = TCId.size();
254 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
255 if (TCId[ihit] >= 81 && TCId[ihit] <= 512) {
256 TCFire[TCId[ihit] - 81] = TCId[ihit];
257 TCFireEnergy[TCId[ihit] - 81] = Energy[ihit];
258 TCFireTiming[TCId[ihit] - 81] = Timing[ihit];
259 TCFirePosition[TCId[ihit] - 81][0] = (_TCMap->getTCPosition(TCId[ihit])).X();
260 TCFirePosition[TCId[ihit] - 81][1] = (_TCMap->getTCPosition(TCId[ihit])).Y();
261 TCFirePosition[TCId[ihit] - 81][2] = (_TCMap->getTCPosition(TCId[ihit])).Z();
262 }
263 }
264 //
265 //
266 //
267 int tc_upper = 0; // check upper TC
268 int tc_upper_right = 0; // check right TC
269 int tc_right = 0; // check right TC
270 int tc_lower_right = 0;
271 int tc_lower = 0; // check lower TC
272 int tc_lower_left = 0; // check lower TC
273 int tc_left = 0;
274 int tc_upper_left = 0;
275
276 for (int iii = 0 ; iii < 432 ; iii++) {
277
278 if (TCFire[iii] == 0) { continue; }
279
280 setBarrelICNsub(iii,
281 TCFire,
282 tc_upper,
283 tc_upper_right,
284 tc_right,
285 tc_lower_right,
286 tc_lower,
287 tc_lower_left,
288 tc_left,
289 tc_upper_left);
290
291 if (!(tc_upper != 0 || tc_left != 0)) {
292 if (!(tc_lower != 0 && tc_lower_left != 0)) {
293
294 if (Method == 1) {
295 // for cluster method2(Consider TC energy in oderto find the center of cluster)
296 int maxTCid = 0;
297 double maxTCEnergy = 0;
298 for (int iTC = 0; iTC < 9; iTC++) { //find center of Cluster
299 if (TempCluster[iTC] == 0) {continue;}
300 if (maxTCEnergy < TCFireEnergy[TempCluster[iTC] - 81]) {
301 maxTCEnergy = TCFireEnergy[TempCluster[iTC] - 81];
302 maxTCid = TempCluster[iTC];
303 }
304 }
305 TempCluster[0] = maxTCid;
306
307 if (maxTCid < 93) {
308
309 TempCluster[1] = TCFire[maxTCid + 420 - 81 ] ;
310 TempCluster[2] = TCFire[maxTCid + 419 - 81 ] ;
311 TempCluster[3] = TCFire[maxTCid - 1 - 81 ] ;
312 TempCluster[4] = TCFire[maxTCid + 11 - 81 ] ;
313 TempCluster[5] = TCFire[maxTCid + 12 - 81 ] ;
314 TempCluster[6] = TCFire[maxTCid + 13 - 81 ] ;
315 TempCluster[7] = TCFire[maxTCid + 1 - 81 ] ;
316 TempCluster[8] = TCFire[maxTCid + 421 - 81 ] ;
317
318 if ((maxTCid - 81) % 12 == 0) {
319 TempCluster[2] = 0 ;
320 TempCluster[3] = 0 ;
321 TempCluster[4] = 0 ;
322 }
323 if ((maxTCid - 81) % 12 == 11) {
324 TempCluster[6] = 0 ;
325 TempCluster[7] = 0 ;
326 TempCluster[8] = 0 ;
327 }
328 }
329 if (maxTCid > 92 && maxTCid < 501) {
330
331 TempCluster[1] = TCFire[maxTCid - 12 - 81] ;
332 // cppcheck-suppress negativeContainerIndex
333 TempCluster[2] = TCFire[maxTCid - 13 - 81] ;
334 TempCluster[3] = TCFire[maxTCid - 1 - 81] ;
335 TempCluster[4] = TCFire[maxTCid + 11 - 81] ;
336 TempCluster[5] = TCFire[maxTCid + 12 - 81] ;
337 TempCluster[6] = TCFire[maxTCid + 13 - 81] ;
338 TempCluster[7] = TCFire[maxTCid + 1 - 81] ;
339 TempCluster[8] = TCFire[maxTCid - 11 - 81] ;
340
341 if ((maxTCid - 81) % 12 == 0) {
342 TempCluster[2] = 0;
343 TempCluster[3] = 0;
344 TempCluster[4] = 0;
345 }
346 if ((maxTCid - 81) % 12 == 11) {
347 TempCluster[6] = 0;
348 TempCluster[7] = 0;
349 TempCluster[8] = 0;
350 }
351 }
352 if (maxTCid > 500) {
353 TempCluster[1] = TCFire[maxTCid - 12 - 81] ;
354 TempCluster[2] = TCFire[maxTCid - 13 - 81] ;
355 TempCluster[3] = TCFire[maxTCid - 1 - 81] ;
356 // cppcheck-suppress negativeContainerIndex
357 TempCluster[4] = TCFire[maxTCid - 421 - 81] ;
358 TempCluster[5] = TCFire[maxTCid - 420 - 81] ;
359 TempCluster[6] = TCFire[maxTCid - 419 - 81] ;
360 TempCluster[7] = TCFire[maxTCid + 1 - 81] ;
361 TempCluster[8] = TCFire[maxTCid - 11 - 81] ;
362 if ((maxTCid - 81) % 12 == 0) {
363 TempCluster[2] = 0 ;
364 TempCluster[3] = 0 ;
365 TempCluster[4] = 0 ;
366 }
367 if ((maxTCid - 81) % 12 == 11) {
368 TempCluster[6] = 0 ;
369 TempCluster[7] = 0 ;
370 TempCluster[8] = 0 ;
371 }
372 }
373 }
374
375 for (int iNearTC = 1; iNearTC < 9; iNearTC ++) {
376 for (int jNearTC = 1; jNearTC < 9; jNearTC ++) {
377 if (TempCluster[iNearTC] == 0) {continue;}
378 if (iNearTC == jNearTC) {continue;}
379 if (TempCluster[iNearTC] == TempCluster[jNearTC]) {
380 TempCluster[jNearTC] = 0;
381 }
382 }
383 }
384
385 int maxTCId = 999;
386 double clusterenergy = 0;
387 double clustertiming = 0;
388 double clusterpositionX = 0;
389 double clusterpositionY = 0;
390 double clusterpositionZ = 0;
391 int noftcincluster = 0;
392 for (int iNearTC = 0; iNearTC < 9; iNearTC ++) {
393 if (TempCluster[iNearTC] == 0) {continue;}
394 else {noftcincluster++;}
395 clusterenergy += TCFireEnergy[TempCluster[iNearTC] - 81];
396 clustertiming += TCFireEnergy[TempCluster[iNearTC] - 81] * TCFireTiming[TempCluster[iNearTC] - 81];
397 clusterpositionX += TCFireEnergy[TempCluster[iNearTC] - 81] * TCFirePosition[TempCluster[iNearTC] - 81][0];
398 clusterpositionY += TCFireEnergy[TempCluster[iNearTC] - 81] * TCFirePosition[TempCluster[iNearTC] - 81][1];
399 clusterpositionZ += TCFireEnergy[TempCluster[iNearTC] - 81] * TCFirePosition[TempCluster[iNearTC] - 81][2];
400 }
401 //
402 maxTCId = TempCluster[0];
403 //
404 clustertiming /= clusterenergy;
405 if (_Position == 1) {
406 clusterpositionX /= clusterenergy;
407 clusterpositionY /= clusterenergy;
408 clusterpositionZ /= clusterenergy;
409 } else if (_Position == 0) {
410 clustertiming = TCFireTiming[maxTCId - 81];
411 clusterpositionX = TCFirePosition[maxTCId - 81][0];
412 clusterpositionY = TCFirePosition[maxTCId - 81][1];
413 clusterpositionZ = TCFirePosition[maxTCId - 81][2];
414 }
415 if (clustertiming == 0 && clusterenergy == 0) {continue;}
416 _BrCluster.push_back(TempCluster);
417 ClusterEnergy[0].push_back(clusterenergy);
418 ClusterTiming[0].push_back(clustertiming);
419 ClusterPositionX[0].push_back(clusterpositionX);
420 ClusterPositionY[0].push_back(clusterpositionY);
421 ClusterPositionZ[0].push_back(clusterpositionZ);
422 NofTCinCluster[0].push_back(noftcincluster);
423 MaxTCId[0].push_back(maxTCId);
424 }
425 }
426 }// iii loop
427 _BRNofCluster = MaxTCId[0].size();
428
429}
430//
431//
432//
433void
434TrgEclCluster::setForwardICN(int Method)
435{
436
437 std::vector<int> TCFire;
438 std::vector<double> TCFireEnergy;
439 std::vector<double> TCFireTiming;
440 std::vector<std::vector<double>> TCFirePosition;
441
442 std::vector<double> TempClusterEnergy;
443 std::vector<double> TempClusterTiming;
444 std::vector<double> TempClusterPositionX;
445 std::vector<double> TempClusterPositionY;
446 std::vector<double> TempClusterPositionZ;
447 std::vector<double> Sort1D;
448 std::vector<std::vector<double>> Sort2D;
449
450 std::vector<int> TempNofTCinCluster;
451 std::vector<int> TempMaxTCId;
452
453 int TempICNTCId = 0;;
454
455 TempClusterEnergy.clear();
456 TempClusterTiming.clear();
457 TempClusterPositionX.clear();
458 TempClusterPositionY.clear();
459 TempClusterPositionZ.clear();
460 TempNofTCinCluster.clear();
461 TempMaxTCId.clear();
462
463 Sort2D.clear();
464 Sort1D.clear();
465
466 TCFire.clear();
467 TCFireEnergy.clear();
468 TCFireTiming.clear();
469 TCFirePosition.clear();
470
471 TCFire.resize(96, 0);
472 TCFireEnergy.resize(96, 0.);
473 TCFireTiming.resize(96, 0.);
474
475 TCFirePosition.resize(96, std::vector<double>(3, 0.));
476
477
478 const int hit_size = TCId.size();
479 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
480 if (TCId[ihit] > 80) {continue;}
481
482 TCFireEnergy[TCId[ihit] - 1] = Energy[ihit];
483 TCFireTiming[TCId[ihit] - 1] = Timing[ihit];
484 TCFirePosition[TCId[ihit] - 1][0] = (_TCMap->getTCPosition(TCId[ihit])).X();
485 TCFirePosition[TCId[ihit] - 1][1] = (_TCMap->getTCPosition(TCId[ihit])).Y();
486 TCFirePosition[TCId[ihit] - 1][2] = (_TCMap->getTCPosition(TCId[ihit])).Z();
487
488 //------------------------------------
489 // To rearrange the hitted map
490 //
491 // orignal converted
492 // (<- Theta) (<- Theta)
493 //
494 // 3 2 1 64 32 0
495 // 4 5 - 65 33 1
496 // 8 7 6 => 66 34 2
497 // 9 10 - 67 35 3
498 // .... ...
499 // 78 77 76 94 62 30
500 // 79 80 - 95 63 31
501 //
502 // Here, TCId-1 becomes TCId=0 and 1.
503 //------------------------------------
504 int iTCId0 = TCId[ihit] - 1;
505 int kkk = 0;
506 if (iTCId0 % 5 == 0) {
507 kkk = (iTCId0 / 5) * 2;
508 TCFire[kkk] = TCId[ihit];
509 TCFire[kkk + 1] = TCId[ihit];
510 } else {
511 kkk = iTCId0 / 5;
512 switch (iTCId0 % 5) {
513 case 1 :
514 TCFire[32 + 2 * kkk] = TCId[ihit]; break;
515 case 2 :
516 TCFire[64 + 2 * kkk] = TCId[ihit]; break;
517 case 3 :
518 TCFire[64 + 2 * kkk + 1] = TCId[ihit]; break;
519 case 4 :
520 TCFire[32 + 2 * kkk + 1] = TCId[ihit]; break;
521 default:
522 break;
523 }
524 }
525 }
526
527 for (int iii = 0 ; iii < 96 ; iii++) {
528 int icn_flag = 0;
529 if (iii < 32) {
530 if (iii % 2 == 1) {
531 continue;
532 }
533 }
534 for (int iinit = 0; iinit < 9; iinit ++)
535 TempCluster[iinit] = 0;
536 if (TCFire[iii] == 0)
537 continue;
538 // cppcheck-suppress knownConditionTrueFalse
539 if (iii < 32) { // most inner
540 if (iii == 0) {
541 TempCluster[0] = TCFire[iii];
542 TempCluster[1] = TCFire[30]; // top
543 TempCluster[2] = TCFire[63]; // left up
544 TempCluster[3] = TCFire[iii + 32] ; // left 1
545 TempCluster[4] = TCFire[iii + 33]; // left 2
546 TempCluster[5] = TCFire[iii + 34]; // left bottom
547 TempCluster[6] = TCFire[iii + 2]; // bottom
548 TempCluster[7] = 0;
549 TempCluster[8] = 0;
550
551 } else if (iii == 30) {
552 TempCluster[0] = TCFire[iii];
553 TempCluster[1] = TCFire[iii - 2]; // top
554 TempCluster[2] = TCFire[iii + 31]; // left up
555 TempCluster[3] = TCFire[iii + 32] ; // left 1
556 TempCluster[4] = TCFire[iii + 33]; // left 2
557 TempCluster[5] = TCFire[32]; // left bottom
558 TempCluster[6] = TCFire[0]; // bottom
559 TempCluster[7] = 0;
560 TempCluster[8] = 0;
561
562 } else {
563 TempCluster[0] = TCFire[iii];
564 TempCluster[1] = TCFire[iii - 2]; // top
565 TempCluster[2] = TCFire[iii + 31]; // left up
566 TempCluster[3] = TCFire[iii + 32] ; // left 1
567 TempCluster[4] = TCFire[iii + 33]; // left 2
568 TempCluster[5] = TCFire[iii + 34]; // left bottom
569 TempCluster[6] = TCFire[iii + 2]; // bottom
570 TempCluster[7] = 0;
571 TempCluster[8] = 0;
572
573 }
574 if (!(TempCluster[1] != 0 || (TempCluster[3] != 0 || TempCluster[4] != 0))) {
575 if (!(TempCluster[5] != 0 && TempCluster[6] != 0)) {
576 icn_flag = 1;
577
578
579 }
580 }
581
582 } else if (iii < 64) {
583 if (iii == 32) {
584 TempCluster[0] = TCFire[iii];
585 TempCluster[1] = TCFire[63]; // up
586 TempCluster[2] = TCFire[iii - 2]; // up right
587 TempCluster[3] = TCFire[iii - 32]; // right
588 TempCluster[4] = 0; //right bottom
589 TempCluster[5] = TCFire[iii + 1]; // bottom
590 TempCluster[6] = TCFire[iii + 33]; // left bottom
591 TempCluster[7] = TCFire[iii + 32]; // left
592 TempCluster[8] = TCFire[95]; // up left
593
594 } else if (iii == 33) {
595
596 TempCluster[0] = TCFire[iii];
597 TempCluster[1] = TCFire[iii - 1]; // up
598 TempCluster[2] = 0; // up right
599 TempCluster[3] = TCFire[iii - 32]; // right
600 TempCluster[4] = TCFire[iii - 30]; //right bottom
601 TempCluster[5] = TCFire[iii + 1]; // bottom
602 TempCluster[6] = TCFire[iii + 33]; // left bottom
603 TempCluster[7] = TCFire[iii + 32]; // left
604 TempCluster[8] = TCFire[iii + 31]; // up left
605
606 }
607
608 else if (iii == 62) {
609 TempCluster[0] = TCFire[iii];
610 TempCluster[1] = TCFire[iii - 1]; // up
611 TempCluster[2] = TCFire[iii - 34]; // up right
612 TempCluster[3] = TCFire[iii - 32]; // right
613 TempCluster[4] = 0; //right bottom
614 TempCluster[5] = TCFire[iii + 1]; // bottom
615 TempCluster[6] = TCFire[iii + 33]; // left bottom
616 TempCluster[7] = TCFire[iii + 32]; // left
617 TempCluster[8] = TCFire[iii + 31]; // up left
618
619
620 } else if (iii == 63) {
621 TempCluster[0] = TCFire[iii];
622 TempCluster[1] = TCFire[iii - 1]; // up
623 TempCluster[2] = 0; // up right
624 TempCluster[3] = TCFire[iii - 32]; // right
625 TempCluster[4] = TCFire[1]; //right bottom
626 TempCluster[5] = TCFire[32]; // bottom
627 TempCluster[6] = TCFire[64]; // left bottom
628 TempCluster[7] = TCFire[iii + 32]; // left
629 TempCluster[8] = TCFire[iii + 31]; // up left
630
631 }
632
633 else {
634
635 TempCluster[0] = TCFire[iii];
636 TempCluster[1] = TCFire[iii - 1]; // up
637 TempCluster[2] = TCFire[iii - 34]; // up right
638 TempCluster[3] = TCFire[iii - 32]; // right
639 TempCluster[4] = TCFire[iii - 30]; //right bottom
640 TempCluster[5] = TCFire[iii + 1]; // bottom
641 TempCluster[6] = TCFire[iii + 33]; // left bottom
642 TempCluster[7] = TCFire[iii + 32]; // left
643 TempCluster[8] = TCFire[iii + 31]; // up left
644 if (iii % 2 == 0) {
645 TempCluster[4] = 0;
646 } else {
647 TempCluster[2] = 0;
648 }
649 }
650 if (!(TempCluster[1] != 0 || TempCluster[7] != 0)) {
651 if (!(TempCluster[5] != 0 && TempCluster[6] != 0)) {
652 icn_flag = 1;
653 }
654 }
655
656 } else {
657 if (iii == 64) {
658 TempCluster[0] = TCFire[iii];
659 TempCluster[1] = TCFire[95]; // top
660 TempCluster[2] = TCFire[63];// right top
661 TempCluster[3] = TCFire[iii - 32]; //right
662 TempCluster[4] = TCFire[iii - 31]; //right bottom
663 TempCluster[5] = TCFire[iii + 1]; //bottom
664 TempCluster[6] = 0; //bottom left
665 TempCluster[7] = 0; // left
666 TempCluster[8] = 0; //top left
667 } else if (iii == 95) {
668 TempCluster[0] = TCFire[iii];
669 TempCluster[1] = TCFire[iii - 1]; // top
670 TempCluster[2] = TCFire[iii - 33]; // right top
671 TempCluster[3] = TCFire[iii - 32]; //right
672 TempCluster[4] = TCFire[32]; //right bottom
673 TempCluster[5] = TCFire[64]; //bottom
674 TempCluster[6] = 0; //bottom left
675 TempCluster[7] = 0; // left
676 TempCluster[8] = 0; //top left
677
678 } else {
679 TempCluster[0] = TCFire[iii];
680 TempCluster[1] = TCFire[iii - 1]; // top
681 TempCluster[2] = TCFire[iii - 33]; // right top
682 TempCluster[3] = TCFire[iii - 32]; //right
683 TempCluster[4] = TCFire[iii - 31]; //right bottom
684 TempCluster[5] = TCFire[iii + 1]; //bottom
685 TempCluster[6] = 0; //bottom left
686 TempCluster[7] = 0; // left
687 TempCluster[8] = 0; //top left
688 }
689 if (!(TempCluster[1] != 0 || TempCluster[7] != 0)) {
690 if (!(TempCluster[5] != 0 && TempCluster[6] != 0)) {
691 icn_flag = 1;
692
693 }
694 }
695
696
697 }
698
699 if (icn_flag == 1) {
700 TempICNTCId = TCFire[iii];
701
702 if (Method == 1) { //for cluster method2
703 int maxTCid = 0;
704 double maxTCEnergy = 0;
705 for (int iTC = 0; iTC < 9; iTC++) { //find center of Cluster
706 if (TempCluster[iTC] == 0) {continue;}
707 if (maxTCEnergy < TCFireEnergy[TempCluster[iTC] - 1]) {
708 maxTCEnergy = TCFireEnergy[TempCluster[iTC] - 1];
709 maxTCid = TempCluster[iTC];
710 }
711 }
712 TempCluster.resize(9, 0);
713 TempCluster[0] = maxTCid;
714 int kkk = (TempCluster[0] - 1) / 5;
715 if ((TempCluster[0] - 1) % 5 == 0) {
716 kkk = kkk * 2;
717 } else if ((TempCluster[0] - 1) % 5 == 1) {
718 kkk = 32 + 2 * kkk;
719 } else if ((TempCluster[0] - 1) % 5 == 2) {
720 kkk = 64 + 2 * kkk;
721 } else if ((TempCluster[0] - 1) % 5 == 3) {
722 kkk = 64 + 1 + 2 * kkk;
723 } else if ((TempCluster[0] - 1) % 5 == 4) {
724 kkk = 32 + 1 + 2 * kkk;
725 }
726
727 if (kkk < 32) { // most inner
728 if (kkk == 0) {
729 TempCluster[0] = TCFire[kkk];
730 TempCluster[1] = TCFire[30]; // top
731 TempCluster[2] = TCFire[63]; // left up
732 TempCluster[3] = TCFire[kkk + 32] ; // left 1
733 TempCluster[4] = TCFire[kkk + 33]; // left 2
734 TempCluster[5] = TCFire[kkk + 34]; // left bottom
735 TempCluster[6] = TCFire[kkk + 2]; // bottom
736 TempCluster[7] = 0;
737 TempCluster[8] = 0;
738
739 } else if (kkk == 30) {
740 TempCluster[0] = TCFire[kkk];
741 TempCluster[1] = TCFire[kkk - 2]; // top
742 TempCluster[2] = TCFire[kkk + 31]; // left up
743 TempCluster[3] = TCFire[kkk + 32] ; // left 1
744 TempCluster[4] = TCFire[kkk + 33]; // left 2
745 TempCluster[5] = TCFire[32]; // left bottom
746 TempCluster[6] = TCFire[0]; // bottom
747 TempCluster[7] = 0;
748 TempCluster[8] = 0;
749
750 } else {
751 TempCluster[0] = TCFire[kkk];
752 TempCluster[1] = TCFire[kkk - 2]; // top
753 TempCluster[2] = TCFire[kkk + 31]; // left up
754 TempCluster[3] = TCFire[kkk + 32] ; // left 1
755 TempCluster[4] = TCFire[kkk + 33]; // left 2
756 TempCluster[5] = TCFire[kkk + 34]; // left bottom
757 TempCluster[6] = TCFire[kkk + 2]; // bottom
758 TempCluster[7] = 0;
759 TempCluster[8] = 0;
760
761 }
762
763 } else if (kkk < 64) {
764 if (kkk == 32) {
765 TempCluster[0] = TCFire[kkk];
766 TempCluster[1] = TCFire[63]; // up
767 TempCluster[2] = TCFire[kkk - 2]; // up right
768 TempCluster[3] = TCFire[kkk - 32]; // right
769 TempCluster[4] = 0; //right bottom
770 TempCluster[5] = TCFire[kkk + 1]; // bottom
771 TempCluster[6] = TCFire[kkk + 33]; // left bottom
772 TempCluster[7] = TCFire[kkk + 32]; // left
773 TempCluster[8] = TCFire[95]; // up left
774
775 } else if (kkk == 33) {
776
777 TempCluster[0] = TCFire[kkk];
778 TempCluster[1] = TCFire[kkk - 1]; // up
779 TempCluster[2] = 0; // up right
780 TempCluster[3] = TCFire[kkk - 32]; // right
781 TempCluster[4] = TCFire[kkk - 30]; //right bottom
782 TempCluster[5] = TCFire[kkk + 1]; // bottom
783 TempCluster[6] = TCFire[kkk + 33]; // left bottom
784 TempCluster[7] = TCFire[kkk + 32]; // left
785 TempCluster[8] = TCFire[kkk + 31]; // up left
786
787 }
788
789 else if (kkk == 62) {
790 TempCluster[0] = TCFire[kkk];
791 TempCluster[1] = TCFire[kkk - 1]; // up
792 TempCluster[2] = TCFire[kkk - 34]; // up right
793 TempCluster[3] = TCFire[kkk - 32]; // right
794 TempCluster[4] = 0; //right bottom
795 TempCluster[5] = TCFire[kkk + 1]; // bottom
796 TempCluster[6] = TCFire[kkk + 33]; // left bottom
797 TempCluster[7] = TCFire[kkk + 32]; // left
798 TempCluster[8] = TCFire[kkk + 31]; // up left
799
800
801 } else if (kkk == 63) {
802 TempCluster[0] = TCFire[kkk];
803 TempCluster[1] = TCFire[kkk - 1]; // up
804 TempCluster[2] = 0; // up right
805 TempCluster[3] = TCFire[kkk - 32]; // right
806 TempCluster[4] = TCFire[1]; //right bottom
807 TempCluster[5] = TCFire[32]; // bottom
808 TempCluster[6] = TCFire[64]; // left bottom
809 TempCluster[7] = TCFire[kkk + 32]; // left
810 TempCluster[8] = TCFire[kkk + 31]; // up left
811
812 }
813
814 else {
815 TempCluster[0] = TCFire[kkk];
816 TempCluster[1] = TCFire[kkk - 1]; // up
817 TempCluster[2] = TCFire[kkk - 34]; // up right
818 TempCluster[3] = TCFire[kkk - 32]; // right
819 TempCluster[4] = TCFire[kkk - 30]; //right bottom
820 TempCluster[5] = TCFire[kkk + 1]; // bottom
821 TempCluster[6] = TCFire[kkk + 33]; // left bottom
822 TempCluster[7] = TCFire[kkk + 32]; // left
823 TempCluster[8] = TCFire[kkk + 31]; // up left
824 if (kkk % 2 == 0) {
825 TempCluster[4] = 0;
826 } else {
827 TempCluster[2] = 0;
828 }
829
830 }
831
832
833
834 } else {
835 if (kkk == 64) {
836 TempCluster[0] = TCFire[kkk];
837 TempCluster[1] = TCFire[95]; // top
838 TempCluster[2] = TCFire[63];// right top
839 TempCluster[3] = TCFire[kkk - 32]; //right
840 TempCluster[4] = TCFire[kkk - 31]; //right bottom
841 TempCluster[5] = TCFire[kkk + 1]; //bottom
842 TempCluster[6] = 0; //bottom left
843 TempCluster[7] = 0; // left
844 TempCluster[8] = 0; //top left
845 } else if (kkk == 95) {
846 TempCluster[0] = TCFire[kkk];
847 TempCluster[1] = TCFire[kkk - 1]; // top
848 TempCluster[2] = TCFire[kkk - 33]; // right top
849 TempCluster[3] = TCFire[kkk - 32]; //right
850 TempCluster[4] = TCFire[32]; //right bottom
851 TempCluster[5] = TCFire[64]; //bottom
852 TempCluster[6] = 0; //bottom left
853 TempCluster[7] = 0; // left
854 TempCluster[8] = 0; //top left
855
856 } else {
857 TempCluster[0] = TCFire[kkk];
858 TempCluster[1] = TCFire[kkk - 1]; // top
859 TempCluster[2] = TCFire[kkk - 33]; // right top
860 TempCluster[3] = TCFire[kkk - 32]; //right
861 TempCluster[4] = TCFire[kkk - 31]; //right bottom
862 TempCluster[5] = TCFire[kkk + 1]; //bottom
863 TempCluster[6] = 0; //bottom left
864 TempCluster[7] = 0; // left
865 TempCluster[8] = 0; //top left
866 }
867
868 }
869 }
870 for (int iNearTC = 1; iNearTC < 9; iNearTC ++) {
871 for (int jNearTC = 1; jNearTC < 9; jNearTC ++) {
872 if (TempCluster[iNearTC] == 0) {continue;}
873 if (iNearTC == jNearTC)continue;
874 if (TempCluster[iNearTC] == TempCluster[jNearTC]) {
875 TempCluster[jNearTC] = 0;
876 }
877 }
878 }
879
880 int maxTCId = 999;
881 double clusterenergy = 0;
882 double clustertiming = 0;
883 double clusterpositionX = 0;
884 double clusterpositionY = 0;
885 double clusterpositionZ = 0;
886 int noftcincluster = 0;
887 for (int iNearTC = 0; iNearTC < 9; iNearTC ++) {
888 if (TempCluster[iNearTC] == 0) {continue;}
889 else {noftcincluster++;}
890 clusterenergy += TCFireEnergy[TempCluster[iNearTC] - 1];
891 clustertiming += TCFireEnergy[TempCluster[iNearTC] - 1] * TCFireTiming[TempCluster[iNearTC] - 1];
892 clusterpositionX += TCFireEnergy[TempCluster[iNearTC] - 1] * TCFirePosition[TempCluster[iNearTC] - 1][0];
893 clusterpositionY += TCFireEnergy[TempCluster[iNearTC] - 1] * TCFirePosition[TempCluster[iNearTC] - 1][1];
894 clusterpositionZ += TCFireEnergy[TempCluster[iNearTC] - 1] * TCFirePosition[TempCluster[iNearTC] - 1][2];
895
896 }
897 //
898 maxTCId = TempCluster[0];
899 //
900
901 clustertiming /= clusterenergy;
902 if (_Position == 1) {
903 clusterpositionX /= clusterenergy;
904 clusterpositionY /= clusterenergy;
905 clusterpositionZ /= clusterenergy;
906 } else if (_Position == 0) {
907 clustertiming = TCFireTiming[maxTCId - 1];
908 clusterpositionX = TCFirePosition[maxTCId - 1][0];
909 clusterpositionY = TCFirePosition[maxTCId - 1][1];
910 clusterpositionZ = TCFirePosition[maxTCId - 1][2];
911 }
912 if (clustertiming == 0 && clusterenergy == 0) {continue;}
913
914 TempClusterEnergy.push_back(clusterenergy);
915 TempClusterTiming.push_back(clustertiming);
916 TempClusterPositionX.push_back(clusterpositionX);
917 TempClusterPositionY.push_back(clusterpositionY);
918 TempClusterPositionZ.push_back(clusterpositionZ);
919 TempNofTCinCluster.push_back(noftcincluster);
920 TempMaxTCId.push_back(maxTCId);
921
922 Sort1D.push_back(TempICNTCId);
923 Sort1D.push_back(clusterenergy);
924 Sort1D.push_back(clustertiming);
925 Sort1D.push_back(clusterpositionX);
926 Sort1D.push_back(clusterpositionY);
927 Sort1D.push_back(clusterpositionZ);
928 Sort1D.push_back(noftcincluster);
929 Sort1D.push_back(maxTCId);
930
931 Sort2D.push_back(Sort1D);
932 Sort1D.clear();
933
934 }
935
936 }
937
938 // Sorting in the order of TC Id
939
940 sort(Sort2D.begin(), Sort2D.end(),
941 [](const vector<double>& aa1, const vector<double>& aa2) {return aa1[0] < aa2[0];});
942
943 const int clustersize = Sort2D.size();
944 for (int jtc = 0; jtc < clustersize; jtc++) {
945
946 ClusterEnergy[1].push_back(Sort2D[jtc][1]);
947 ClusterTiming[1].push_back(Sort2D[jtc][2]);
948 ClusterPositionX[1].push_back(Sort2D[jtc][3]);
949 ClusterPositionY[1].push_back(Sort2D[jtc][4]);
950 ClusterPositionZ[1].push_back(Sort2D[jtc][5]);
951 NofTCinCluster[1].push_back(Sort2D[jtc][6]);
952 MaxTCId[1].push_back(Sort2D[jtc][7]);
953 }
954
955 _FWDNofCluster = MaxTCId[1].size();
956}
957//
958//
959//
960void TrgEclCluster::setBackwardICN(int Method)
961{
962 std::vector<int> TCFire;
963 std::vector<double> TCFireEnergy;
964 std::vector<double> TCFireTiming;
965 std::vector<std::vector<double>> TCFirePosition;
966
967
968 std::vector<double> TempClusterEnergy;
969 std::vector<double> TempClusterTiming;
970 std::vector<double> TempClusterPositionX;
971 std::vector<double> TempClusterPositionY;
972 std::vector<double> TempClusterPositionZ;
973 std::vector<int> TempNofTCinCluster;
974 std::vector<int> TempMaxTCId;
975
976 std::vector<double> Sort1D;
977 std::vector<std::vector<double>> Sort2D;
978
979 int TempICNTCId = 0;
980
981 TempClusterEnergy.clear();
982 TempClusterTiming.clear();
983 TempClusterPositionX.clear();
984 TempClusterPositionY.clear();
985 TempClusterPositionZ.clear();
986 TempNofTCinCluster.clear();
987 TempMaxTCId.clear();
988 Sort1D.clear();
989 Sort2D.clear();
990
991 TCFire.clear();
992 TCFireEnergy.clear();
993 TCFireTiming.clear();
994 TCFirePosition.clear();
995
996 TCFire.resize(64, 0);
997 TCFireEnergy.resize(64, 0.);
998 TCFireTiming.resize(64, 0.);
999 TCFirePosition.resize(64, std::vector<double>(3, 0.));
1000
1001 const int hit_size = TCId.size();
1002 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1003 if (TCId[ihit] < 513) {continue;}
1004 TCFireEnergy[TCId[ihit] - 513] = Energy[ihit];
1005 TCFireTiming[TCId[ihit] - 513] = Timing[ihit];
1006 TCFirePosition[TCId[ihit] - 513][0] = (_TCMap->getTCPosition(TCId[ihit])).X();
1007 TCFirePosition[TCId[ihit] - 513][1] = (_TCMap->getTCPosition(TCId[ihit])).Y();
1008 TCFirePosition[TCId[ihit] - 513][2] = (_TCMap->getTCPosition(TCId[ihit])).Z();
1009
1010 //------------------------------------
1011 // To rearrange the hitted map
1012 //
1013 // orignal converted
1014 // (<- Theta) (<- Theta)
1015 //
1016 // 516 515 32 0
1017 // 513 514 33 1
1018 // 520 519 => 34 2
1019 // 517 518 35 3
1020 // ... .
1021 // 576 575 62 30
1022 // 573 574 63 31
1023 //
1024 // Here, TCId-1 becomes TCId=0 and 1.
1025 //------------------------------------
1026 int iTCId0 = TCId[ihit] - 1;
1027 int kkk = 0;
1028 if ((iTCId0 - 512) % 4 == 2) {
1029 kkk = (iTCId0 - 512) / 2 - 1;
1030 }
1031 if ((iTCId0 - 512) % 4 == 1) {
1032 kkk = ((iTCId0 - 512) + 1) / 2;
1033 }
1034 if ((iTCId0 - 512) % 4 == 3) {
1035 kkk = 32 + ((iTCId0 - 512) - 3) / 2;
1036 }
1037 if ((iTCId0 - 512) % 4 == 0) {
1038 kkk = 33 + ((iTCId0 - 512)) / 2;
1039 }
1040
1041 TCFire[kkk] = iTCId0 + 1;
1042
1043 }
1044
1045
1046 for (int iii = 0 ; iii < 64 ; iii ++) {
1047
1048 if (TCFire[iii] == 0) { continue; }
1049
1050 for (int iinit = 0; iinit < 9; iinit ++) {TempCluster[iinit] = 0;}
1051 if (iii < 32) {
1052 if (iii == 0) {
1053 TempCluster[0] = TCFire[ 0];
1054 TempCluster[1] = TCFire[31]; // top
1055 TempCluster[2] = 0;// right top
1056 TempCluster[3] = 0; //right
1057 TempCluster[4] = 0; //right bottom
1058 TempCluster[5] = TCFire[ 1]; // bottom
1059 TempCluster[6] = TCFire[33]; // bottom left
1060 TempCluster[7] = TCFire[32]; // left
1061 TempCluster[8] = TCFire[63]; // top left
1062 } else if (iii == 31) {
1063 TempCluster[0] = TCFire[31];
1064 TempCluster[1] = TCFire[30];
1065 TempCluster[2] = 0;// right top
1066 TempCluster[3] = 0; //right
1067 TempCluster[4] = 0; //right bottom
1068 TempCluster[5] = TCFire[0]; //bottom
1069 TempCluster[6] = TCFire[32]; // bottom left
1070 TempCluster[7] = TCFire[63]; // left
1071 TempCluster[8] = TCFire[62]; //top left
1072 } else {
1073 TempCluster[0] = TCFire[iii];
1074 TempCluster[1] = TCFire[iii - 1]; // top
1075 TempCluster[2] = 0;// right top
1076 TempCluster[3] = 0; //right
1077 TempCluster[4] = 0; //right bottom
1078 TempCluster[5] = TCFire[iii + 1]; //bottom
1079 TempCluster[6] = TCFire[iii + 33]; //bottom left
1080 TempCluster[7] = TCFire[iii + 32]; // left
1081 TempCluster[8] = TCFire[iii + 31]; //top left
1082 }
1083 } else {
1084 if (iii == 32) {
1085 TempCluster[0] = TCFire[32];
1086 TempCluster[1] = TCFire[63]; // top
1087 TempCluster[2] = TCFire[31];// right top
1088 TempCluster[3] = TCFire[0]; //right
1089 TempCluster[4] = TCFire[1]; //right bottom
1090 TempCluster[5] = TCFire[33]; //bottom
1091 TempCluster[6] = 0; //bottom left
1092 TempCluster[7] = 0; // left
1093 TempCluster[8] = 0; //top left
1094 } else if (iii == 63) {
1095 TempCluster[0] = TCFire[63];
1096 TempCluster[1] = TCFire[62]; // top
1097 TempCluster[2] = TCFire[30];// right top
1098 TempCluster[3] = TCFire[31]; //right
1099 TempCluster[4] = TCFire[0]; //right bottom
1100 TempCluster[5] = TCFire[32]; //bottom
1101 TempCluster[6] = 0; //bottom left
1102 TempCluster[7] = 0; // left
1103 TempCluster[8] = 0; //top left
1104 } else {
1105 TempCluster[0] = TCFire[iii];
1106 TempCluster[1] = TCFire[iii - 1]; // top
1107 TempCluster[2] = TCFire[iii - 33]; // right top
1108 TempCluster[3] = TCFire[iii - 32]; //right
1109 TempCluster[4] = TCFire[iii - 31]; //right bottom
1110 TempCluster[5] = TCFire[iii + 1]; //bottom
1111 TempCluster[6] = 0; //bottom left
1112 TempCluster[7] = 0; // left
1113 TempCluster[8] = 0; //top left
1114 }
1115
1116 }
1117
1118 if (!(TempCluster[1] != 0 || TempCluster[7] != 0)) {
1119 if (!(TempCluster[5] != 0 && TempCluster[6] != 0)) {
1120 TempICNTCId = TCFire[iii];
1121
1122 if (Method == 1) {
1123 int maxTCid = 0;
1124 double maxTCEnergy = 0;
1125 for (int iTC = 0; iTC < 9; iTC++) { //find center of Cluster
1126 if (TempCluster[iTC] == 0) {continue;}
1127 if (maxTCEnergy < TCFireEnergy[TempCluster[iTC] - 513]) {
1128 maxTCEnergy = TCFireEnergy[TempCluster[iTC] - 513];
1129 maxTCid = TempCluster[iTC];
1130 }
1131 }
1132 int kkk = 0;
1133 TempCluster[0] = maxTCid;
1134 if ((TempCluster[0] - 513) % 4 == 2) {
1135 kkk = (TempCluster[0] - 513) / 2 - 1;
1136 }
1137 if ((TempCluster[0] - 513) % 4 == 1) {
1138 kkk = ((TempCluster[0] - 513) + 1) / 2;
1139 }
1140 if ((TempCluster[0] - 513) % 4 == 3) {
1141 kkk = 32 + ((TempCluster[0] - 513) - 3) / 2;
1142 }
1143 if ((TempCluster[0] - 513) % 4 == 0) {
1144 kkk = 33 + ((TempCluster[0] - 513)) / 2;
1145 }
1146
1147 if (kkk < 32) {
1148 if (kkk == 0) {
1149 TempCluster[0] = TCFire[ 0];
1150 TempCluster[1] = TCFire[31]; // top
1151 TempCluster[2] = 0;// right top
1152 TempCluster[3] = 0; //right
1153 TempCluster[4] = 0; //right bottom
1154 TempCluster[5] = TCFire[ 1]; // bottom
1155 TempCluster[6] = TCFire[33]; // bottom left
1156 TempCluster[7] = TCFire[32]; // left
1157 TempCluster[8] = TCFire[63]; // top left
1158 } else if (kkk == 31) {
1159 TempCluster[0] = TCFire[31];
1160 TempCluster[1] = TCFire[30];
1161 TempCluster[2] = 0;// right top
1162 TempCluster[3] = 0; //right
1163 TempCluster[4] = 0; //right bottom
1164 TempCluster[5] = TCFire[0]; //bottom
1165 TempCluster[6] = TCFire[32]; // bottom left
1166 TempCluster[7] = TCFire[63]; // left
1167 TempCluster[8] = TCFire[62]; //top left
1168 } else {
1169 TempCluster[0] = TCFire[kkk];
1170 TempCluster[1] = TCFire[kkk - 1]; // top
1171 TempCluster[2] = 0;// right top
1172 TempCluster[3] = 0; //right
1173 TempCluster[4] = 0; //right bottom
1174 TempCluster[5] = TCFire[kkk + 1]; //bottom
1175 TempCluster[6] = TCFire[kkk + 33]; //bottom left
1176 TempCluster[7] = TCFire[kkk + 32]; // left
1177 TempCluster[8] = TCFire[kkk + 31]; //top left
1178 }
1179 } else {
1180 if (kkk == 32) {
1181 TempCluster[0] = TCFire[32];
1182 TempCluster[1] = TCFire[63]; // top
1183 TempCluster[2] = TCFire[31];// right top
1184 TempCluster[3] = TCFire[0]; //right
1185 TempCluster[4] = TCFire[1]; //right bottom
1186 TempCluster[5] = TCFire[33]; //bottom
1187 TempCluster[6] = 0; //bottom left
1188 TempCluster[7] = 0; // left
1189 TempCluster[8] = 0; //top left
1190 } else if (kkk == 63) {
1191 TempCluster[0] = TCFire[63];
1192 TempCluster[1] = TCFire[62]; // top
1193 TempCluster[2] = TCFire[30];// right top
1194 TempCluster[3] = TCFire[31]; //right
1195 TempCluster[4] = TCFire[0]; //right bottom
1196 TempCluster[5] = TCFire[32]; //bottom
1197 TempCluster[6] = 0; //bottom left
1198 TempCluster[7] = 0; // left
1199 TempCluster[8] = 0; //top left
1200 } else {
1201 TempCluster[0] = TCFire[kkk];
1202 TempCluster[1] = TCFire[kkk - 1]; // top
1203 TempCluster[2] = TCFire[kkk - 33]; // right top
1204 TempCluster[3] = TCFire[kkk - 32]; //right
1205 TempCluster[4] = TCFire[kkk - 31]; //right bottom
1206 TempCluster[5] = TCFire[kkk + 1]; //bottom
1207 TempCluster[6] = 0; //bottom left
1208 TempCluster[7] = 0; // left
1209 TempCluster[8] = 0; //top left
1210 }
1211
1212 }
1213 }
1214
1215 for (int iNearTC = 1; iNearTC < 9; iNearTC ++) {
1216 for (int jNearTC = 1; jNearTC < 9; jNearTC ++) {
1217 if (TempCluster[iNearTC] == 0) {continue;}
1218 if (iNearTC == jNearTC) {continue;}
1219 if (TempCluster[iNearTC] == TempCluster[jNearTC]) {
1220 TempCluster[jNearTC] = 0;
1221 }
1222 }
1223 }
1224
1225 int maxTCId = 999;
1226 double clusterenergy = 0;
1227 double clustertiming = 0;
1228 double clusterpositionX = 0;
1229 double clusterpositionY = 0;
1230 double clusterpositionZ = 0;
1231 int noftcincluster = 0;
1232 for (int iNearTC = 0; iNearTC < 9; iNearTC ++) {
1233 if (TempCluster[iNearTC] == 0) {continue;}
1234 else {noftcincluster++;}
1235
1236 clusterenergy += TCFireEnergy[TempCluster[iNearTC] - 513];
1237 clustertiming += TCFireEnergy[TempCluster[iNearTC] - 513] * TCFireTiming[TempCluster[iNearTC] - 513];
1238 clusterpositionX += TCFireEnergy[TempCluster[iNearTC] - 513] * TCFirePosition[TempCluster[iNearTC] - 513][0];
1239 clusterpositionY += TCFireEnergy[TempCluster[iNearTC] - 513] * TCFirePosition[TempCluster[iNearTC] - 513][1];
1240 clusterpositionZ += TCFireEnergy[TempCluster[iNearTC] - 513] * TCFirePosition[TempCluster[iNearTC] - 513][2];
1241
1242
1243 }
1244 //
1245 maxTCId = TempCluster[0];
1246 //
1247
1248 clustertiming /= clusterenergy;
1249 if (_Position == 1) {
1250 clusterpositionX /= clusterenergy;
1251 clusterpositionY /= clusterenergy;
1252 clusterpositionZ /= clusterenergy;
1253 } else if (_Position == 0) {
1254 clustertiming = TCFireTiming[maxTCId - 513];
1255 clusterpositionX = TCFirePosition[maxTCId - 513][0];
1256 clusterpositionY = TCFirePosition[maxTCId - 513][1];
1257 clusterpositionZ = TCFirePosition[maxTCId - 513][2];
1258 }
1259
1260 if (clustertiming == 0 && clusterenergy == 0) {continue;}
1261 TempClusterEnergy.push_back(clusterenergy);
1262 TempClusterTiming.push_back(clustertiming);
1263 TempClusterPositionX.push_back(clusterpositionX);
1264 TempClusterPositionY.push_back(clusterpositionY);
1265 TempClusterPositionZ.push_back(clusterpositionZ);
1266 TempNofTCinCluster.push_back(noftcincluster);
1267 TempMaxTCId.push_back(maxTCId);
1268
1269
1270 Sort1D.push_back(TempICNTCId);
1271 Sort1D.push_back(clusterenergy);
1272 Sort1D.push_back(clustertiming);
1273 Sort1D.push_back(clusterpositionX);
1274 Sort1D.push_back(clusterpositionY);
1275 Sort1D.push_back(clusterpositionZ);
1276 Sort1D.push_back(noftcincluster);
1277 Sort1D.push_back(maxTCId);
1278
1279 Sort2D.push_back(Sort1D);
1280 Sort1D.clear();
1281
1282
1283 }
1284 }
1285 }
1286
1287 sort(Sort2D.begin(), Sort2D.end(),
1288 [](const vector<double>& aa1, const vector<double>& aa2) {return aa1[0] < aa2[0];});
1289
1290 const int clustersize = Sort2D.size();
1291 for (int jtc = 0; jtc < clustersize; jtc++) {
1292 ClusterEnergy[2].push_back(Sort2D[jtc][1]);
1293 ClusterTiming[2].push_back(Sort2D[jtc][2]);
1294 ClusterPositionX[2].push_back(Sort2D[jtc][3]);
1295 ClusterPositionY[2].push_back(Sort2D[jtc][4]);
1296 ClusterPositionZ[2].push_back(Sort2D[jtc][5]);
1297 NofTCinCluster[2].push_back(Sort2D[jtc][6]);
1298 MaxTCId[2].push_back(Sort2D[jtc][7]);
1299 }
1300
1301 _BWDNofCluster = MaxTCId[2].size();
1302}
1303//
1304//
1305//
1306int
1307TrgEclCluster::setBarrelICN()
1308{
1309
1310 std::vector<int> TCFire;
1311
1312 TCFire.clear();
1313
1314 TCFire.resize(432, 0);
1315
1316 const int hit_size = TCId.size();
1317 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1318 if (TCId[ihit] >= 81 && TCId[ihit] <= 512) {
1319 TCFire[TCId[ihit] - 81] = TCId[ihit];
1320 }
1321 }
1322 //
1323 //
1324 //
1325 int tc_upper = 0; // check upper TC
1326 int tc_upper_right = 0; // check right TC
1327 int tc_right = 0; // check right TC
1328 int tc_lower_right = 0;
1329 int tc_lower = 0; // check lower TC
1330 int tc_lower_left = 0; // check lower TC
1331 int tc_left = 0;
1332 int tc_upper_left = 0;
1333
1334 for (int iii = 0 ; iii < 432 ; iii++) {
1335 if (TCFire[iii] == 0) { continue; }
1336
1337 setBarrelICNsub(iii,
1338 TCFire,
1339 tc_upper,
1340 tc_upper_right,
1341 tc_right,
1342 tc_lower_right,
1343 tc_lower,
1344 tc_lower_left,
1345 tc_left,
1346 tc_upper_left);
1347
1348 if (!(tc_upper != 0 || tc_left != 0)) {
1349 if (!(tc_lower != 0 && tc_lower_left != 0)) {
1350 _BRICN++;
1351 int phiid = _TCMap->getTCPhiIdFromTCId(iii + 80 + 1);
1352
1353 if (phiid == 36 || (phiid > 0 && phiid < 11)) {
1354 _Quadrant[1][0]++;
1355 }
1356 if (phiid > 8 && phiid < 20) {
1357 _Quadrant[1][1]++;
1358 }
1359 if (phiid > 17 && phiid < 29) {
1360 _Quadrant[1][2]++;
1361 }
1362 if ((phiid > 26 && phiid < 37) || phiid == 1) {
1363 _Quadrant[1][3]++;
1364 }
1365
1366 }
1367 }// iii loop
1368 }
1369 return _BRICN;
1370
1371}
1372//
1373//
1374//
1375void
1376TrgEclCluster::setBarrelICNsub(int iii,
1377 std::vector<int> TCFire,
1378 int& tc_upper,
1379 int& tc_upper_right,
1380 int& tc_right,
1381 int& tc_lower_right,
1382 int& tc_lower,
1383 int& tc_lower_left,
1384 int& tc_left,
1385 int& tc_upper_left)
1386{
1387 // take into account TCId jump at boundary between FAM-9 and FAM-44
1388 int offset_upper = 0;
1389 int offset_lower = 0;
1390 if (iii <= 11) {
1391 // FAM-9
1392 offset_upper = 432;
1393 offset_lower = 0;
1394 } else if (iii <= 419) {
1395 // FAM-10 to FAM-43
1396 offset_upper = 0;
1397 offset_lower = 0;
1398 } else {
1399 // FAM-44
1400 offset_upper = 0;
1401 offset_lower = -432;
1402 }
1403
1404 // take into account TC at boundary near endcaps
1405 if (iii % 12 == 0) {
1406 // TC at most forward side
1407 tc_upper = TCFire[iii - 12 + offset_upper];
1408 tc_upper_right = 0;
1409 tc_right = 0;
1410 tc_lower_right = 0;
1411 tc_lower = TCFire[iii + 12 + offset_lower];
1412 tc_lower_left = TCFire[iii + 13 + offset_lower];
1413 tc_left = TCFire[iii + 1];
1414 tc_upper_left = TCFire[iii - 11 + offset_upper];
1415 } else if (iii % 12 == 11) {
1416 // TC at most backward side
1417 tc_upper = TCFire[iii - 12 + offset_upper];
1418 tc_upper_right = TCFire[iii - 13 + offset_upper];
1419 tc_right = TCFire[iii - 1];
1420 tc_lower_right = TCFire[iii + 11 + offset_lower];
1421 tc_lower = TCFire[iii + 12 + offset_lower];
1422 tc_lower_left = 0;
1423 tc_left = 0;
1424 tc_upper_left = 0;
1425 } else {
1426 tc_upper = TCFire[iii - 12 + offset_upper];
1427 tc_upper_right = TCFire[iii - 13 + offset_upper];
1428 tc_right = TCFire[iii - 1];
1429 tc_lower_right = TCFire[iii + 11 + offset_lower];
1430 tc_lower = TCFire[iii + 12 + offset_lower];
1431 tc_lower_left = TCFire[iii + 13 + offset_lower];
1432 tc_left = TCFire[iii + 1];
1433 tc_upper_left = TCFire[iii - 11 + offset_upper];
1434 }
1435
1436 TempCluster[0] = iii + 80 + 1; //middle of ICN
1437 TempCluster[1] = tc_upper; // upper
1438 TempCluster[2] = tc_upper_right; //right
1439 TempCluster[3] = tc_right; //right
1440 TempCluster[4] = tc_lower_right; //lower
1441 TempCluster[5] = tc_lower; //lower
1442 TempCluster[6] = tc_lower_left; //lower
1443 TempCluster[7] = tc_left; //lower
1444 TempCluster[8] = tc_upper_left; //lower right;
1445}
1446//
1447//
1448//
1449int
1450TrgEclCluster::setForwardICN()
1451{
1452
1453 std::vector<int> TCFire;
1454
1455
1456 TCFire.clear();
1457
1458 TCFire.resize(96, 0);
1459
1460
1461 const int hit_size = TCId.size();
1462 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1463 if (TCId[ihit] > 80) {continue;}
1464
1465
1466 //------------------------------------
1467 // To rearrange the hitted map
1468 //
1469 // orignal converted
1470 // (<- Theta) (<- Theta)
1471 //
1472 // 3 2 1 64 32 0
1473 // 4 5 - 65 33 1
1474 // 8 7 6 => 66 34 2
1475 // 9 10 - 67 35 3
1476 // .... ...
1477 // 78 77 76 94 62 30
1478 // 79 80 - 95 63 31
1479 //
1480 // Here, TCId-1 becomes TCId=0 and 1.
1481 //------------------------------------
1482 int iTCId0 = TCId[ihit] - 1;
1483 int kkk = 0;
1484 if (iTCId0 % 5 == 0) {
1485 kkk = (iTCId0 / 5) * 2;
1486 TCFire[kkk] = TCId[ihit];
1487 TCFire[kkk + 1] = TCId[ihit];
1488 } else {
1489 kkk = iTCId0 / 5;
1490 switch (iTCId0 % 5) {
1491 case 1 :
1492 TCFire[32 + 2 * kkk] = TCId[ihit]; break;
1493 case 2 :
1494 TCFire[64 + 2 * kkk] = TCId[ihit]; break;
1495 case 3 :
1496 TCFire[64 + 2 * kkk + 1] = TCId[ihit]; break;
1497 case 4 :
1498 TCFire[32 + 2 * kkk + 1] = TCId[ihit]; break;
1499 default:
1500 break;
1501 }
1502 }
1503 }
1504
1505
1506 for (int iii = 32 ; iii < 96 ; iii++) {
1507 for (int iinit = 0; iinit < 9; iinit ++) {TempCluster[iinit] = 0;}
1508 if (TCFire[iii] == 0) { continue; }
1509 if (iii < 64) {
1510 if (iii == 32) {
1511 TempCluster[0] = TCFire[iii];
1512 TempCluster[1] = TCFire[63]; // top
1513 TempCluster[2] = 0;// right top
1514 TempCluster[3] = 0; //right
1515 TempCluster[4] = 0; //right bottom
1516 TempCluster[5] = TCFire[iii + 1]; //bottom
1517 TempCluster[6] = TCFire[iii + 33]; //bottom left
1518 TempCluster[7] = TCFire[iii + 32]; // left
1519 TempCluster[8] = TCFire[95]; //top left
1520 } else if (iii == 63) {
1521 TempCluster[0] = TCFire[iii];
1522 TempCluster[1] = TCFire[iii - 1]; // top
1523 TempCluster[2] = 0; // right top
1524 TempCluster[3] = 0; //right
1525 TempCluster[4] = 0; //right bottom
1526 TempCluster[5] = TCFire[32]; //bottom
1527 TempCluster[6] = TCFire[64]; //bottom left
1528 TempCluster[7] = TCFire[iii + 32]; // left
1529 TempCluster[8] = TCFire[iii + 31]; //top left
1530 } else {
1531 TempCluster[0] = TCFire[iii];
1532 TempCluster[1] = TCFire[iii - 1]; // top
1533 TempCluster[2] = 0; // right top
1534 TempCluster[3] = 0; //right
1535 TempCluster[4] = 0; //right bottom
1536 TempCluster[5] = TCFire[iii + 1]; //bottom
1537 TempCluster[6] = TCFire[iii + 33]; //bottom left
1538 TempCluster[7] = TCFire[iii + 32]; // left
1539 TempCluster[8] = TCFire[iii + 31]; //top left
1540 }
1541 } else {
1542 if (iii == 64) {
1543 TempCluster[0] = TCFire[iii];
1544 TempCluster[1] = TCFire[95]; // top
1545 TempCluster[2] = TCFire[63];// right top
1546 TempCluster[3] = TCFire[iii - 32]; //right
1547 TempCluster[4] = TCFire[iii - 31]; //right bottom
1548 TempCluster[5] = TCFire[iii + 1]; //bottom
1549 TempCluster[6] = 0; //bottom left
1550 TempCluster[7] = 0; // left
1551 TempCluster[8] = 0; //top left
1552 } else if (iii == 95) {
1553 TempCluster[0] = TCFire[iii];
1554 TempCluster[1] = TCFire[iii - 1]; // top
1555 TempCluster[2] = TCFire[iii - 33]; // right top
1556 TempCluster[3] = TCFire[iii - 32]; //right
1557 TempCluster[4] = TCFire[32]; //right bottom
1558 TempCluster[5] = TCFire[64]; //bottom
1559 TempCluster[6] = 0; //bottom left
1560 TempCluster[7] = 0; // left
1561 TempCluster[8] = 0; //top left
1562
1563 } else {
1564 TempCluster[0] = TCFire[iii];
1565 TempCluster[1] = TCFire[iii - 1]; // top
1566 TempCluster[2] = TCFire[iii - 33]; // right top
1567 TempCluster[3] = TCFire[iii - 32]; //right
1568 TempCluster[4] = TCFire[iii - 31]; //right bottom
1569 TempCluster[5] = TCFire[iii + 1]; //bottom
1570 TempCluster[6] = 0; //bottom left
1571 TempCluster[7] = 0; // left
1572 TempCluster[8] = 0; //top left
1573 }
1574
1575 }
1576 if (!(TempCluster[1] != 0 || TempCluster[7] != 0)) {
1577 if (!(TempCluster[5] != 0 && TempCluster[6] != 0)) {
1578 _FWDICN++;
1579 int phiid = _TCMap->getTCPhiIdFromTCId(TCFire[iii]);
1580
1581 if (phiid == 32 || (phiid > 0 && phiid < 10)) {
1582 _Quadrant[0][0]++;
1583 }
1584 if (phiid > 7 && phiid < 18) {
1585 _Quadrant[0][1]++;
1586 }
1587 if (phiid > 15 && phiid < 26) {
1588 _Quadrant[0][2]++;
1589 }
1590 if ((phiid > 22 && phiid < 33) || phiid == 1) {
1591 _Quadrant[0][3]++;
1592 }
1593
1594
1595 }
1596 }
1597 }
1598 return _FWDICN;
1599}
1600//
1601//
1602//
1603int TrgEclCluster::setBackwardICN()
1604{
1605 std::vector<int> TCFire;
1606
1607
1608 TCFire.clear();
1609
1610 TCFire.resize(64, 0);
1611
1612
1613
1614 const int hit_size = TCId.size();
1615 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1616 if (TCId[ihit] < 513) {continue;}
1617
1618 // TCFire[TCId[ihit] - 513] = TCId[ihit];
1619 //------------------------------------
1620 // To rearrange the hitted map
1621 //
1622 // orignal converted
1623 // (<- Theta) (<- Theta)
1624 //
1625 // 516 515 32 0
1626 // 513 514 33 1
1627 // 520 519 => 34 2
1628 // 517 518 35 3
1629 // ... .
1630 // 576 575 62 30
1631 // 573 574 63 31
1632 //
1633 // Here, TCId-1 becomes TCId=0 and 1.
1634 //------------------------------------
1635 int iTCId0 = TCId[ihit] - 1;
1636 int kkk = 0;
1637 if ((iTCId0 - 512) % 4 == 2) {
1638 kkk = (iTCId0 - 512) / 2 - 1;
1639 }
1640 if ((iTCId0 - 512) % 4 == 1) {
1641 kkk = ((iTCId0 - 512) + 1) / 2;
1642 }
1643 if ((iTCId0 - 512) % 4 == 3) {
1644 kkk = 32 + ((iTCId0 - 512) - 3) / 2;
1645 }
1646 if ((iTCId0 - 512) % 4 == 0) {
1647 kkk = 33 + ((iTCId0 - 512)) / 2;
1648 }
1649
1650 TCFire[kkk] = iTCId0 + 1;
1651
1652 }
1653
1654
1655 for (int iii = 0 ; iii < 64 ; iii ++) {
1656
1657 if (TCFire[iii] == 0) { continue; }
1658
1659 for (int iinit = 0; iinit < 9; iinit ++) {TempCluster[iinit] = 0;}
1660 if (iii < 32) {
1661 if (iii == 0) {
1662 TempCluster[0] = TCFire[ 0];
1663 TempCluster[1] = TCFire[31]; // top
1664 TempCluster[2] = 0;// right top
1665 TempCluster[3] = 0; //right
1666 TempCluster[4] = 0; //right bottom
1667 TempCluster[5] = TCFire[ 1]; // bottom
1668 TempCluster[6] = TCFire[33]; // bottom left
1669 TempCluster[7] = TCFire[32]; // left
1670 TempCluster[8] = TCFire[63]; // top left
1671 } else if (iii == 31) {
1672 TempCluster[0] = TCFire[31];
1673 TempCluster[1] = TCFire[30];
1674 TempCluster[2] = 0;// right top
1675 TempCluster[3] = 0; //right
1676 TempCluster[4] = 0; //right bottom
1677 TempCluster[5] = TCFire[0]; //bottom
1678 TempCluster[6] = TCFire[32]; // bottom left
1679 TempCluster[7] = TCFire[63]; // left
1680 TempCluster[8] = TCFire[62]; //top left
1681 } else {
1682 TempCluster[0] = TCFire[iii];
1683 TempCluster[1] = TCFire[iii - 1]; // top
1684 TempCluster[2] = 0;// right top
1685 TempCluster[3] = 0; //right
1686 TempCluster[4] = 0; //right bottom
1687 TempCluster[5] = TCFire[iii + 1]; //bottom
1688 TempCluster[6] = TCFire[iii + 33]; //bottom left
1689 TempCluster[7] = TCFire[iii + 32]; // left
1690 TempCluster[8] = TCFire[iii + 31]; //top left
1691 }
1692 } else {
1693 if (iii == 32) {
1694 TempCluster[0] = TCFire[32];
1695 TempCluster[1] = TCFire[63]; // top
1696 TempCluster[2] = TCFire[31];// right top
1697 TempCluster[3] = TCFire[0]; //right
1698 TempCluster[4] = TCFire[1]; //right bottom
1699 TempCluster[5] = TCFire[33]; //bottom
1700 TempCluster[6] = 0; //bottom left
1701 TempCluster[7] = 0; // left
1702 TempCluster[8] = 0; //top left
1703 } else if (iii == 63) {
1704 TempCluster[0] = TCFire[63];
1705 TempCluster[1] = TCFire[62]; // top
1706 TempCluster[2] = TCFire[30];// right top
1707 TempCluster[3] = TCFire[31]; //right
1708 TempCluster[4] = TCFire[0]; //right bottom
1709 TempCluster[5] = TCFire[32]; //bottom
1710 TempCluster[6] = 0; //bottom left
1711 TempCluster[7] = 0; // left
1712 TempCluster[8] = 0; //top left
1713 } else {
1714 TempCluster[0] = TCFire[iii];
1715 TempCluster[1] = TCFire[iii - 1]; // top
1716 TempCluster[2] = TCFire[iii - 33]; // right top
1717 TempCluster[3] = TCFire[iii - 32]; //right
1718 TempCluster[4] = TCFire[iii - 31]; //right bottom
1719 TempCluster[5] = TCFire[iii + 1]; //bottom
1720 TempCluster[6] = 0; //bottom left
1721 TempCluster[7] = 0; // left
1722 TempCluster[8] = 0; //top left
1723 }
1724
1725 }
1726
1727 if (!(TempCluster[1] != 0 || TempCluster[7] != 0)) {
1728 if (!(TempCluster[5] != 0 && TempCluster[6] != 0)) {
1729 _BWDICN ++;
1730 int phiid = _TCMap->getTCPhiIdFromTCId(TCFire[iii]);
1731
1732 if (phiid == 32 || (phiid > 0 && phiid < 10)) {
1733 _Quadrant[2][0]++;
1734 }
1735 if (phiid > 7 && phiid < 18) {
1736 _Quadrant[2][1]++;
1737 }
1738 if (phiid > 15 && phiid < 26) {
1739 _Quadrant[2][2]++;
1740 }
1741 if ((phiid > 22 && phiid < 33) || phiid == 1) {
1742 _Quadrant[2][3]++;
1743 }
1744
1745
1746 }
1747 }
1748 }
1749
1750 return _BWDICN;
1751}
1752//
1753//
1754//
1755int TrgEclCluster::getNofExceedCluster()
1756{
1757 int ncluster =
1758 ClusterEnergy[0].size() +
1759 ClusterEnergy[1].size() +
1760 ClusterEnergy[2].size();
1761 if (ncluster > _LimitNCluster) {
1762 return ncluster;
1763 } else {
1764 return 0;
1765 }
1766}
1767//
1768//===<END>
1769//
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:246
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
Belle2::TrgEclCluster::save
void save(int)
Save Cluster information in TRGECLCluster Table.
Definition: TrgEclCluster.cc:192
Belle2::TrgEclCluster::_Position
int _Position
Position calculation method(0:Most energetic TC Postion, 1 : Energy weighted Postion)
Definition: TrgEclCluster.h:128
Belle2::TrgEclCluster::setICN
void setICN(const std::vector< int > &)
set ICN for each part(Fw,Br,Bw)
Definition: TrgEclCluster.cc:151
Belle2::TrgEclCluster::_Quadrant
std::vector< std::vector< int > > _Quadrant
Quadrant for Beam Backgournd veto.
Definition: TrgEclCluster.h:141
Belle2::TrgEclCluster::_BRNofCluster
int _BRNofCluster
Cluster in Barrel.
Definition: TrgEclCluster.h:116
Belle2::TrgEclCluster::NofTCinCluster
std::vector< std::vector< int > > NofTCinCluster
N of TC in Cluster
Definition: TrgEclCluster.h:163
Belle2::TrgEclCluster::TempCluster
std::vector< int > TempCluster
Temporal Cluster.
Definition: TrgEclCluster.h:167
Belle2::TrgEclCluster::getICNSub
int getICNSub(int)
get ICN in each region(Fw(0), Br(1), Bw(2))
Definition: TrgEclCluster.cc:110
Belle2::TrgEclCluster::_BWDNofCluster
int _BWDNofCluster
Cluster in Backward Endcap.
Definition: TrgEclCluster.h:120
Belle2::TrgEclCluster::_FwCluster
std::vector< std::vector< int > > _FwCluster
cluster in forward endcap
Definition: TrgEclCluster.h:146
Belle2::TrgEclCluster::getICNFwBr
int getICNFwBr(void)
get ICN in Barrel and Forward
Definition: TrgEclCluster.cc:100
Belle2::TrgEclCluster::ClusterPositionX
std::vector< std::vector< double > > ClusterPositionX
Cluster position in X-axis.
Definition: TrgEclCluster.h:157
Belle2::TrgEclCluster::getNofExceedCluster
int getNofExceedCluster()
get # Cluster in case of exceeding limit
Definition: TrgEclCluster.cc:1755
Belle2::TrgEclCluster::setBarrelICN
int setBarrelICN()
calculate Belle ICN in Barrel
Definition: TrgEclCluster.cc:1307
Belle2::TrgEclCluster::setBackwardICN
int setBackwardICN()
calculate Belle ICN in Backward endcap
Definition: TrgEclCluster.cc:1603
Belle2::TrgEclCluster::ClusterPositionZ
std::vector< std::vector< double > > ClusterPositionZ
Cluster position in Z-axis.
Definition: TrgEclCluster.h:161
Belle2::TrgEclCluster::_icnfwbrbw
std::vector< int > _icnfwbrbw
icn
Definition: TrgEclCluster.h:132
Belle2::TrgEclCluster::_BwCluster
std::vector< std::vector< int > > _BwCluster
cluster in backward endcap
Definition: TrgEclCluster.h:148
Belle2::TrgEclCluster::getBrICNCluster
int getBrICNCluster(int ICNId, int)
get ICN in QuadrantId in Fw or Br or Bw.
Definition: TrgEclCluster.cc:121
Belle2::TrgEclCluster::setForwardICN
int setForwardICN()
calculate Belle ICN in Foward endcap
Definition: TrgEclCluster.cc:1450
Belle2::TrgEclCluster::getFwICNCluster
int getFwICNCluster(int ICNId, int)
0 : center , 1; upper , 2: right , 3: lower , 4: lower right
Definition: TrgEclCluster.cc:141
Belle2::TrgEclCluster::setBarrelICNsub
void setBarrelICNsub(int, std::vector< int >, int &, int &, int &, int &, int &, int &, int &, int &)
calculate 3x3 TC hit map for ICN in Barrel
Definition: TrgEclCluster.cc:1376
Belle2::TrgEclCluster::_Method
int _Method
Clustering method.
Definition: TrgEclCluster.h:124
Belle2::TrgEclCluster::_BRICN
int _BRICN
get Beam bkg veto flag.
Definition: TrgEclCluster.h:110
Belle2::TrgEclCluster::ClusterPositionY
std::vector< std::vector< double > > ClusterPositionY
Cluster position in Y-axis.
Definition: TrgEclCluster.h:159
Belle2::TrgEclCluster::_FWDNofCluster
int _FWDNofCluster
Cluster in Forward Endcap.
Definition: TrgEclCluster.h:118
Belle2::TrgEclCluster::~TrgEclCluster
virtual ~TrgEclCluster()
Constructor.
Definition: TrgEclCluster.cc:92
Belle2::TrgEclCluster::TrgEclCluster
TrgEclCluster()
Constructor.
Definition: TrgEclCluster.cc:45
Belle2::TrgEclCluster::MaxTCId
std::vector< std::vector< int > > MaxTCId
Maximum contribution TC Id in Cluster.
Definition: TrgEclCluster.h:165
Belle2::TrgEclCluster::_LimitNCluster
int _LimitNCluster
the Limit Number of Cluster
Definition: TrgEclCluster.h:126
Belle2::TrgEclCluster::getBwICNCluster
int getBwICNCluster(int ICNId, int)
0 : center , 1; upper , 2: right , 3: lower , 4: lower right
Definition: TrgEclCluster.cc:131
Belle2::TrgEclCluster::_EventId
int _EventId
event number
Definition: TrgEclCluster.h:122
Belle2::TrgEclCluster::ClusterTiming
std::vector< std::vector< double > > ClusterTiming
Cluster timing.
Definition: TrgEclCluster.h:153
Belle2::TrgEclCluster::ClusterEnergy
std::vector< std::vector< double > > ClusterEnergy
Cluster enrgy
Definition: TrgEclCluster.h:155
Belle2::TrgEclCluster::_FWDICN
int _FWDICN
ICN in Forward Endcap.
Definition: TrgEclCluster.h:112
Belle2::TrgEclCluster::_TCMap
TrgEclMapping * _TCMap
Object of TC Mapping.
Definition: TrgEclCluster.h:169
Belle2::TrgEclCluster::_BWDICN
int _BWDICN
ICN in Backward Endcap.
Definition: TrgEclCluster.h:114
Belle2::TrgEclCluster::TCId
std::vector< int > TCId
TC Id.
Definition: TrgEclCluster.h:134
Belle2::TrgEclCluster::_BrCluster
std::vector< std::vector< int > > _BrCluster
cluster in barrel
Definition: TrgEclCluster.h:144
Belle2::TrgEclCluster::Energy
std::vector< double > Energy
TC energy
Definition: TrgEclCluster.h:138
Belle2::TrgEclCluster::Timing
std::vector< double > Timing
TC timing.
Definition: TrgEclCluster.h:136
Belle2::TrgEclMapping
A class of TC Mapping.
Definition: TrgEclMapping.h:26
Belle2::TrgEclMapping::getTCThetaIdFromTCId
int getTCThetaIdFromTCId(int)
get [TC Theta ID] from [TC ID]
Definition: TrgEclMapping.cc:194
Belle2::TrgEclMapping::getTCPosition
ROOT::Math::XYZVector getTCPosition(int)
TC position (cm)
Definition: TrgEclMapping.cc:244
Belle2::TrgEclMapping::getTCPhiIdFromTCId
int getTCPhiIdFromTCId(int)
get [TC Phi ID] from [TC ID]
Definition: TrgEclMapping.cc:221
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.