Belle II Software prerelease-10-00-00a
Public Member Functions | Private Attributes | List of all members
TrgEclCluster Class Reference
Packages » trg

A Class of ECL Trigger clustering. More...

#include <TrgEclCluster.h>

Collaboration diagram for TrgEclCluster:
Collaboration graph
[legend]

Public Member Functions

 TrgEclCluster ()
 Constructor.
 
virtual ~TrgEclCluster ()
 Constructor.
 
 TrgEclCluster (TrgEclCluster &)=delete
 Destructor.
 
TrgEclCluster & operator= (TrgEclCluster &)=delete
 Assignment operator, deleted.
 
void initialize (void)
 initialization
 
void setICN (const std::vector< int > &)
 set ICN for each part(Fw,Br,Bw)
 
void setICN (const std::vector< int > &, const std::vector< double > &, const std::vector< double > &)
 set Belle 2 Clustering
 
void save (int)
 Save Cluster information in TRGECLCluster Table.
 
void setBarrelICN (int)
 calculate Belle 2 Cluster in Barrel
 
void setBarrelICNsub (int, std::vector< int >, int &, int &, int &, int &, int &, int &, int &, int &)
 calculate 3x3 TC hit map for ICN in Barrel
 
void setForwardICN (int)
 calculate Belle2 Cluster in Forward endcap
 
void setBackwardICN (int)
 calculate Belle 2 Cluster in Backward endcap
 
int setBarrelICN ()
 calculate Belle ICN in Barrel
 
int setForwardICN ()
 calculate Belle ICN in Forward endcap
 
int setBackwardICN ()
 calculate Belle ICN in Backward endcap
 
void setEventId (int eventId)
 Set EventId.
 
void setClusteringMethod (int method)
 Set.
 
void setClusterLimit (int limit)
 Set Limit of Cluster.
 
int getICNFwBr (void)
 get ICN in Barrel and Forward
 
int getICNSub (int)
 get ICN in each region(Fw(0), Br(1), Bw(2))
 
int getBrICNCluster (int ICNId, int)
 get ICN in QuadrantId in Fw or Br or Bw.
 
int getBwICNCluster (int ICNId, int)
 0 : center , 1; upper , 2: right , 3: lower , 4: lower right
 
int getFwICNCluster (int ICNId, int)
 0 : center , 1; upper , 2: right , 3: lower , 4: lower right
 
int getNofCluster ()
 0 : center , 1; upper , 2: right , 3: lower , 4: lower right
 
int getNofExceedCluster ()
 get # Cluster in case of exceeding limit
 

Private Attributes

int m_BRICN
 get Beam bkg veto flag.
 
int m_FWDICN
 ICN in Forward Endcap.
 
int m_BWDICN
 ICN in Backward Endcap.
 
int m_BRNofCluster
 Cluster in Barrel.
 
int m_FWDNofCluster
 Cluster in Forward Endcap.
 
int m_BWDNofCluster
 Cluster in Backward Endcap.
 
int m_EventId
 event number
 
int m_Method
 Clustering method.
 
int m_LimitNCluster
 the Limit Number of Cluster
 
int m_Position
 Position calculation method(0:Most energetic TC Position, 1 : Energy weighted Position)
 
std::vector< int > m_icnfwbrbw
 icn
 
std::vector< int > m_TCId
 TC Id.
 
std::vector< double > m_Timing
 TC timing.
 
std::vector< double > m_Energy
 TC energy.
 
std::vector< std::vector< int > > m_Quadrant
 Quadrant for Beam Background veto.
 
std::vector< std::vector< int > > m_BrCluster
 cluster in barrel
 
std::vector< std::vector< int > > m_FwCluster
 cluster in forward endcap
 
std::vector< std::vector< int > > m_BwCluster
 cluster in backward endcap
 
std::vector< std::vector< double > > m_ClusterTiming
 Cluster timing.
 
std::vector< std::vector< double > > m_ClusterEnergy
 Cluster enrgy.
 
std::vector< std::vector< double > > m_ClusterPositionX
 Cluster position in X-axis.
 
std::vector< std::vector< double > > m_ClusterPositionY
 Cluster position in Y-axis.
 
std::vector< std::vector< double > > m_ClusterPositionZ
 Cluster position in Z-axis.
 
std::vector< std::vector< int > > m_NofTCinCluster
 N of TC in Cluster.
 
std::vector< std::vector< int > > m_MaxTCId
 Maximum contribution TC Id in Cluster.
 
std::vector< int > m_TempCluster
 Temporal Cluster.
 
TrgEclMapping * m_TCMap
 Object of TC Mapping.
 

Detailed Description

A Class of ECL Trigger clustering.

Definition at line 30 of file TrgEclCluster.h.

Constructor & Destructor Documentation

◆ TrgEclCluster() [1/2]

TrgEclCluster ( )

Constructor.

Definition at line 45 of file TrgEclCluster.cc.

45 :
46 m_BRICN(0), m_FWDICN(0), m_BWDICN(0),
47 m_BRNofCluster(0), m_FWDNofCluster(0), m_BWDNofCluster(0),
48 m_EventId(0), m_Method(1), m_LimitNCluster(6), m_Position(1)
49{
50
51 TrgEclCluster::initialize();
52 m_TCMap = new TrgEclMapping();
53
54}
Belle2::TrgEclCluster::m_BWDNofCluster
int m_BWDNofCluster
Cluster in Backward Endcap.
Definition TrgEclCluster.h:122
Belle2::TrgEclCluster::m_LimitNCluster
int m_LimitNCluster
the Limit Number of Cluster
Definition TrgEclCluster.h:128
Belle2::TrgEclCluster::m_BRNofCluster
int m_BRNofCluster
Cluster in Barrel.
Definition TrgEclCluster.h:118
Belle2::TrgEclCluster::m_Method
int m_Method
Clustering method.
Definition TrgEclCluster.h:126
Belle2::TrgEclCluster::m_FWDICN
int m_FWDICN
ICN in Forward Endcap.
Definition TrgEclCluster.h:114
Belle2::TrgEclCluster::m_BRICN
int m_BRICN
get Beam bkg veto flag.
Definition TrgEclCluster.h:112
Belle2::TrgEclCluster::m_BWDICN
int m_BWDICN
ICN in Backward Endcap.
Definition TrgEclCluster.h:116
Belle2::TrgEclCluster::initialize
void initialize(void)
initialization
Definition TrgEclCluster.cc:65
Belle2::TrgEclCluster::m_FWDNofCluster
int m_FWDNofCluster
Cluster in Forward Endcap.
Definition TrgEclCluster.h:120
Belle2::TrgEclCluster::m_EventId
int m_EventId
event number
Definition TrgEclCluster.h:124
Belle2::TrgEclCluster::m_Position
int m_Position
Position calculation method(0:Most energetic TC Position, 1 : Energy weighted Position)
Definition TrgEclCluster.h:130
Belle2::TrgEclCluster::m_TCMap
TrgEclMapping * m_TCMap
Object of TC Mapping.
Definition TrgEclCluster.h:171

◆ ~TrgEclCluster()

~TrgEclCluster ( )
virtual

Constructor.

Destructor

Definition at line 58 of file TrgEclCluster.cc.

59{
60 delete m_TCMap;
61}

◆ TrgEclCluster() [2/2]

TrgEclCluster ( TrgEclCluster & )
delete

Destructor.

Copy constructor, deleted.

Member Function Documentation

◆ getBrICNCluster()

int getBrICNCluster ( int ICNId,
int location )

get ICN in QuadrantId in Fw or Br or Bw.

FwBrBwId = 0(Fw),1(Br),2(Bw) QuadrantId = 0,1,2,3

Definition at line 123 of file TrgEclCluster.cc.

124{
125 // get the # of Cluster in Barrel.
126 return m_BrCluster[ICNId][location];
127
128}
Belle2::TrgEclCluster::m_BrCluster
std::vector< std::vector< int > > m_BrCluster
cluster in barrel
Definition TrgEclCluster.h:146

◆ getBwICNCluster()

int getBwICNCluster ( int ICNId,
int location )

0 : center , 1; upper , 2: right , 3: lower , 4: lower right

Definition at line 133 of file TrgEclCluster.cc.

134{
135
136 return m_BwCluster[ICNId][location];
137
138}
Belle2::TrgEclCluster::m_BwCluster
std::vector< std::vector< int > > m_BwCluster
cluster in backward endcap
Definition TrgEclCluster.h:150

◆ getFwICNCluster()

int getFwICNCluster ( int ICNId,
int location )

0 : center , 1; upper , 2: right , 3: lower , 4: lower right

Definition at line 143 of file TrgEclCluster.cc.

144{
145
146 return m_FwCluster[ICNId][location];
147
148}
Belle2::TrgEclCluster::m_FwCluster
std::vector< std::vector< int > > m_FwCluster
cluster in forward endcap
Definition TrgEclCluster.h:148

◆ getICNFwBr()

int getICNFwBr ( void )

get ICN in Barrel and Forward

Definition at line 102 of file TrgEclCluster.cc.

103{
104 // get ICN in Barrel and Forward Endcap except for the most inner (=Physics region : Theta Id 2 ~ 15)
105 return m_icnfwbrbw[0] + m_icnfwbrbw[1];
106
107}
Belle2::TrgEclCluster::m_icnfwbrbw
std::vector< int > m_icnfwbrbw
icn
Definition TrgEclCluster.h:134

◆ getICNSub()

int getICNSub ( int FwBrBw)

get ICN in each region(Fw(0), Br(1), Bw(2))

Definition at line 112 of file TrgEclCluster.cc.

113{
114 // get ICN in Barrel and Backward endcap, Forward Endcap except for the most inner (=Physics region : Theta Id 2 ~ 15)
115
116 return m_icnfwbrbw[FwBrBw];
117
118}

◆ getNofCluster()

int getNofCluster ( )
inline

0 : center , 1; upper , 2: right , 3: lower , 4: lower right

Output # of cluster

Definition at line 97 of file TrgEclCluster.h.

97{return m_BWDNofCluster + m_FWDNofCluster + m_BRNofCluster;}

◆ getNofExceedCluster()

int getNofExceedCluster ( )

get # Cluster in case of exceeding limit

Definition at line 1757 of file TrgEclCluster.cc.

1758{
1759 int ncluster =
1760 m_ClusterEnergy[0].size() +
1761 m_ClusterEnergy[1].size() +
1762 m_ClusterEnergy[2].size();
1763 if (ncluster > m_LimitNCluster) {
1764 return ncluster;
1765 } else {
1766 return 0;
1767 }
1768}
Belle2::TrgEclCluster::m_ClusterEnergy
std::vector< std::vector< double > > m_ClusterEnergy
Cluster enrgy.
Definition TrgEclCluster.h:157

◆ initialize()

void initialize ( void )

initialization

Definition at line 65 of file TrgEclCluster.cc.

