Belle II Software  release-08-01-10
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 
40 using namespace std;
41 using namespace Belle2;
42 //
43 //
44 //
45 TrgEclCluster::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 //
92 TrgEclCluster::~TrgEclCluster()
93 {
94  delete _TCMap;
95 }
96 //
97 //
98 //
99 int
100 TrgEclCluster::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 //
109 int
110 TrgEclCluster::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 //
120 int
121 TrgEclCluster::getBrICNCluster(int ICNId, int location)
122 {
123  // get the # of Cluster in Barrel.
124  return _BrCluster[ICNId][location];
125 
126 }
127 //
128 //
129 //
130 int
131 TrgEclCluster::getBwICNCluster(int ICNId, int location)
132 {
133 
134  return _BwCluster[ICNId][location];
135 
136 }
137 //
138 //
139 //
140 int
141 TrgEclCluster::getFwICNCluster(int ICNId, int location)
142 {
143 
144  return _FwCluster[ICNId][location];
145 
146 }
147 //
148 //
149 //
150 void
151 TrgEclCluster::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 //
171 void
172 TrgEclCluster::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 //
191 void
192 TrgEclCluster::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 //
235 void 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 //
433 void
434 TrgEclCluster::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 //
960 void 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 //
1306 int
1307 TrgEclCluster::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 //
1375 void
1376 TrgEclCluster::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 //
1449 int
1450 TrgEclCluster::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 //
1603 int 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 //
1755 int 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::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:195
Belle2::TrgEclMapping::getTCPosition
TVector3 getTCPosition(int)
TC position (cm)
Definition: TrgEclMapping.cc:245
Belle2::TrgEclMapping::getTCPhiIdFromTCId
int getTCPhiIdFromTCId(int)
get [TC Phi ID] from [TC ID]
Definition: TrgEclMapping.cc:222
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17