66{
67 m_icnfwbrbw.clear();
68 m_BrCluster.clear();
69 m_FwCluster.clear();
70 m_BwCluster.clear();
71 m_Quadrant.clear();
72
73 m_TCId.clear();
74 m_Timing.clear();
75 m_Energy.clear();
76
77 m_ClusterTiming.clear();
78 m_ClusterEnergy.clear();
79 m_ClusterPositionX.clear();
80 m_ClusterPositionY.clear();
81 m_ClusterPositionZ.clear();
82 m_NofTCinCluster.clear();
83 m_MaxTCId.clear();
84 m_TempCluster.clear();
85
86 m_icnfwbrbw.resize(3, 0);
87 m_TempCluster.resize(9);
88 m_Quadrant.resize(3, std::vector<int>(4, 0.0));
89
90 m_ClusterTiming.resize(3);
91 m_ClusterEnergy.resize(3);
92 m_ClusterPositionX.resize(3);
93 m_ClusterPositionY.resize(3);
94 m_ClusterPositionZ.resize(3);
95 m_NofTCinCluster.resize(3);
96 m_MaxTCId.resize(3);
97}
Belle2::TrgEclCluster::m_ClusterTiming
std::vector< std::vector< double > > m_ClusterTiming
Cluster timing.
Definition TrgEclCluster.h:155
Belle2::TrgEclCluster::m_MaxTCId
std::vector< std::vector< int > > m_MaxTCId
Maximum contribution TC Id in Cluster.
Definition TrgEclCluster.h:167
Belle2::TrgEclCluster::m_ClusterPositionX
std::vector< std::vector< double > > m_ClusterPositionX
Cluster position in X-axis.
Definition TrgEclCluster.h:159
Belle2::TrgEclCluster::m_ClusterPositionZ
std::vector< std::vector< double > > m_ClusterPositionZ
Cluster position in Z-axis.
Definition TrgEclCluster.h:163
Belle2::TrgEclCluster::m_NofTCinCluster
std::vector< std::vector< int > > m_NofTCinCluster
N of TC in Cluster.
Definition TrgEclCluster.h:165
Belle2::TrgEclCluster::m_Quadrant
std::vector< std::vector< int > > m_Quadrant
Quadrant for Beam Background veto.
Definition TrgEclCluster.h:143
Belle2::TrgEclCluster::m_Energy
std::vector< double > m_Energy
TC energy.
Definition TrgEclCluster.h:140
Belle2::TrgEclCluster::m_TempCluster
std::vector< int > m_TempCluster
Temporal Cluster.
Definition TrgEclCluster.h:169
Belle2::TrgEclCluster::m_TCId
std::vector< int > m_TCId
TC Id.
Definition TrgEclCluster.h:136
Belle2::TrgEclCluster::m_ClusterPositionY
std::vector< std::vector< double > > m_ClusterPositionY
Cluster position in Y-axis.
Definition TrgEclCluster.h:161
Belle2::TrgEclCluster::m_Timing
std::vector< double > m_Timing
TC timing.
Definition TrgEclCluster.h:138

◆ save()

void save ( int m_nEvent)

Save Cluster information in TRGECLCluster Table.

Definition at line 194 of file TrgEclCluster.cc.

195{
196 // Save Cluster
197 // Save order : Barrel, Forward, Backward
198
199 int m_hitNum = 0;
200 int clusterId = 0;
201 int counter = 0;
202 for (int iposition = 0; iposition < 3 ; iposition ++) {
203 const int Ncluster = m_ClusterEnergy[iposition].size();
204 for (int icluster = 0; icluster < Ncluster; icluster++) {
205 if (m_ClusterEnergy[iposition][icluster] <= 0) {continue;}
206
207 if (counter >= m_LimitNCluster) {
208 continue;
209 } else {
210 counter ++;
211 }
212
213 StoreArray<TRGECLCluster> ClusterArray;
214 ClusterArray.appendNew();
215 m_hitNum = ClusterArray.getEntries() - 1;
216 ClusterArray[m_hitNum]->setEventId(m_nEvent);
217 ClusterArray[m_hitNum]->setClusterId(clusterId);
218 ClusterArray[m_hitNum]->setMaxTCId(m_MaxTCId[iposition][icluster]);
219 ClusterArray[m_hitNum]->setMaxThetaId(m_TCMap->getTCThetaIdFromTCId(m_MaxTCId[iposition][icluster]));
220 ClusterArray[m_hitNum]->setMaxPhiId(m_TCMap->getTCPhiIdFromTCId(m_MaxTCId[iposition][icluster]));
221 ClusterArray[m_hitNum]->setNofTCinCluster(m_NofTCinCluster[iposition][icluster]);
222 ClusterArray[m_hitNum]->setEnergyDep(m_ClusterEnergy[iposition][icluster]);
223 ClusterArray[m_hitNum]->setTimeAve(m_ClusterTiming[iposition][icluster]);
224
225 ClusterArray[m_hitNum]->setPositionX(m_ClusterPositionX[iposition][icluster]);
226 ClusterArray[m_hitNum]->setPositionY(m_ClusterPositionY[iposition][icluster]);
227 ClusterArray[m_hitNum]->setPositionZ(m_ClusterPositionZ[iposition][icluster]);
228 clusterId ++;
229 }
230 }
231
232
233}
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

◆ setBackwardICN() [1/2]

int setBackwardICN ( )

calculate Belle ICN in Backward endcap

Definition at line 1605 of file TrgEclCluster.cc.

1606{
1607 std::vector<int> TCFire;
1608
1609
1610 TCFire.clear();
1611
1612 TCFire.resize(64, 0);
1613
1614
1615
1616 const int hit_size = m_TCId.size();
1617 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1618 if (m_TCId[ihit] < 513) {continue;}
1619
1620 // TCFire[m_TCId[ihit] - 513] = m_TCId[ihit];
1621 //------------------------------------
1622 // To rearrange the hit map
1623 //
1624 // original converted
1625 // (<- Theta) (<- Theta)
1626 //
1627 // 516 515 32 0
1628 // 513 514 33 1
1629 // 520 519 => 34 2
1630 // 517 518 35 3
1631 // ... .
1632 // 576 575 62 30
1633 // 573 574 63 31
1634 //
1635 // Here, TCId-1 becomes TCId=0 and 1.
1636 //------------------------------------
1637 int iTCId0 = m_TCId[ihit] - 1;
1638 int kkk = 0;
1639 if ((iTCId0 - 512) % 4 == 2) {
1640 kkk = (iTCId0 - 512) / 2 - 1;
1641 }
1642 if ((iTCId0 - 512) % 4 == 1) {
1643 kkk = ((iTCId0 - 512) + 1) / 2;
1644 }
1645 if ((iTCId0 - 512) % 4 == 3) {
1646 kkk = 32 + ((iTCId0 - 512) - 3) / 2;
1647 }
1648 if ((iTCId0 - 512) % 4 == 0) {
1649 kkk = 33 + ((iTCId0 - 512)) / 2;
1650 }
1651
1652 TCFire[kkk] = iTCId0 + 1;
1653
1654 }
1655
1656
1657 for (int iii = 0 ; iii < 64 ; iii ++) {
1658
1659 if (TCFire[iii] == 0) { continue; }
1660
1661 for (int iinit = 0; iinit < 9; iinit ++) {m_TempCluster[iinit] = 0;}
1662 if (iii < 32) {
1663 if (iii == 0) {
1664 m_TempCluster[0] = TCFire[ 0];
1665 m_TempCluster[1] = TCFire[31]; // top
1666 m_TempCluster[2] = 0;// right top
1667 m_TempCluster[3] = 0; //right
1668 m_TempCluster[4] = 0; //right bottom
1669 m_TempCluster[5] = TCFire[ 1]; // bottom
1670 m_TempCluster[6] = TCFire[33]; // bottom left
1671 m_TempCluster[7] = TCFire[32]; // left
1672 m_TempCluster[8] = TCFire[63]; // top left
1673 } else if (iii == 31) {
1674 m_TempCluster[0] = TCFire[31];
1675 m_TempCluster[1] = TCFire[30];
1676 m_TempCluster[2] = 0;// right top
1677 m_TempCluster[3] = 0; //right
1678 m_TempCluster[4] = 0; //right bottom
1679 m_TempCluster[5] = TCFire[0]; //bottom
1680 m_TempCluster[6] = TCFire[32]; // bottom left
1681 m_TempCluster[7] = TCFire[63]; // left
1682 m_TempCluster[8] = TCFire[62]; //top left
1683 } else {
1684 m_TempCluster[0] = TCFire[iii];
1685 m_TempCluster[1] = TCFire[iii - 1]; // top
1686 m_TempCluster[2] = 0;// right top
1687 m_TempCluster[3] = 0; //right
1688 m_TempCluster[4] = 0; //right bottom
1689 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1690 m_TempCluster[6] = TCFire[iii + 33]; //bottom left
1691 m_TempCluster[7] = TCFire[iii + 32]; // left
1692 m_TempCluster[8] = TCFire[iii + 31]; //top left
1693 }
1694 } else {
1695 if (iii == 32) {
1696 m_TempCluster[0] = TCFire[32];
1697 m_TempCluster[1] = TCFire[63]; // top
1698 m_TempCluster[2] = TCFire[31];// right top
1699 m_TempCluster[3] = TCFire[0]; //right
1700 m_TempCluster[4] = TCFire[1]; //right bottom
1701 m_TempCluster[5] = TCFire[33]; //bottom
1702 m_TempCluster[6] = 0; //bottom left
1703 m_TempCluster[7] = 0; // left
1704 m_TempCluster[8] = 0; //top left
1705 } else if (iii == 63) {
1706 m_TempCluster[0] = TCFire[63];
1707 m_TempCluster[1] = TCFire[62]; // top
1708 m_TempCluster[2] = TCFire[30];// right top
1709 m_TempCluster[3] = TCFire[31]; //right
1710 m_TempCluster[4] = TCFire[0]; //right bottom
1711 m_TempCluster[5] = TCFire[32]; //bottom
1712 m_TempCluster[6] = 0; //bottom left
1713 m_TempCluster[7] = 0; // left
1714 m_TempCluster[8] = 0; //top left
1715 } else {
1716 m_TempCluster[0] = TCFire[iii];
1717 m_TempCluster[1] = TCFire[iii - 1]; // top
1718 m_TempCluster[2] = TCFire[iii - 33]; // right top
1719 m_TempCluster[3] = TCFire[iii - 32]; //right
1720 m_TempCluster[4] = TCFire[iii - 31]; //right bottom
1721 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1722 m_TempCluster[6] = 0; //bottom left
1723 m_TempCluster[7] = 0; // left
1724 m_TempCluster[8] = 0; //top left
1725 }
1726
1727 }
1728
1729 if (!(m_TempCluster[1] != 0 || m_TempCluster[7] != 0)) {
1730 if (!(m_TempCluster[5] != 0 && m_TempCluster[6] != 0)) {
1731 m_BWDICN ++;
1732 int phiid = m_TCMap->getTCPhiIdFromTCId(TCFire[iii]);
1733
1734 if (phiid == 32 || (phiid > 0 && phiid < 10)) {
1735 m_Quadrant[2][0]++;
1736 }
1737 if (phiid > 7 && phiid < 18) {
1738 m_Quadrant[2][1]++;
1739 }
1740 if (phiid > 15 && phiid < 26) {
1741 m_Quadrant[2][2]++;
1742 }
1743 if ((phiid > 22 && phiid < 33) || phiid == 1) {
1744 m_Quadrant[2][3]++;
1745 }
1746
1747
1748 }
1749 }
1750 }
1751
1752 return m_BWDICN;
1753}

◆ setBackwardICN() [2/2]

void setBackwardICN ( int Method)

calculate Belle 2 Cluster in Backward endcap

Definition at line 962 of file TrgEclCluster.cc.

963{
964 std::vector<int> TCFire;
965 std::vector<double> TCFireEnergy;
966 std::vector<double> TCFireTiming;
967 std::vector<std::vector<double>> TCFirePosition;
968
969
970 std::vector<double> TempClusterEnergy;
971 std::vector<double> TempClusterTiming;
972 std::vector<double> TempClusterPositionX;
973 std::vector<double> TempClusterPositionY;
974 std::vector<double> TempClusterPositionZ;
975 std::vector<int> TempNofTCinCluster;
976 std::vector<int> TempMaxTCId;
977
978 std::vector<double> Sort1D;
979 std::vector<std::vector<double>> Sort2D;
980
981 int TempICNTCId = 0;
982
983 TempClusterEnergy.clear();
984 TempClusterTiming.clear();
985 TempClusterPositionX.clear();
986 TempClusterPositionY.clear();
987 TempClusterPositionZ.clear();
988 TempNofTCinCluster.clear();
989 TempMaxTCId.clear();
990 Sort1D.clear();
991 Sort2D.clear();
992
993 TCFire.clear();
994 TCFireEnergy.clear();
995 TCFireTiming.clear();
996 TCFirePosition.clear();
997
998 TCFire.resize(64, 0);
999 TCFireEnergy.resize(64, 0.);
1000 TCFireTiming.resize(64, 0.);
1001 TCFirePosition.resize(64, std::vector<double>(3, 0.));
1002
1003 const int hit_size = m_TCId.size();
1004 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1005 if (m_TCId[ihit] < 513) {continue;}
1006 TCFireEnergy[m_TCId[ihit] - 513] = m_Energy[ihit];
1007 TCFireTiming[m_TCId[ihit] - 513] = m_Timing[ihit];
1008 TCFirePosition[m_TCId[ihit] - 513][0] = (m_TCMap->getTCPosition(m_TCId[ihit])).X();
1009 TCFirePosition[m_TCId[ihit] - 513][1] = (m_TCMap->getTCPosition(m_TCId[ihit])).Y();
1010 TCFirePosition[m_TCId[ihit] - 513][2] = (m_TCMap->getTCPosition(m_TCId[ihit])).Z();
1011
1012 //------------------------------------
1013 // To rearrange the hit map
1014 //
1015 // original converted
1016 // (<- Theta) (<- Theta)
1017 //
1018 // 516 515 32 0
1019 // 513 514 33 1
1020 // 520 519 => 34 2
1021 // 517 518 35 3
1022 // ... .
1023 // 576 575 62 30
1024 // 573 574 63 31
1025 //
1026 // Here, TCId-1 becomes TCId=0 and 1.
1027 //------------------------------------
1028 int iTCId0 = m_TCId[ihit] - 1;
1029 int kkk = 0;
1030 if ((iTCId0 - 512) % 4 == 2) {
1031 kkk = (iTCId0 - 512) / 2 - 1;
1032 }
1033 if ((iTCId0 - 512) % 4 == 1) {
1034 kkk = ((iTCId0 - 512) + 1) / 2;
1035 }
1036 if ((iTCId0 - 512) % 4 == 3) {
1037 kkk = 32 + ((iTCId0 - 512) - 3) / 2;
1038 }
1039 if ((iTCId0 - 512) % 4 == 0) {
1040 kkk = 33 + ((iTCId0 - 512)) / 2;
1041 }
1042
1043 TCFire[kkk] = iTCId0 + 1;
1044
1045 }
1046
1047
1048 for (int iii = 0 ; iii < 64 ; iii ++) {
1049
1050 if (TCFire[iii] == 0) { continue; }
1051
1052 for (int iinit = 0; iinit < 9; iinit ++) {m_TempCluster[iinit] = 0;}
1053 if (iii < 32) {
1054 if (iii == 0) {
1055 m_TempCluster[0] = TCFire[ 0];
1056 m_TempCluster[1] = TCFire[31]; // top
1057 m_TempCluster[2] = 0;// right top
1058 m_TempCluster[3] = 0; //right
1059 m_TempCluster[4] = 0; //right bottom
1060 m_TempCluster[5] = TCFire[ 1]; // bottom
1061 m_TempCluster[6] = TCFire[33]; // bottom left
1062 m_TempCluster[7] = TCFire[32]; // left
1063 m_TempCluster[8] = TCFire[63]; // top left
1064 } else if (iii == 31) {
1065 m_TempCluster[0] = TCFire[31];
1066 m_TempCluster[1] = TCFire[30];
1067 m_TempCluster[2] = 0;// right top
1068 m_TempCluster[3] = 0; //right
1069 m_TempCluster[4] = 0; //right bottom
1070 m_TempCluster[5] = TCFire[0]; //bottom
1071 m_TempCluster[6] = TCFire[32]; // bottom left
1072 m_TempCluster[7] = TCFire[63]; // left
1073 m_TempCluster[8] = TCFire[62]; //top left
1074 } else {
1075 m_TempCluster[0] = TCFire[iii];
1076 m_TempCluster[1] = TCFire[iii - 1]; // top
1077 m_TempCluster[2] = 0;// right top
1078 m_TempCluster[3] = 0; //right
1079 m_TempCluster[4] = 0; //right bottom
1080 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1081 m_TempCluster[6] = TCFire[iii + 33]; //bottom left
1082 m_TempCluster[7] = TCFire[iii + 32]; // left
1083 m_TempCluster[8] = TCFire[iii + 31]; //top left
1084 }
1085 } else {
1086 if (iii == 32) {
1087 m_TempCluster[0] = TCFire[32];
1088 m_TempCluster[1] = TCFire[63]; // top
1089 m_TempCluster[2] = TCFire[31];// right top
1090 m_TempCluster[3] = TCFire[0]; //right
1091 m_TempCluster[4] = TCFire[1]; //right bottom
1092 m_TempCluster[5] = TCFire[33]; //bottom
1093 m_TempCluster[6] = 0; //bottom left
1094 m_TempCluster[7] = 0; // left
1095 m_TempCluster[8] = 0; //top left
1096 } else if (iii == 63) {
1097 m_TempCluster[0] = TCFire[63];
1098 m_TempCluster[1] = TCFire[62]; // top
1099 m_TempCluster[2] = TCFire[30];// right top
1100 m_TempCluster[3] = TCFire[31]; //right
1101 m_TempCluster[4] = TCFire[0]; //right bottom
1102 m_TempCluster[5] = TCFire[32]; //bottom
1103 m_TempCluster[6] = 0; //bottom left
1104 m_TempCluster[7] = 0; // left
1105 m_TempCluster[8] = 0; //top left
1106 } else {
1107 m_TempCluster[0] = TCFire[iii];
1108 m_TempCluster[1] = TCFire[iii - 1]; // top
1109 m_TempCluster[2] = TCFire[iii - 33]; // right top
1110 m_TempCluster[3] = TCFire[iii - 32]; //right
1111 m_TempCluster[4] = TCFire[iii - 31]; //right bottom
1112 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1113 m_TempCluster[6] = 0; //bottom left
1114 m_TempCluster[7] = 0; // left
1115 m_TempCluster[8] = 0; //top left
1116 }
1117
1118 }
1119
1120 if (!(m_TempCluster[1] != 0 || m_TempCluster[7] != 0)) {
1121 if (!(m_TempCluster[5] != 0 && m_TempCluster[6] != 0)) {
1122 TempICNTCId = TCFire[iii];
1123
1124 if (Method == 1) {
1125 int maxTCid = 0;
1126 double maxTCEnergy = 0;
1127 for (int iTC = 0; iTC < 9; iTC++) { //find center of Cluster
1128 if (m_TempCluster[iTC] == 0) {continue;}
1129 if (maxTCEnergy < TCFireEnergy[m_TempCluster[iTC] - 513]) {
1130 maxTCEnergy = TCFireEnergy[m_TempCluster[iTC] - 513];
1131 maxTCid = m_TempCluster[iTC];
1132 }
1133 }
1134 int kkk = 0;
1135 m_TempCluster[0] = maxTCid;
1136 if ((m_TempCluster[0] - 513) % 4 == 2) {
1137 kkk = (m_TempCluster[0] - 513) / 2 - 1;
1138 }
1139 if ((m_TempCluster[0] - 513) % 4 == 1) {
1140 kkk = ((m_TempCluster[0] - 513) + 1) / 2;
1141 }
1142 if ((m_TempCluster[0] - 513) % 4 == 3) {
1143 kkk = 32 + ((m_TempCluster[0] - 513) - 3) / 2;
1144 }
1145 if ((m_TempCluster[0] - 513) % 4 == 0) {
1146 kkk = 33 + ((m_TempCluster[0] - 513)) / 2;
1147 }
1148
1149 if (kkk < 32) {
1150 if (kkk == 0) {
1151 m_TempCluster[0] = TCFire[ 0];
1152 m_TempCluster[1] = TCFire[31]; // top
1153 m_TempCluster[2] = 0;// right top
1154 m_TempCluster[3] = 0; //right
1155 m_TempCluster[4] = 0; //right bottom
1156 m_TempCluster[5] = TCFire[ 1]; // bottom
1157 m_TempCluster[6] = TCFire[33]; // bottom left
1158 m_TempCluster[7] = TCFire[32]; // left
1159 m_TempCluster[8] = TCFire[63]; // top left
1160 } else if (kkk == 31) {
1161 m_TempCluster[0] = TCFire[31];
1162 m_TempCluster[1] = TCFire[30];
1163 m_TempCluster[2] = 0;// right top
1164 m_TempCluster[3] = 0; //right
1165 m_TempCluster[4] = 0; //right bottom
1166 m_TempCluster[5] = TCFire[0]; //bottom
1167 m_TempCluster[6] = TCFire[32]; // bottom left
1168 m_TempCluster[7] = TCFire[63]; // left
1169 m_TempCluster[8] = TCFire[62]; //top left
1170 } else {
1171 m_TempCluster[0] = TCFire[kkk];
1172 m_TempCluster[1] = TCFire[kkk - 1]; // top
1173 m_TempCluster[2] = 0;// right top
1174 m_TempCluster[3] = 0; //right
1175 m_TempCluster[4] = 0; //right bottom
1176 m_TempCluster[5] = TCFire[kkk + 1]; //bottom
1177 m_TempCluster[6] = TCFire[kkk + 33]; //bottom left
1178 m_TempCluster[7] = TCFire[kkk + 32]; // left
1179 m_TempCluster[8] = TCFire[kkk + 31]; //top left
1180 }
1181 } else {
1182 if (kkk == 32) {
1183 m_TempCluster[0] = TCFire[32];
1184 m_TempCluster[1] = TCFire[63]; // top
1185 m_TempCluster[2] = TCFire[31];// right top
1186 m_TempCluster[3] = TCFire[0]; //right
1187 m_TempCluster[4] = TCFire[1]; //right bottom
1188 m_TempCluster[5] = TCFire[33]; //bottom
1189 m_TempCluster[6] = 0; //bottom left
1190 m_TempCluster[7] = 0; // left
1191 m_TempCluster[8] = 0; //top left
1192 } else if (kkk == 63) {
1193 m_TempCluster[0] = TCFire[63];
1194 m_TempCluster[1] = TCFire[62]; // top
1195 m_TempCluster[2] = TCFire[30];// right top
1196 m_TempCluster[3] = TCFire[31]; //right
1197 m_TempCluster[4] = TCFire[0]; //right bottom
1198 m_TempCluster[5] = TCFire[32]; //bottom
1199 m_TempCluster[6] = 0; //bottom left
1200 m_TempCluster[7] = 0; // left
1201 m_TempCluster[8] = 0; //top left
1202 } else {
1203 m_TempCluster[0] = TCFire[kkk];
1204 m_TempCluster[1] = TCFire[kkk - 1]; // top
1205 m_TempCluster[2] = TCFire[kkk - 33]; // right top
1206 m_TempCluster[3] = TCFire[kkk - 32]; //right
1207 m_TempCluster[4] = TCFire[kkk - 31]; //right bottom
1208 m_TempCluster[5] = TCFire[kkk + 1]; //bottom
1209 m_TempCluster[6] = 0; //bottom left
1210 m_TempCluster[7] = 0; // left
1211 m_TempCluster[8] = 0; //top left
1212 }
1213
1214 }
1215 }
1216
1217 for (int iNearTC = 1; iNearTC < 9; iNearTC ++) {
1218 for (int jNearTC = 1; jNearTC < 9; jNearTC ++) {
1219 if (m_TempCluster[iNearTC] == 0) {continue;}
1220 if (iNearTC == jNearTC) {continue;}
1221 if (m_TempCluster[iNearTC] == m_TempCluster[jNearTC]) {
1222 m_TempCluster[jNearTC] = 0;
1223 }
1224 }
1225 }
1226
1227 int maxTCId = 999;
1228 double clusterenergy = 0;
1229 double clustertiming = 0;
1230 double clusterpositionX = 0;
1231 double clusterpositionY = 0;
1232 double clusterpositionZ = 0;
1233 int noftcincluster = 0;
1234 for (int iNearTC = 0; iNearTC < 9; iNearTC ++) {
1235 if (m_TempCluster[iNearTC] == 0) {continue;}
1236 else {noftcincluster++;}
1237
1238 clusterenergy += TCFireEnergy[m_TempCluster[iNearTC] - 513];
1239 clustertiming += TCFireEnergy[m_TempCluster[iNearTC] - 513] * TCFireTiming[m_TempCluster[iNearTC] - 513];
1240 clusterpositionX += TCFireEnergy[m_TempCluster[iNearTC] - 513] * TCFirePosition[m_TempCluster[iNearTC] - 513][0];
1241 clusterpositionY += TCFireEnergy[m_TempCluster[iNearTC] - 513] * TCFirePosition[m_TempCluster[iNearTC] - 513][1];
1242 clusterpositionZ += TCFireEnergy[m_TempCluster[iNearTC] - 513] * TCFirePosition[m_TempCluster[iNearTC] - 513][2];
1243
1244
1245 }
1246 //
1247 maxTCId = m_TempCluster[0];
1248 //
1249
1250 clustertiming /= clusterenergy;
1251 if (m_Position == 1) {
1252 clusterpositionX /= clusterenergy;
1253 clusterpositionY /= clusterenergy;
1254 clusterpositionZ /= clusterenergy;
1255 } else if (m_Position == 0) {
1256 clustertiming = TCFireTiming[maxTCId - 513];
1257 clusterpositionX = TCFirePosition[maxTCId - 513][0];
1258 clusterpositionY = TCFirePosition[maxTCId - 513][1];
1259 clusterpositionZ = TCFirePosition[maxTCId - 513][2];
1260 }
1261
1262 if (clustertiming == 0 && clusterenergy == 0) {continue;}
1263 TempClusterEnergy.push_back(clusterenergy);
1264 TempClusterTiming.push_back(clustertiming);
1265 TempClusterPositionX.push_back(clusterpositionX);
1266 TempClusterPositionY.push_back(clusterpositionY);
1267 TempClusterPositionZ.push_back(clusterpositionZ);
1268 TempNofTCinCluster.push_back(noftcincluster);
1269 TempMaxTCId.push_back(maxTCId);
1270
1271
1272 Sort1D.push_back(TempICNTCId);
1273 Sort1D.push_back(clusterenergy);
1274 Sort1D.push_back(clustertiming);
1275 Sort1D.push_back(clusterpositionX);
1276 Sort1D.push_back(clusterpositionY);
1277 Sort1D.push_back(clusterpositionZ);
1278 Sort1D.push_back(noftcincluster);
1279 Sort1D.push_back(maxTCId);
1280
1281 Sort2D.push_back(Sort1D);
1282 Sort1D.clear();
1283
1284
1285 }
1286 }
1287 }
1288
1289 sort(Sort2D.begin(), Sort2D.end(),
1290 [](const vector<double>& aa1, const vector<double>& aa2) {return aa1[0] < aa2[0];});
1291
1292 const int clustersize = Sort2D.size();
1293 for (int jtc = 0; jtc < clustersize; jtc++) {
1294 m_ClusterEnergy[2].push_back(Sort2D[jtc][1]);
1295 m_ClusterTiming[2].push_back(Sort2D[jtc][2]);
1296 m_ClusterPositionX[2].push_back(Sort2D[jtc][3]);
1297 m_ClusterPositionY[2].push_back(Sort2D[jtc][4]);
1298 m_ClusterPositionZ[2].push_back(Sort2D[jtc][5]);
1299 m_NofTCinCluster[2].push_back(Sort2D[jtc][6]);
1300 m_MaxTCId[2].push_back(Sort2D[jtc][7]);
1301 }
1302
1303 m_BWDNofCluster = m_MaxTCId[2].size();
1304}

◆ setBarrelICN() [1/2]

int setBarrelICN ( )

calculate Belle ICN in Barrel

Definition at line 1309 of file TrgEclCluster.cc.

1310{
1311
1312 std::vector<int> TCFire;
1313
1314 TCFire.clear();
1315
1316 TCFire.resize(432, 0);
1317
1318 const int hit_size = m_TCId.size();
1319 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1320 if (m_TCId[ihit] >= 81 && m_TCId[ihit] <= 512) {
1321 TCFire[m_TCId[ihit] - 81] = m_TCId[ihit];
1322 }
1323 }
1324 //
1325 //
1326 //
1327 int tc_upper = 0; // check upper TC
1328 int tc_upper_right = 0; // check right TC
1329 int tc_right = 0; // check right TC
1330 int tc_lower_right = 0;
1331 int tc_lower = 0; // check lower TC
1332 int tc_lower_left = 0; // check lower TC
1333 int tc_left = 0;
1334 int tc_upper_left = 0;
1335
1336 for (int iii = 0 ; iii < 432 ; iii++) {
1337 if (TCFire[iii] == 0) { continue; }
1338
1339 setBarrelICNsub(iii,
1340 TCFire,
1341 tc_upper,
1342 tc_upper_right,
1343 tc_right,
1344 tc_lower_right,
1345 tc_lower,
1346 tc_lower_left,
1347 tc_left,
1348 tc_upper_left);
1349
1350 if (!(tc_upper != 0 || tc_left != 0)) {
1351 if (!(tc_lower != 0 && tc_lower_left != 0)) {
1352 m_BRICN++;
1353 int phiid = m_TCMap->getTCPhiIdFromTCId(iii + 80 + 1);
1354
1355 if (phiid == 36 || (phiid > 0 && phiid < 11)) {
1356 m_Quadrant[1][0]++;
1357 }
1358 if (phiid > 8 && phiid < 20) {
1359 m_Quadrant[1][1]++;
1360 }
1361 if (phiid > 17 && phiid < 29) {
1362 m_Quadrant[1][2]++;
1363 }
1364 if ((phiid > 26 && phiid < 37) || phiid == 1) {
1365 m_Quadrant[1][3]++;
1366 }
1367
1368 }
1369 }// iii loop
1370 }
1371 return m_BRICN;
1372
1373}
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:1378

◆ setBarrelICN() [2/2]

void setBarrelICN ( int Method)

calculate Belle 2 Cluster in Barrel

Definition at line 237 of file TrgEclCluster.cc.

238{
239
240 std::vector<int> TCFire;
241 std::vector<double> TCFireEnergy;
242 std::vector<double> TCFireTiming;
243 std::vector<std::vector<double>> TCFirePosition;
244
245 TCFire.clear();
246 TCFireEnergy.clear();
247 TCFireTiming.clear();
248 TCFirePosition.clear();
249
250 TCFire.resize(432, 0);
251 TCFireEnergy.resize(432, 0.);
252 TCFireTiming.resize(432, 0.);
253 TCFirePosition.resize(432, std::vector<double>(3, 0.));
254
255 const int hit_size = m_TCId.size();
256 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
257 if (m_TCId[ihit] >= 81 && m_TCId[ihit] <= 512) {
258 TCFire[m_TCId[ihit] - 81] = m_TCId[ihit];
259 TCFireEnergy[m_TCId[ihit] - 81] = m_Energy[ihit];
260 TCFireTiming[m_TCId[ihit] - 81] = m_Timing[ihit];
261 TCFirePosition[m_TCId[ihit] - 81][0] = (m_TCMap->getTCPosition(m_TCId[ihit])).X();
262 TCFirePosition[m_TCId[ihit] - 81][1] = (m_TCMap->getTCPosition(m_TCId[ihit])).Y();
263 TCFirePosition[m_TCId[ihit] - 81][2] = (m_TCMap->getTCPosition(m_TCId[ihit])).Z();
264 }
265 }
266 //
267 //
268 //
269 int tc_upper = 0; // check upper TC
270 int tc_upper_right = 0; // check right TC
271 int tc_right = 0; // check right TC
272 int tc_lower_right = 0;
273 int tc_lower = 0; // check lower TC
274 int tc_lower_left = 0; // check lower TC
275 int tc_left = 0;
276 int tc_upper_left = 0;
277
278 for (int iii = 0 ; iii < 432 ; iii++) {
279
280 if (TCFire[iii] == 0) { continue; }
281
282 setBarrelICNsub(iii,
283 TCFire,
284 tc_upper,
285 tc_upper_right,
286 tc_right,
287 tc_lower_right,
288 tc_lower,
289 tc_lower_left,
290 tc_left,
291 tc_upper_left);
292
293 if (!(tc_upper != 0 || tc_left != 0)) {
294 if (!(tc_lower != 0 && tc_lower_left != 0)) {
295
296 if (Method == 1) {
297 // for cluster method2(Consider TC energy in oderto find the center of cluster)
298 int maxTCid = 0;
299 double maxTCEnergy = 0;
300 for (int iTC = 0; iTC < 9; iTC++) { //find center of Cluster
301 if (m_TempCluster[iTC] == 0) {continue;}
302 if (maxTCEnergy < TCFireEnergy[m_TempCluster[iTC] - 81]) {
303 maxTCEnergy = TCFireEnergy[m_TempCluster[iTC] - 81];
304 maxTCid = m_TempCluster[iTC];
305 }
306 }
307 m_TempCluster[0] = maxTCid;
308
309 if (maxTCid < 93) {
310
311 m_TempCluster[1] = TCFire[maxTCid + 420 - 81 ] ;
312 m_TempCluster[2] = TCFire[maxTCid + 419 - 81 ] ;
313 m_TempCluster[3] = TCFire[maxTCid - 1 - 81 ] ;
314 m_TempCluster[4] = TCFire[maxTCid + 11 - 81 ] ;
315 m_TempCluster[5] = TCFire[maxTCid + 12 - 81 ] ;
316 m_TempCluster[6] = TCFire[maxTCid + 13 - 81 ] ;
317 m_TempCluster[7] = TCFire[maxTCid + 1 - 81 ] ;
318 m_TempCluster[8] = TCFire[maxTCid + 421 - 81 ] ;
319
320 if ((maxTCid - 81) % 12 == 0) {
321 m_TempCluster[2] = 0 ;
322 m_TempCluster[3] = 0 ;
323 m_TempCluster[4] = 0 ;
324 }
325 if ((maxTCid - 81) % 12 == 11) {
326 m_TempCluster[6] = 0 ;
327 m_TempCluster[7] = 0 ;
328 m_TempCluster[8] = 0 ;
329 }
330 }
331 if (maxTCid > 92 && maxTCid < 501) {
332
333 m_TempCluster[1] = TCFire[maxTCid - 12 - 81] ;
334 // cppcheck-suppress negativeContainerIndex
335 m_TempCluster[2] = TCFire[maxTCid - 13 - 81] ;
336 m_TempCluster[3] = TCFire[maxTCid - 1 - 81] ;
337 m_TempCluster[4] = TCFire[maxTCid + 11 - 81] ;
338 m_TempCluster[5] = TCFire[maxTCid + 12 - 81] ;
339 m_TempCluster[6] = TCFire[maxTCid + 13 - 81] ;
340 m_TempCluster[7] = TCFire[maxTCid + 1 - 81] ;
341 m_TempCluster[8] = TCFire[maxTCid - 11 - 81] ;
342
343 if ((maxTCid - 81) % 12 == 0) {
344 m_TempCluster[2] = 0;
345 m_TempCluster[3] = 0;
346 m_TempCluster[4] = 0;
347 }
348 if ((maxTCid - 81) % 12 == 11) {
349 m_TempCluster[6] = 0;
350 m_TempCluster[7] = 0;
351 m_TempCluster[8] = 0;
352 }
353 }
354 if (maxTCid > 500) {
355 m_TempCluster[1] = TCFire[maxTCid - 12 - 81] ;
356 m_TempCluster[2] = TCFire[maxTCid - 13 - 81] ;
357 m_TempCluster[3] = TCFire[maxTCid - 1 - 81] ;
358 // cppcheck-suppress negativeContainerIndex
359 m_TempCluster[4] = TCFire[maxTCid - 421 - 81] ;
360 m_TempCluster[5] = TCFire[maxTCid - 420 - 81] ;
361 m_TempCluster[6] = TCFire[maxTCid - 419 - 81] ;
362 m_TempCluster[7] = TCFire[maxTCid + 1 - 81] ;
363 m_TempCluster[8] = TCFire[maxTCid - 11 - 81] ;
364 if ((maxTCid - 81) % 12 == 0) {
365 m_TempCluster[2] = 0 ;
366 m_TempCluster[3] = 0 ;
367 m_TempCluster[4] = 0 ;
368 }
369 if ((maxTCid - 81) % 12 == 11) {
370 m_TempCluster[6] = 0 ;
371 m_TempCluster[7] = 0 ;
372 m_TempCluster[8] = 0 ;
373 }
374 }
375 }
376
377 for (int iNearTC = 1; iNearTC < 9; iNearTC ++) {
378 for (int jNearTC = 1; jNearTC < 9; jNearTC ++) {
379 if (m_TempCluster[iNearTC] == 0) {continue;}
380 if (iNearTC == jNearTC) {continue;}
381 if (m_TempCluster[iNearTC] == m_TempCluster[jNearTC]) {
382 m_TempCluster[jNearTC] = 0;
383 }
384 }
385 }
386
387 int maxTCId = 999;
388 double clusterenergy = 0;
389 double clustertiming = 0;
390 double clusterpositionX = 0;
391 double clusterpositionY = 0;
392 double clusterpositionZ = 0;
393 int noftcincluster = 0;
394 for (int iNearTC = 0; iNearTC < 9; iNearTC ++) {
395 if (m_TempCluster[iNearTC] == 0) {continue;}
396 else {noftcincluster++;}
397 clusterenergy += TCFireEnergy[m_TempCluster[iNearTC] - 81];
398 clustertiming += TCFireEnergy[m_TempCluster[iNearTC] - 81] * TCFireTiming[m_TempCluster[iNearTC] - 81];
399 clusterpositionX += TCFireEnergy[m_TempCluster[iNearTC] - 81] * TCFirePosition[m_TempCluster[iNearTC] - 81][0];
400 clusterpositionY += TCFireEnergy[m_TempCluster[iNearTC] - 81] * TCFirePosition[m_TempCluster[iNearTC] - 81][1];
401 clusterpositionZ += TCFireEnergy[m_TempCluster[iNearTC] - 81] * TCFirePosition[m_TempCluster[iNearTC] - 81][2];
402 }
403 //
404 maxTCId = m_TempCluster[0];
405 //
406 clustertiming /= clusterenergy;
407 if (m_Position == 1) {
408 clusterpositionX /= clusterenergy;
409 clusterpositionY /= clusterenergy;
410 clusterpositionZ /= clusterenergy;
411 } else if (m_Position == 0) {
412 clustertiming = TCFireTiming[maxTCId - 81];
413 clusterpositionX = TCFirePosition[maxTCId - 81][0];
414 clusterpositionY = TCFirePosition[maxTCId - 81][1];
415 clusterpositionZ = TCFirePosition[maxTCId - 81][2];
416 }
417 if (clustertiming == 0 && clusterenergy == 0) {continue;}
418 m_BrCluster.push_back(m_TempCluster);
419 m_ClusterEnergy[0].push_back(clusterenergy);
420 m_ClusterTiming[0].push_back(clustertiming);
421 m_ClusterPositionX[0].push_back(clusterpositionX);
422 m_ClusterPositionY[0].push_back(clusterpositionY);
423 m_ClusterPositionZ[0].push_back(clusterpositionZ);
424 m_NofTCinCluster[0].push_back(noftcincluster);
425 m_MaxTCId[0].push_back(maxTCId);
426 }
427 }
428 }// iii loop
429 m_BRNofCluster = m_MaxTCId[0].size();
430
431}

◆ setBarrelICNsub()

void setBarrelICNsub ( int iii,
std::vector< int > TCFire,
int & tc_upper,
int & tc_upper_right,
int & tc_right,
int & tc_lower_right,
int & tc_lower,
int & tc_lower_left,
int & tc_left,
int & tc_upper_left )

calculate 3x3 TC hit map for ICN in Barrel

Definition at line 1378 of file TrgEclCluster.cc.

1388{
1389 // take into account TCId jump at boundary between FAM-9 and FAM-44
1390 int offset_upper = 0;
1391 int offset_lower = 0;
1392 if (iii <= 11) {
1393 // FAM-9
1394 offset_upper = 432;
1395 offset_lower = 0;
1396 } else if (iii <= 419) {
1397 // FAM-10 to FAM-43
1398 offset_upper = 0;
1399 offset_lower = 0;
1400 } else {
1401 // FAM-44
1402 offset_upper = 0;
1403 offset_lower = -432;
1404 }
1405
1406 // take into account TC at boundary near endcaps
1407 if (iii % 12 == 0) {
1408 // TC at most forward side
1409 tc_upper = TCFire[iii - 12 + offset_upper];
1410 tc_upper_right = 0;
1411 tc_right = 0;
1412 tc_lower_right = 0;
1413 tc_lower = TCFire[iii + 12 + offset_lower];
1414 tc_lower_left = TCFire[iii + 13 + offset_lower];
1415 tc_left = TCFire[iii + 1];
1416 tc_upper_left = TCFire[iii - 11 + offset_upper];
1417 } else if (iii % 12 == 11) {
1418 // TC at most backward side
1419 tc_upper = TCFire[iii - 12 + offset_upper];
1420 tc_upper_right = TCFire[iii - 13 + offset_upper];
1421 tc_right = TCFire[iii - 1];
1422 tc_lower_right = TCFire[iii + 11 + offset_lower];
1423 tc_lower = TCFire[iii + 12 + offset_lower];
1424 tc_lower_left = 0;
1425 tc_left = 0;
1426 tc_upper_left = 0;
1427 } else {
1428 tc_upper = TCFire[iii - 12 + offset_upper];
1429 tc_upper_right = TCFire[iii - 13 + offset_upper];
1430 tc_right = TCFire[iii - 1];
1431 tc_lower_right = TCFire[iii + 11 + offset_lower];
1432 tc_lower = TCFire[iii + 12 + offset_lower];
1433 tc_lower_left = TCFire[iii + 13 + offset_lower];
1434 tc_left = TCFire[iii + 1];
1435 tc_upper_left = TCFire[iii - 11 + offset_upper];
1436 }
1437
1438 m_TempCluster[0] = iii + 80 + 1; //middle of ICN
1439 m_TempCluster[1] = tc_upper; // upper
1440 m_TempCluster[2] = tc_upper_right; //right
1441 m_TempCluster[3] = tc_right; //right
1442 m_TempCluster[4] = tc_lower_right; //lower
1443 m_TempCluster[5] = tc_lower; //lower
1444 m_TempCluster[6] = tc_lower_left; //lower
1445 m_TempCluster[7] = tc_left; //lower
1446 m_TempCluster[8] = tc_upper_left; //lower right;
1447}

◆ setClusteringMethod()

void setClusteringMethod ( int method)
inline

Set.

Definition at line 73 of file TrgEclCluster.h.

73{ m_Method = method; }

◆ setClusterLimit()

void setClusterLimit ( int limit)
inline

Set Limit of Cluster.

Definition at line 75 of file TrgEclCluster.h.

75{ m_LimitNCluster = limit; }

◆ setEventId()

void setEventId ( int eventId)
inline

Set EventId.

Definition at line 71 of file TrgEclCluster.h.

71{ m_EventId = eventId; }

◆ setForwardICN() [1/2]

int setForwardICN ( )

calculate Belle ICN in Forward endcap

Definition at line 1452 of file TrgEclCluster.cc.

1453{
1454
1455 std::vector<int> TCFire;
1456
1457
1458 TCFire.clear();
1459
1460 TCFire.resize(96, 0);
1461
1462
1463 const int hit_size = m_TCId.size();
1464 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
1465 if (m_TCId[ihit] > 80) {continue;}
1466
1467
1468 //------------------------------------
1469 // To rearrange the hit map
1470 //
1471 // original converted
1472 // (<- Theta) (<- Theta)
1473 //
1474 // 3 2 1 64 32 0
1475 // 4 5 - 65 33 1
1476 // 8 7 6 => 66 34 2
1477 // 9 10 - 67 35 3
1478 // .... ...
1479 // 78 77 76 94 62 30
1480 // 79 80 - 95 63 31
1481 //
1482 // Here, TCId-1 becomes TCId=0 and 1.
1483 //------------------------------------
1484 int iTCId0 = m_TCId[ihit] - 1;
1485 int kkk = 0;
1486 if (iTCId0 % 5 == 0) {
1487 kkk = (iTCId0 / 5) * 2;
1488 TCFire[kkk] = m_TCId[ihit];
1489 TCFire[kkk + 1] = m_TCId[ihit];
1490 } else {
1491 kkk = iTCId0 / 5;
1492 switch (iTCId0 % 5) {
1493 case 1 :
1494 TCFire[32 + 2 * kkk] = m_TCId[ihit]; break;
1495 case 2 :
1496 TCFire[64 + 2 * kkk] = m_TCId[ihit]; break;
1497 case 3 :
1498 TCFire[64 + 2 * kkk + 1] = m_TCId[ihit]; break;
1499 case 4 :
1500 TCFire[32 + 2 * kkk + 1] = m_TCId[ihit]; break;
1501 default:
1502 break;
1503 }
1504 }
1505 }
1506
1507
1508 for (int iii = 32 ; iii < 96 ; iii++) {
1509 for (int iinit = 0; iinit < 9; iinit ++) {m_TempCluster[iinit] = 0;}
1510 if (TCFire[iii] == 0) { continue; }
1511 if (iii < 64) {
1512 if (iii == 32) {
1513 m_TempCluster[0] = TCFire[iii];
1514 m_TempCluster[1] = TCFire[63]; // top
1515 m_TempCluster[2] = 0;// right top
1516 m_TempCluster[3] = 0; //right
1517 m_TempCluster[4] = 0; //right bottom
1518 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1519 m_TempCluster[6] = TCFire[iii + 33]; //bottom left
1520 m_TempCluster[7] = TCFire[iii + 32]; // left
1521 m_TempCluster[8] = TCFire[95]; //top left
1522 } else if (iii == 63) {
1523 m_TempCluster[0] = TCFire[iii];
1524 m_TempCluster[1] = TCFire[iii - 1]; // top
1525 m_TempCluster[2] = 0; // right top
1526 m_TempCluster[3] = 0; //right
1527 m_TempCluster[4] = 0; //right bottom
1528 m_TempCluster[5] = TCFire[32]; //bottom
1529 m_TempCluster[6] = TCFire[64]; //bottom left
1530 m_TempCluster[7] = TCFire[iii + 32]; // left
1531 m_TempCluster[8] = TCFire[iii + 31]; //top left
1532 } else {
1533 m_TempCluster[0] = TCFire[iii];
1534 m_TempCluster[1] = TCFire[iii - 1]; // top
1535 m_TempCluster[2] = 0; // right top
1536 m_TempCluster[3] = 0; //right
1537 m_TempCluster[4] = 0; //right bottom
1538 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1539 m_TempCluster[6] = TCFire[iii + 33]; //bottom left
1540 m_TempCluster[7] = TCFire[iii + 32]; // left
1541 m_TempCluster[8] = TCFire[iii + 31]; //top left
1542 }
1543 } else {
1544 if (iii == 64) {
1545 m_TempCluster[0] = TCFire[iii];
1546 m_TempCluster[1] = TCFire[95]; // top
1547 m_TempCluster[2] = TCFire[63];// right top
1548 m_TempCluster[3] = TCFire[iii - 32]; //right
1549 m_TempCluster[4] = TCFire[iii - 31]; //right bottom
1550 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1551 m_TempCluster[6] = 0; //bottom left
1552 m_TempCluster[7] = 0; // left
1553 m_TempCluster[8] = 0; //top left
1554 } else if (iii == 95) {
1555 m_TempCluster[0] = TCFire[iii];
1556 m_TempCluster[1] = TCFire[iii - 1]; // top
1557 m_TempCluster[2] = TCFire[iii - 33]; // right top
1558 m_TempCluster[3] = TCFire[iii - 32]; //right
1559 m_TempCluster[4] = TCFire[32]; //right bottom
1560 m_TempCluster[5] = TCFire[64]; //bottom
1561 m_TempCluster[6] = 0; //bottom left
1562 m_TempCluster[7] = 0; // left
1563 m_TempCluster[8] = 0; //top left
1564
1565 } else {
1566 m_TempCluster[0] = TCFire[iii];
1567 m_TempCluster[1] = TCFire[iii - 1]; // top
1568 m_TempCluster[2] = TCFire[iii - 33]; // right top
1569 m_TempCluster[3] = TCFire[iii - 32]; //right
1570 m_TempCluster[4] = TCFire[iii - 31]; //right bottom
1571 m_TempCluster[5] = TCFire[iii + 1]; //bottom
1572 m_TempCluster[6] = 0; //bottom left
1573 m_TempCluster[7] = 0; // left
1574 m_TempCluster[8] = 0; //top left
1575 }
1576
1577 }
1578 if (!(m_TempCluster[1] != 0 || m_TempCluster[7] != 0)) {
1579 if (!(m_TempCluster[5] != 0 && m_TempCluster[6] != 0)) {
1580 m_FWDICN++;
1581 int phiid = m_TCMap->getTCPhiIdFromTCId(TCFire[iii]);
1582
1583 if (phiid == 32 || (phiid > 0 && phiid < 10)) {
1584 m_Quadrant[0][0]++;
1585 }
1586 if (phiid > 7 && phiid < 18) {
1587 m_Quadrant[0][1]++;
1588 }
1589 if (phiid > 15 && phiid < 26) {
1590 m_Quadrant[0][2]++;
1591 }
1592 if ((phiid > 22 && phiid < 33) || phiid == 1) {
1593 m_Quadrant[0][3]++;
1594 }
1595
1596
1597 }
1598 }
1599 }
1600 return m_FWDICN;
1601}

◆ setForwardICN() [2/2]

void setForwardICN ( int Method)

calculate Belle2 Cluster in Forward endcap

Definition at line 436 of file TrgEclCluster.cc.

437{
438
439 std::vector<int> TCFire;
440 std::vector<double> TCFireEnergy;
441 std::vector<double> TCFireTiming;
442 std::vector<std::vector<double>> TCFirePosition;
443
444 std::vector<double> TempClusterEnergy;
445 std::vector<double> TempClusterTiming;
446 std::vector<double> TempClusterPositionX;
447 std::vector<double> TempClusterPositionY;
448 std::vector<double> TempClusterPositionZ;
449 std::vector<double> Sort1D;
450 std::vector<std::vector<double>> Sort2D;
451
452 std::vector<int> TempNofTCinCluster;
453 std::vector<int> TempMaxTCId;
454
455 int TempICNTCId = 0;;
456
457 TempClusterEnergy.clear();
458 TempClusterTiming.clear();
459 TempClusterPositionX.clear();
460 TempClusterPositionY.clear();
461 TempClusterPositionZ.clear();
462 TempNofTCinCluster.clear();
463 TempMaxTCId.clear();
464
465 Sort2D.clear();
466 Sort1D.clear();
467
468 TCFire.clear();
469 TCFireEnergy.clear();
470 TCFireTiming.clear();
471 TCFirePosition.clear();
472
473 TCFire.resize(96, 0);
474 TCFireEnergy.resize(96, 0.);
475 TCFireTiming.resize(96, 0.);
476
477 TCFirePosition.resize(96, std::vector<double>(3, 0.));
478
479
480 const int hit_size = m_TCId.size();
481 for (int ihit = 0 ; ihit < hit_size ; ihit++) {
482 if (m_TCId[ihit] > 80) {continue;}
483
484 TCFireEnergy[m_TCId[ihit] - 1] = m_Energy[ihit];
485 TCFireTiming[m_TCId[ihit] - 1] = m_Timing[ihit];
486 TCFirePosition[m_TCId[ihit] - 1][0] = (m_TCMap->getTCPosition(m_TCId[ihit])).X();
487 TCFirePosition[m_TCId[ihit] - 1][1] = (m_TCMap->getTCPosition(m_TCId[ihit])).Y();
488 TCFirePosition[m_TCId[ihit] - 1][2] = (m_TCMap->getTCPosition(m_TCId[ihit])).Z();
489
490 //------------------------------------
491 // To rearrange the hit map
492 //
493 // original converted
494 // (<- Theta) (<- Theta)
495 //
496 // 3 2 1 64 32 0
497 // 4 5 - 65 33 1
498 // 8 7 6 => 66 34 2
499 // 9 10 - 67 35 3
500 // .... ...
501 // 78 77 76 94 62 30
502 // 79 80 - 95 63 31
503 //
504 // Here, TCId-1 becomes TCId=0 and 1.
505 //------------------------------------
506 int iTCId0 = m_TCId[ihit] - 1;
507 int kkk = 0;
508 if (iTCId0 % 5 == 0) {
509 kkk = (iTCId0 / 5) * 2;
510 TCFire[kkk] = m_TCId[ihit];
511 TCFire[kkk + 1] = m_TCId[ihit];
512 } else {
513 kkk = iTCId0 / 5;
514 switch (iTCId0 % 5) {
515 case 1 :
516 TCFire[32 + 2 * kkk] = m_TCId[ihit]; break;
517 case 2 :
518 TCFire[64 + 2 * kkk] = m_TCId[ihit]; break;
519 case 3 :
520 TCFire[64 + 2 * kkk + 1] = m_TCId[ihit]; break;
521 case 4 :
522 TCFire[32 + 2 * kkk + 1] = m_TCId[ihit]; break;
523 default:
524 break;
525 }
526 }
527 }
528
529 for (int iii = 0 ; iii < 96 ; iii++) {
530 int icn_flag = 0;
531 if (iii < 32) {
532 if (iii % 2 == 1) {
533 continue;
534 }
535 }
536 for (int iinit = 0; iinit < 9; iinit ++)
537 m_TempCluster[iinit] = 0;
538 if (TCFire[iii] == 0)
539 continue;
540 // cppcheck-suppress knownConditionTrueFalse
541 if (iii < 32) { // most inner
542 if (iii == 0) {
543 m_TempCluster[0] = TCFire[iii];
544 m_TempCluster[1] = TCFire[30]; // top
545 m_TempCluster[2] = TCFire[63]; // left up
546 m_TempCluster[3] = TCFire[iii + 32] ; // left 1
547 m_TempCluster[4] = TCFire[iii + 33]; // left 2
548 m_TempCluster[5] = TCFire[iii + 34]; // left bottom
549 m_TempCluster[6] = TCFire[iii + 2]; // bottom
550 m_TempCluster[7] = 0;
551 m_TempCluster[8] = 0;
552
553 } else if (iii == 30) {
554 m_TempCluster[0] = TCFire[iii];
555 m_TempCluster[1] = TCFire[iii - 2]; // top
556 m_TempCluster[2] = TCFire[iii + 31]; // left up
557 m_TempCluster[3] = TCFire[iii + 32] ; // left 1
558 m_TempCluster[4] = TCFire[iii + 33]; // left 2
559 m_TempCluster[5] = TCFire[32]; // left bottom
560 m_TempCluster[6] = TCFire[0]; // bottom
561 m_TempCluster[7] = 0;
562 m_TempCluster[8] = 0;
563
564 } else {
565 m_TempCluster[0] = TCFire[iii];
566 m_TempCluster[1] = TCFire[iii - 2]; // top
567 m_TempCluster[2] = TCFire[iii + 31]; // left up
568 m_TempCluster[3] = TCFire[iii + 32] ; // left 1
569 m_TempCluster[4] = TCFire[iii + 33]; // left 2
570 m_TempCluster[5] = TCFire[iii + 34]; // left bottom
571 m_TempCluster[6] = TCFire[iii + 2]; // bottom
572 m_TempCluster[7] = 0;
573 m_TempCluster[8] = 0;
574
575 }
576 if (!(m_TempCluster[1] != 0 || (m_TempCluster[3] != 0 || m_TempCluster[4] != 0))) {
577 if (!(m_TempCluster[5] != 0 && m_TempCluster[6] != 0)) {
578 icn_flag = 1;
579
580
581 }
582 }
583
584 } else if (iii < 64) {
585 if (iii == 32) {
586 m_TempCluster[0] = TCFire[iii];
587 m_TempCluster[1] = TCFire[63]; // up
588 m_TempCluster[2] = TCFire[iii - 2]; // up right
589 m_TempCluster[3] = TCFire[iii - 32]; // right
590 m_TempCluster[4] = 0; //right bottom
591 m_TempCluster[5] = TCFire[iii + 1]; // bottom
592 m_TempCluster[6] = TCFire[iii + 33]; // left bottom
593 m_TempCluster[7] = TCFire[iii + 32]; // left
594 m_TempCluster[8] = TCFire[95]; // up left
595
596 } else if (iii == 33) {
597
598 m_TempCluster[0] = TCFire[iii];
599 m_TempCluster[1] = TCFire[iii - 1]; // up
600 m_TempCluster[2] = 0; // up right
601 m_TempCluster[3] = TCFire[iii - 32]; // right
602 m_TempCluster[4] = TCFire[iii - 30]; //right bottom
603 m_TempCluster[5] = TCFire[iii + 1]; // bottom
604 m_TempCluster[6] = TCFire[iii + 33]; // left bottom
605 m_TempCluster[7] = TCFire[iii + 32]; // left
606 m_TempCluster[8] = TCFire[iii + 31]; // up left
607
608 }
609
610 else if (iii == 62) {
611 m_TempCluster[0] = TCFire[iii];
612 m_TempCluster[1] = TCFire[iii - 1]; // up
613 m_TempCluster[2] = TCFire[iii - 34]; // up right
614 m_TempCluster[3] = TCFire[iii - 32]; // right
615 m_TempCluster[4] = 0; //right bottom
616 m_TempCluster[5] = TCFire[iii + 1]; // bottom
617 m_TempCluster[6] = TCFire[iii + 33]; // left bottom
618 m_TempCluster[7] = TCFire[iii + 32]; // left
619 m_TempCluster[8] = TCFire[iii + 31]; // up left
620
621
622 } else if (iii == 63) {
623 m_TempCluster[0] = TCFire[iii];
624 m_TempCluster[1] = TCFire[iii - 1]; // up
625 m_TempCluster[2] = 0; // up right
626 m_TempCluster[3] = TCFire[iii - 32]; // right
627 m_TempCluster[4] = TCFire[1]; //right bottom
628 m_TempCluster[5] = TCFire[32]; // bottom
629 m_TempCluster[6] = TCFire[64]; // left bottom
630 m_TempCluster[7] = TCFire[iii + 32]; // left
631 m_TempCluster[8] = TCFire[iii + 31]; // up left
632
633 }
634
635 else {
636
637 m_TempCluster[0] = TCFire[iii];
638 m_TempCluster[1] = TCFire[iii - 1]; // up
639 m_TempCluster[2] = TCFire[iii - 34]; // up right
640 m_TempCluster[3] = TCFire[iii - 32]; // right
641 m_TempCluster[4] = TCFire[iii - 30]; //right bottom
642 m_TempCluster[5] = TCFire[iii + 1]; // bottom
643 m_TempCluster[6] = TCFire[iii + 33]; // left bottom
644 m_TempCluster[7] = TCFire[iii + 32]; // left
645 m_TempCluster[8] = TCFire[iii + 31]; // up left
646 if (iii % 2 == 0) {
647 m_TempCluster[4] = 0;
648 } else {
649 m_TempCluster[2] = 0;
650 }
651 }
652 if (!(m_TempCluster[1] != 0 || m_TempCluster[7] != 0)) {
653 if (!(m_TempCluster[5] != 0 && m_TempCluster[6] != 0)) {
654 icn_flag = 1;
655 }
656 }
657
658 } else {
659 if (iii == 64) {
660 m_TempCluster[0] = TCFire[iii];
661 m_TempCluster[1] = TCFire[95]; // top
662 m_TempCluster[2] = TCFire[63];// right top
663 m_TempCluster[3] = TCFire[iii - 32]; //right
664 m_TempCluster[4] = TCFire[iii - 31]; //right bottom
665 m_TempCluster[5] = TCFire[iii + 1]; //bottom
666 m_TempCluster[6] = 0; //bottom left
667 m_TempCluster[7] = 0; // left
668 m_TempCluster[8] = 0; //top left
669 } else if (iii == 95) {
670 m_TempCluster[0] = TCFire[iii];
671 m_TempCluster[1] = TCFire[iii - 1]; // top
672 m_TempCluster[2] = TCFire[iii - 33]; // right top
673 m_TempCluster[3] = TCFire[iii - 32]; //right
674 m_TempCluster[4] = TCFire[32]; //right bottom
675 m_TempCluster[5] = TCFire[64]; //bottom
676 m_TempCluster[6] = 0; //bottom left
677 m_TempCluster[7] = 0; // left
678 m_TempCluster[8] = 0; //top left
679
680 } else {
681 m_TempCluster[0] = TCFire[iii];
682 m_TempCluster[1] = TCFire[iii - 1]; // top
683 m_TempCluster[2] = TCFire[iii - 33]; // right top
684 m_TempCluster[3] = TCFire[iii - 32]; //right
685 m_TempCluster[4] = TCFire[iii - 31]; //right bottom
686 m_TempCluster[5] = TCFire[iii + 1]; //bottom
687 m_TempCluster[6] = 0; //bottom left
688 m_TempCluster[7] = 0; // left
689 m_TempCluster[8] = 0; //top left
690 }
691 if (!(m_TempCluster[1] != 0 || m_TempCluster[7] != 0)) {
692 if (!(m_TempCluster[5] != 0 && m_TempCluster[6] != 0)) {
693 icn_flag = 1;
694
695 }
696 }
697
698
699 }
700
701 if (icn_flag == 1) {
702 TempICNTCId = TCFire[iii];
703
704 if (Method == 1) { //for cluster method2
705 int maxTCid = 0;
706 double maxTCEnergy = 0;
707 for (int iTC = 0; iTC < 9; iTC++) { //find center of Cluster
708 if (m_TempCluster[iTC] == 0) {continue;}
709 if (maxTCEnergy < TCFireEnergy[m_TempCluster[iTC] - 1]) {
710 maxTCEnergy = TCFireEnergy[m_TempCluster[iTC] - 1];
711 maxTCid = m_TempCluster[iTC];
712 }
713 }
714 m_TempCluster.resize(9, 0);
715 m_TempCluster[0] = maxTCid;
716 int kkk = (m_TempCluster[0] - 1) / 5;
717 if ((m_TempCluster[0] - 1) % 5 == 0) {
718 kkk = kkk * 2;
719 } else if ((m_TempCluster[0] - 1) % 5 == 1) {
720 kkk = 32 + 2 * kkk;
721 } else if ((m_TempCluster[0] - 1) % 5 == 2) {
722 kkk = 64 + 2 * kkk;
723 } else if ((m_TempCluster[0] - 1) % 5 == 3) {
724 kkk = 64 + 1 + 2 * kkk;
725 } else if ((m_TempCluster[0] - 1) % 5 == 4) {
726 kkk = 32 + 1 + 2 * kkk;
727 }
728
729 if (kkk < 32) { // most inner
730 if (kkk == 0) {
731 m_TempCluster[0] = TCFire[kkk];
732 m_TempCluster[1] = TCFire[30]; // top
733 m_TempCluster[2] = TCFire[63]; // left up
734 m_TempCluster[3] = TCFire[kkk + 32] ; // left 1
735 m_TempCluster[4] = TCFire[kkk + 33]; // left 2
736 m_TempCluster[5] = TCFire[kkk + 34]; // left bottom
737 m_TempCluster[6] = TCFire[kkk + 2]; // bottom
738 m_TempCluster[7] = 0;
739 m_TempCluster[8] = 0;
740
741 } else if (kkk == 30) {
742 m_TempCluster[0] = TCFire[kkk];
743 m_TempCluster[1] = TCFire[kkk - 2]; // top
744 m_TempCluster[2] = TCFire[kkk + 31]; // left up
745 m_TempCluster[3] = TCFire[kkk + 32] ; // left 1
746 m_TempCluster[4] = TCFire[kkk + 33]; // left 2
747 m_TempCluster[5] = TCFire[32]; // left bottom
748 m_TempCluster[6] = TCFire[0]; // bottom
749 m_TempCluster[7] = 0;
750 m_TempCluster[8] = 0;
751
752 } else {
753 m_TempCluster[0] = TCFire[kkk];
754 m_TempCluster[1] = TCFire[kkk - 2]; // top
755 m_TempCluster[2] = TCFire[kkk + 31]; // left up
756 m_TempCluster[3] = TCFire[kkk + 32] ; // left 1
757 m_TempCluster[4] = TCFire[kkk + 33]; // left 2
758 m_TempCluster[5] = TCFire[kkk + 34]; // left bottom
759 m_TempCluster[6] = TCFire[kkk + 2]; // bottom
760 m_TempCluster[7] = 0;
761 m_TempCluster[8] = 0;
762
763 }
764
765 } else if (kkk < 64) {
766 if (kkk == 32) {
767 m_TempCluster[0] = TCFire[kkk];
768 m_TempCluster[1] = TCFire[63]; // up
769 m_TempCluster[2] = TCFire[kkk - 2]; // up right
770 m_TempCluster[3] = TCFire[kkk - 32]; // right
771 m_TempCluster[4] = 0; //right bottom
772 m_TempCluster[5] = TCFire[kkk + 1]; // bottom
773 m_TempCluster[6] = TCFire[kkk + 33]; // left bottom
774 m_TempCluster[7] = TCFire[kkk + 32]; // left
775 m_TempCluster[8] = TCFire[95]; // up left
776
777 } else if (kkk == 33) {
778
779 m_TempCluster[0] = TCFire[kkk];
780 m_TempCluster[1] = TCFire[kkk - 1]; // up
781 m_TempCluster[2] = 0; // up right
782 m_TempCluster[3] = TCFire[kkk - 32]; // right
783 m_TempCluster[4] = TCFire[kkk - 30]; //right bottom
784 m_TempCluster[5] = TCFire[kkk + 1]; // bottom
785 m_TempCluster[6] = TCFire[kkk + 33]; // left bottom
786 m_TempCluster[7] = TCFire[kkk + 32]; // left
787 m_TempCluster[8] = TCFire[kkk + 31]; // up left
788
789 }
790
791 else if (kkk == 62) {
792 m_TempCluster[0] = TCFire[kkk];
793 m_TempCluster[1] = TCFire[kkk - 1]; // up
794 m_TempCluster[2] = TCFire[kkk - 34]; // up right
795 m_TempCluster[3] = TCFire[kkk - 32]; // right
796 m_TempCluster[4] = 0; //right bottom
797 m_TempCluster[5] = TCFire[kkk + 1]; // bottom
798 m_TempCluster[6] = TCFire[kkk + 33]; // left bottom
799 m_TempCluster[7] = TCFire[kkk + 32]; // left
800 m_TempCluster[8] = TCFire[kkk + 31]; // up left
801
802
803 } else if (kkk == 63) {
804 m_TempCluster[0] = TCFire[kkk];
805 m_TempCluster[1] = TCFire[kkk - 1]; // up
806 m_TempCluster[2] = 0; // up right
807 m_TempCluster[3] = TCFire[kkk - 32]; // right
808 m_TempCluster[4] = TCFire[1]; //right bottom
809 m_TempCluster[5] = TCFire[32]; // bottom
810 m_TempCluster[6] = TCFire[64]; // left bottom
811 m_TempCluster[7] = TCFire[kkk + 32]; // left
812 m_TempCluster[8] = TCFire[kkk + 31]; // up left
813
814 }
815
816 else {
817 m_TempCluster[0] = TCFire[kkk];
818 m_TempCluster[1] = TCFire[kkk - 1]; // up
819 m_TempCluster[2] = TCFire[kkk - 34]; // up right
820 m_TempCluster[3] = TCFire[kkk - 32]; // right
821 m_TempCluster[4] = TCFire[kkk - 30]; //right bottom
822 m_TempCluster[5] = TCFire[kkk + 1]; // bottom
823 m_TempCluster[6] = TCFire[kkk + 33]; // left bottom
824 m_TempCluster[7] = TCFire[kkk + 32]; // left
825 m_TempCluster[8] = TCFire[kkk + 31]; // up left
826 if (kkk % 2 == 0) {
827 m_TempCluster[4] = 0;
828 } else {
829 m_TempCluster[2] = 0;
830 }
831
832 }
833
834
835
836 } else {
837 if (kkk == 64) {
838 m_TempCluster[0] = TCFire[kkk];
839 m_TempCluster[1] = TCFire[95]; // top
840 m_TempCluster[2] = TCFire[63];// right top
841 m_TempCluster[3] = TCFire[kkk - 32]; //right
842 m_TempCluster[4] = TCFire[kkk - 31]; //right bottom
843 m_TempCluster[5] = TCFire[kkk + 1]; //bottom
844 m_TempCluster[6] = 0; //bottom left
845 m_TempCluster[7] = 0; // left
846 m_TempCluster[8] = 0; //top left
847 } else if (kkk == 95) {
848 m_TempCluster[0] = TCFire[kkk];
849 m_TempCluster[1] = TCFire[kkk - 1]; // top
850 m_TempCluster[2] = TCFire[kkk - 33]; // right top
851 m_TempCluster[3] = TCFire[kkk - 32]; //right
852 m_TempCluster[4] = TCFire[32]; //right bottom
853 m_TempCluster[5] = TCFire[64]; //bottom
854 m_TempCluster[6] = 0; //bottom left
855 m_TempCluster[7] = 0; // left
856 m_TempCluster[8] = 0; //top left
857
858 } else {
859 m_TempCluster[0] = TCFire[kkk];
860 m_TempCluster[1] = TCFire[kkk - 1]; // top
861 m_TempCluster[2] = TCFire[kkk - 33]; // right top
862 m_TempCluster[3] = TCFire[kkk - 32]; //right
863 m_TempCluster[4] = TCFire[kkk - 31]; //right bottom
864 m_TempCluster[5] = TCFire[kkk + 1]; //bottom
865 m_TempCluster[6] = 0; //bottom left
866 m_TempCluster[7] = 0; // left
867 m_TempCluster[8] = 0; //top left
868 }
869
870 }
871 }
872 for (int iNearTC = 1; iNearTC < 9; iNearTC ++) {
873 for (int jNearTC = 1; jNearTC < 9; jNearTC ++) {
874 if (m_TempCluster[iNearTC] == 0) {continue;}
875 if (iNearTC == jNearTC)continue;
876 if (m_TempCluster[iNearTC] == m_TempCluster[jNearTC]) {
877 m_TempCluster[jNearTC] = 0;
878 }
879 }
880 }
881
882 int maxTCId = 999;
883 double clusterenergy = 0;
884 double clustertiming = 0;
885 double clusterpositionX = 0;
886 double clusterpositionY = 0;
887 double clusterpositionZ = 0;
888 int noftcincluster = 0;
889 for (int iNearTC = 0; iNearTC < 9; iNearTC ++) {
890 if (m_TempCluster[iNearTC] == 0) {continue;}
891 else {noftcincluster++;}
892 clusterenergy += TCFireEnergy[m_TempCluster[iNearTC] - 1];
893 clustertiming += TCFireEnergy[m_TempCluster[iNearTC] - 1] * TCFireTiming[m_TempCluster[iNearTC] - 1];
894 clusterpositionX += TCFireEnergy[m_TempCluster[iNearTC] - 1] * TCFirePosition[m_TempCluster[iNearTC] - 1][0];
895 clusterpositionY += TCFireEnergy[m_TempCluster[iNearTC] - 1] * TCFirePosition[m_TempCluster[iNearTC] - 1][1];
896 clusterpositionZ += TCFireEnergy[m_TempCluster[iNearTC] - 1] * TCFirePosition[m_TempCluster[iNearTC] - 1][2];
897
898 }
899 //
900 maxTCId = m_TempCluster[0];
901 //
902
903 clustertiming /= clusterenergy;
904 if (m_Position == 1) {
905 clusterpositionX /= clusterenergy;
906 clusterpositionY /= clusterenergy;
907 clusterpositionZ /= clusterenergy;
908 } else if (m_Position == 0) {
909 clustertiming = TCFireTiming[maxTCId - 1];
910 clusterpositionX = TCFirePosition[maxTCId - 1][0];
911 clusterpositionY = TCFirePosition[maxTCId - 1][1];
912 clusterpositionZ = TCFirePosition[maxTCId - 1][2];
913 }
914 if (clustertiming == 0 && clusterenergy == 0) {continue;}
915
916 TempClusterEnergy.push_back(clusterenergy);
917 TempClusterTiming.push_back(clustertiming);
918 TempClusterPositionX.push_back(clusterpositionX);
919 TempClusterPositionY.push_back(clusterpositionY);
920 TempClusterPositionZ.push_back(clusterpositionZ);
921 TempNofTCinCluster.push_back(noftcincluster);
922 TempMaxTCId.push_back(maxTCId);
923
924 Sort1D.push_back(TempICNTCId);
925 Sort1D.push_back(clusterenergy);
926 Sort1D.push_back(clustertiming);
927 Sort1D.push_back(clusterpositionX);
928 Sort1D.push_back(clusterpositionY);
929 Sort1D.push_back(clusterpositionZ);
930 Sort1D.push_back(noftcincluster);
931 Sort1D.push_back(maxTCId);
932
933 Sort2D.push_back(Sort1D);
934 Sort1D.clear();
935
936 }
937
938 }
939
940 // Sorting in the order of TC Id
941
942 sort(Sort2D.begin(), Sort2D.end(),
943 [](const vector<double>& aa1, const vector<double>& aa2) {return aa1[0] < aa2[0];});
944
945 const int clustersize = Sort2D.size();
946 for (int jtc = 0; jtc < clustersize; jtc++) {
947
948 m_ClusterEnergy[1].push_back(Sort2D[jtc][1]);
949 m_ClusterTiming[1].push_back(Sort2D[jtc][2]);
950 m_ClusterPositionX[1].push_back(Sort2D[jtc][3]);
951 m_ClusterPositionY[1].push_back(Sort2D[jtc][4]);
952 m_ClusterPositionZ[1].push_back(Sort2D[jtc][5]);
953 m_NofTCinCluster[1].push_back(Sort2D[jtc][6]);
954 m_MaxTCId[1].push_back(Sort2D[jtc][7]);
955 }
956
957 m_FWDNofCluster = m_MaxTCId[1].size();
958}

◆ setICN() [1/2]

void setICN ( const std::vector< int > & tcid)

set ICN for each part(Fw,Br,Bw)

Definition at line 153 of file TrgEclCluster.cc.

154{
155 m_TCId = tcid ;
156 m_Quadrant.clear();
157 m_Quadrant.resize(3, std::vector<int>(4, 0.0));
158 m_icnfwbrbw.clear();
159 m_icnfwbrbw.resize(3, 0);
160 m_BRICN = 0 ;
161 m_FWDICN = 0;
162 m_BWDICN = 0;
163
164 m_icnfwbrbw[1] = setBarrelICN();
165 m_icnfwbrbw[0] = setForwardICN();
166 m_icnfwbrbw[2] = setBackwardICN();
167
168 return;
169}
Belle2::TrgEclCluster::setBarrelICN
int setBarrelICN()
calculate Belle ICN in Barrel
Definition TrgEclCluster.cc:1309
Belle2::TrgEclCluster::setBackwardICN
int setBackwardICN()
calculate Belle ICN in Backward endcap
Definition TrgEclCluster.cc:1605
Belle2::TrgEclCluster::setForwardICN
int setForwardICN()
calculate Belle ICN in Forward endcap
Definition TrgEclCluster.cc:1452

◆ setICN() [2/2]

void setICN ( const std::vector< int > & tcid,
const std::vector< double > & tcenergy,
const std::vector< double > & tctiming )

set Belle 2 Clustering

Definition at line 174 of file TrgEclCluster.cc.

177{
178 m_TCId = tcid ;
179 m_Energy = tcenergy;
180 m_Timing = tctiming;
181
182 setBarrelICN(m_Method);
183 setForwardICN(m_Method);
184 setBackwardICN(m_Method);
185
186 save(m_EventId);
187
188 return;
189}
Belle2::TrgEclCluster::save
void save(int)
Save Cluster information in TRGECLCluster Table.
Definition TrgEclCluster.cc:194

Member Data Documentation

◆ m_BrCluster

std::vector<std::vector<int> > m_BrCluster
private

cluster in barrel

Definition at line 146 of file TrgEclCluster.h.

◆ m_BRICN

int m_BRICN
private

get Beam bkg veto flag.

On = true, Off = false. ICN in Barrel

Definition at line 112 of file TrgEclCluster.h.

◆ m_BRNofCluster

int m_BRNofCluster
private

Cluster in Barrel.

Definition at line 118 of file TrgEclCluster.h.

◆ m_BwCluster

std::vector<std::vector<int> > m_BwCluster
private

cluster in backward endcap

Definition at line 150 of file TrgEclCluster.h.

◆ m_BWDICN

int m_BWDICN
private

ICN in Backward Endcap.

Definition at line 116 of file TrgEclCluster.h.

◆ m_BWDNofCluster

int m_BWDNofCluster
private

Cluster in Backward Endcap.

Definition at line 122 of file TrgEclCluster.h.

◆ m_ClusterEnergy

std::vector<std::vector<double> > m_ClusterEnergy
private

Cluster enrgy.

Definition at line 157 of file TrgEclCluster.h.

◆ m_ClusterPositionX

std::vector<std::vector<double> > m_ClusterPositionX
private

Cluster position in X-axis.

Definition at line 159 of file TrgEclCluster.h.

◆ m_ClusterPositionY

std::vector<std::vector<double> > m_ClusterPositionY
private

Cluster position in Y-axis.

Definition at line 161 of file TrgEclCluster.h.

◆ m_ClusterPositionZ

std::vector<std::vector<double> > m_ClusterPositionZ
private

Cluster position in Z-axis.

Definition at line 163 of file TrgEclCluster.h.

◆ m_ClusterTiming

std::vector<std::vector<double> > m_ClusterTiming
private

Cluster timing.

Definition at line 155 of file TrgEclCluster.h.

◆ m_Energy

std::vector<double> m_Energy
private

TC energy.

Definition at line 140 of file TrgEclCluster.h.

◆ m_EventId

int m_EventId
private

event number

Definition at line 124 of file TrgEclCluster.h.

◆ m_FwCluster

std::vector<std::vector<int> > m_FwCluster
private

cluster in forward endcap

Definition at line 148 of file TrgEclCluster.h.

◆ m_FWDICN

int m_FWDICN
private

ICN in Forward Endcap.

Definition at line 114 of file TrgEclCluster.h.

◆ m_FWDNofCluster

int m_FWDNofCluster
private

Cluster in Forward Endcap.

Definition at line 120 of file TrgEclCluster.h.

◆ m_icnfwbrbw

std::vector<int> m_icnfwbrbw
private

icn

Definition at line 134 of file TrgEclCluster.h.

◆ m_LimitNCluster

int m_LimitNCluster
private

the Limit Number of Cluster

Definition at line 128 of file TrgEclCluster.h.

◆ m_MaxTCId

std::vector<std::vector<int> > m_MaxTCId
private

Maximum contribution TC Id in Cluster.

Definition at line 167 of file TrgEclCluster.h.

◆ m_Method

int m_Method
private

Clustering method.

Definition at line 126 of file TrgEclCluster.h.

◆ m_NofTCinCluster

std::vector<std::vector<int> > m_NofTCinCluster
private

N of TC in Cluster.

Definition at line 165 of file TrgEclCluster.h.

◆ m_Position

int m_Position
private

Position calculation method(0:Most energetic TC Position, 1 : Energy weighted Position)

Definition at line 130 of file TrgEclCluster.h.

◆ m_Quadrant

std::vector<std::vector<int> > m_Quadrant
private

Quadrant for Beam Background veto.

Definition at line 143 of file TrgEclCluster.h.

◆ m_TCId

std::vector<int> m_TCId
private

TC Id.

Definition at line 136 of file TrgEclCluster.h.

◆ m_TCMap

TrgEclMapping* m_TCMap
private

Object of TC Mapping.

Definition at line 171 of file TrgEclCluster.h.

◆ m_TempCluster

std::vector<int> m_TempCluster
private

Temporal Cluster.

Definition at line 169 of file TrgEclCluster.h.

◆ m_Timing

std::vector<double> m_Timing
private

TC timing.

Definition at line 138 of file TrgEclCluster.h.

The documentation for this class was generated from the following files: