Belle II Software  release-06-00-14
TRGGRLMatchModule.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 // include
10 #include <trg/grl/modules/trggrl/TRGGRLMatchModule.h>
11 #include <trg/grl/dataobjects/TRGGRLMATCH.h>
12 #include <trg/grl/dataobjects/TRGGRLMATCHKLM.h>
13 #include <trg/grl/dataobjects/TRGGRLPHOTON.h>
14 #include <trg/cdc/dataobjects/CDCTriggerTrack.h>
15 #include <trg/ecl/dataobjects/TRGECLCluster.h>
16 #include <trg/klm/dataobjects/KLMTrgSummary.h>
17 #include <trg/cdc/dataobjects/CDCTriggerSegmentHit.h>
18 #include <trg/grl/dataobjects/TRGGRLInfo.h>
19 #include <trg/grl/dataobjects/TRGGRLShortTrack.h>
20 #include <trg/grl/dataobjects/TRGGRLInnerTrack.h>
21 
22 // framework - DataStore
23 #include <framework/datastore/StoreArray.h>
24 #include <framework/datastore/StoreObjPtr.h>
25 
26 //framework aux
27 #include <framework/logging/Logger.h>
28 #include <framework/core/ModuleParamList.templateDetails.h>
29 
30 #include <stdlib.h>
31 
32 
33 using namespace Belle2;
34 //-----------------------------------------------------------------
35 // Register the Module
36 //-----------------------------------------------------------------
37 REG_MODULE(TRGGRLMatch)
38 
39 //-----------------------------------------------------------------
40 // Implementation
41 //-----------------------------------------------------------------
42 
43 TRGGRLMatchModule::TRGGRLMatchModule() : Module()
44 {
45  // Set module properties
46  setDescription("match CDC trigger tracks and ECL trigger clusters");
47  setPropertyFlags(c_ParallelProcessingCertified);
48  addParam("SimulationMode", m_simulationMode, "TRGGRL simulation switch", 1);
49  addParam("FastSimulationMode", m_fastSimulationMode, "TRGGRL fast simulation mode", m_fastSimulationMode);
50  addParam("FirmwareSimulationMode", m_firmwareSimulationMode, "TRGGRL firmware simulation mode", m_firmwareSimulationMode);
51 
52  addParam("DrMatch", m_dr_threshold, "the threshold of dr between track and cluster if they are matched successfully", 25.);
53  addParam("DzMatch", m_dz_threshold, "the threshold of dz between track and cluster if they are matched successfully", 30.);
54  addParam("DphidMatch", m_dphi_d_threshold, "the threshold of dphi_d between track and cluster if they are matched successfully", 2);
55  addParam("Ephoton", m_e_threshold, "the threshold of cluster energy as a photon", 1.0);
56  addParam("KLMMatch", m_dphi_klm_threshold,
57  "the threshold of dphi (in degree) between track and KLM sector if they are matched successfully", 32.5);
58  addParam("2DtrackCollection", m_2d_tracklist, "the 2d track list used in the match", std::string("TRGCDC2DFinderTracks"));
59  addParam("3DtrackCollection", m_3d_tracklist, "the 3d track list used in the match", std::string("TRGCDCNeuroTracks"));
60  addParam("TRGECLClusterCollection", m_clusterlist, "the cluster list used in the match", std::string("TRGECLClusters"));
61  addParam("KLMTrgrSummary", m_klmtrgsummarylist, "the KLM track list used in the match", std::string("KLMTrgSummary"));
62  addParam("2DmatchCollection", m_2dmatch_tracklist, "the 2d tracklist with associated cluster", std::string("TRG2DMatchTracks"));
63  addParam("PhimatchCollection", m_phimatch_tracklist, "the 2d tracklist with associated cluster", std::string("TRGPhiMatchTracks"));
64  addParam("3DmatchCollection", m_3dmatch_tracklist, "the 3d NN tracklist with associated cluster", std::string("TRG3DMatchTracks"));
65  addParam("KLMmatchCollection", m_klmmatch_tracklist, "the 2d tracklist with associated KLM track",
66  std::string("TRGKLMMatchTracks"));
67  addParam("GRLphotonCollection", m_grlphotonlist, "the isolated cluster list", std::string("TRGGRLPhotons"));
68  addParam("hitCollectionName", m_hitCollectionName, "Name of the input StoreArray of CDCTriggerSegmentHits.", std::string(""));
69  addParam("TrgGrlInformation", m_TrgGrlInformationName,
70  "Name of the StoreArray holding the information of tracks and clusters from cdc ecl klm.",
71  std::string("TRGGRLObjects"));
72  addParam("grlstCollectionName", m_grlstCollectionName, "Name of the output StoreArray of TRGGRLShortTrack.",
73  std::string("TRGGRLShortTracks"));
74  addParam("grlitCollectionName", m_grlitCollectionName, "Name of the output StoreArray of TRGGRLInnerTrack.",
75  std::string("TRGGRLInnerTracks"));
76 
77 
78 }
79 
80 TRGGRLMatchModule::~TRGGRLMatchModule()
81 {
82 }
83 
84 void TRGGRLMatchModule::initialize()
85 {
86  B2DEBUG(100, "TRGGRLMatchModule processing");
87  StoreArray<CDCTriggerTrack> track2Dlist(m_2d_tracklist);
88  StoreArray<CDCTriggerTrack> track3Dlist(m_3d_tracklist);
89  track2Dlist.isRequired();
90  track3Dlist.isRequired();
91  StoreArray<TRGECLCluster> clusterslist(m_clusterlist);
92  clusterslist.isRequired();
93  clusterslist.registerRelationTo(track2Dlist);
94  clusterslist.registerRelationTo(track3Dlist);
95  StoreObjPtr<KLMTrgSummary> klmtrgsummary(m_klmtrgsummarylist);
96  klmtrgsummary.isRequired();
97 
98  StoreArray<CDCTriggerSegmentHit> tslist(m_hitCollectionName);
99  tslist.isRequired();
100 
101  StoreArray<TRGGRLMATCH> track2Dmatch;
102  track2Dmatch.registerInDataStore(m_2dmatch_tracklist);
103  track2Dmatch.registerRelationTo(track2Dlist);
104  track2Dmatch.registerRelationTo(clusterslist);
105 
106  StoreArray<TRGGRLMATCH> trackphimatch;
107  trackphimatch.registerInDataStore(m_phimatch_tracklist);
108  trackphimatch.registerRelationTo(track2Dlist);
109  trackphimatch.registerRelationTo(clusterslist);
110 
111  StoreArray<TRGGRLMATCH> track3Dmatch;
112  track3Dmatch.registerInDataStore(m_3dmatch_tracklist);
113  track3Dmatch.registerRelationTo(clusterslist);
114  track3Dmatch.registerRelationTo(track3Dlist);
115 
116  StoreArray<TRGGRLMATCHKLM> trackKLMmatch;
117  trackKLMmatch.registerInDataStore(m_klmmatch_tracklist);
118  trackKLMmatch.registerRelationTo(track2Dlist);
119 
120  StoreArray<TRGGRLPHOTON> grlphoton;
121  grlphoton.registerInDataStore(m_grlphotonlist);
122  grlphoton.registerRelationTo(clusterslist);
123 
124  StoreArray<TRGGRLShortTrack> grlst;
125  grlst.registerInDataStore(m_grlstCollectionName);
126 
127  StoreArray<TRGGRLInnerTrack> grlit;
128  grlit.registerInDataStore(m_grlitCollectionName);
129 
130  m_TRGGRLInfo.registerInDataStore(m_TrgGrlInformationName);
131 
132 //-- Fill the patterns for short tracking
133 
134  fill_pattern_base2(patterns_base2);
135 
136  for (int p = 0; p < 137; p++) {
137  int x0 = patterns_base2[p][0];
138  int x1 = patterns_base2[p][1];
139  int x2 = 0;
140  int x3 = patterns_base2[p][2];
141  int x4 = patterns_base2[p][3];
142  int d = x2 - x0;
143  x1 += d;
144  x2 += d;
145  x3 += d;
146  x4 += d;
147  patterns_base0.push_back({x1, x2, x3, x4});
148  }
149 
150 
151 }
152 
153 void TRGGRLMatchModule::beginRun()
154 {
155 }
156 
157 void TRGGRLMatchModule::event()
158 {
159 
160  StoreArray<CDCTriggerTrack> track2Dlist(m_2d_tracklist);
161  StoreArray<CDCTriggerTrack> track3Dlist(m_3d_tracklist);
162  StoreArray<TRGECLCluster> clusterlist(m_clusterlist);
163  StoreObjPtr<KLMTrgSummary> klmtrgsummary(m_klmtrgsummarylist);
164  StoreArray<CDCTriggerSegmentHit> tslist(m_hitCollectionName);
165  StoreArray<TRGGRLMATCH> track2Dmatch(m_2dmatch_tracklist);
166  StoreArray<TRGGRLMATCH> trackphimatch(m_phimatch_tracklist);
167  StoreArray<TRGGRLMATCH> track3Dmatch(m_3dmatch_tracklist);
168  StoreArray<TRGGRLMATCHKLM> trackKLMmatch(m_klmmatch_tracklist);
169  StoreArray<TRGGRLPHOTON> grlphoton(m_grlphotonlist);
170  StoreArray<TRGGRLShortTrack> grlst(m_grlstCollectionName);
171  StoreArray<TRGGRLInnerTrack> grlit(m_grlitCollectionName);
172  StoreObjPtr<TRGGRLInfo> trgInfo(m_TrgGrlInformationName);
173  trgInfo.create();
174 
175 //initialize the phi map
176 
177  track_phimap.clear();
178  track_phimap_i.clear();
179  eecl_phimap.clear();
180  eecl_phimap_fwd.clear();
181  eecl_phimap_bwd.clear();
182  eecl_sectormap_fwd.clear();
183  eecl_sectormap_bwd.clear();
184  eklm_sectormap.clear();
185  eklm_sectormap_fwd.clear();
186  eklm_sectormap_bwd.clear();
187 
188  for (int i = 0; i < 36; i++) {
189  track_phimap.push_back(false);
190  track_phimap_i.push_back(false);
191  eecl_phimap.push_back(false);
192  eecl_phimap_fwd.push_back(false);
193  eecl_phimap_bwd.push_back(false);
194  }
195  for (int i = 0; i < 4; i++) {
196  eecl_sectormap_fwd.push_back(false);
197  eecl_sectormap_bwd.push_back(false);
198  eklm_sectormap.push_back(false);
199  eklm_sectormap_fwd.push_back(false);
200  eklm_sectormap_bwd.push_back(false);
201  }
202 
203 //do 2d track match with ECL and KLM cluster
204  int klmtrack_ind_phi_map[8] = {};
205  for (int i = 0; i < track2Dlist.getEntries(); i++) {
206 
207  double dr_tmp = 99999.;
208  int dphi_d_tmp = 100;
209  double dphi_klm_tmp = 100;
210  int cluster_ind = -1;
211  int cluster_ind_phi = -1;
212  int klmtrack_ind_phi = -1;
213 
214 // do 2d track match with KLMTrgSummary
215  sectormatching_klm(track2Dlist[i], klmtrgsummary, dphi_klm_tmp, klmtrack_ind_phi);
216 
217  for (int j = 0; j < clusterlist.getEntries(); j++) {
218  // skip the end-cap cluster
219  double _cluster_x = clusterlist[j]->getPositionX();
220  double _cluster_y = clusterlist[j]->getPositionY();
221  double _cluster_z = clusterlist[j]->getPositionZ();
222  double _cluster_theta = atan(_cluster_z / (sqrt(_cluster_x * _cluster_x + _cluster_y * _cluster_y)));
223  _cluster_theta = 0.5 * M_PI - _cluster_theta;
224  if (_cluster_theta < M_PI * 35.0 / 180.0 || _cluster_theta > M_PI * 126.0 / 180.0) continue;
225 
226  double ds_ct[2] = {99999., 99999.};
227  calculationdistance(track2Dlist[i], clusterlist[j], ds_ct, 0);
228  int dphi_d = 0;
229  calculationphiangle(track2Dlist[i], clusterlist[j], dphi_d, track_phimap, track_phimap_i);
230 
231  if (dr_tmp > ds_ct[0]) {
232  dr_tmp = ds_ct[0];
233  cluster_ind = j;
234  }
235  if (dphi_d_tmp > dphi_d) {
236  dphi_d_tmp = dphi_d;
237  cluster_ind_phi = j;
238  }
239 
240  }
241 
242  if (dr_tmp < m_dr_threshold && cluster_ind != -1) {
243  TRGGRLMATCH* mat2d = track2Dmatch.appendNew();
244  mat2d->setDeltaR(dr_tmp);
245  mat2d->addRelationTo(track2Dlist[i]);
246  mat2d->addRelationTo(clusterlist[cluster_ind]);
247  // track2Dlist[i]->addRelationTo(clusterlist[cluster_ind]);
248  clusterlist[cluster_ind]->addRelationTo(track2Dlist[i]);
249  }
250  if (dphi_d_tmp < m_dphi_d_threshold && cluster_ind_phi != -1) {
251  TRGGRLMATCH* matphi = trackphimatch.appendNew();
252  matphi->set_dphi_d(dphi_d_tmp);
253  matphi->addRelationTo(track2Dlist[i]);
254  matphi->addRelationTo(clusterlist[cluster_ind_phi]);
255  matphi->set_e(clusterlist[cluster_ind_phi]->getEnergyDep());
256  // track2Dlist[i]->addRelationTo(clusterlist[cluster_ind]);
257  clusterlist[cluster_ind_phi]->addRelationTo(track2Dlist[i]);
258  }
259 
260  if (dphi_klm_tmp < m_dphi_klm_threshold * M_PI / 180.0 && klmtrack_ind_phi > -1 && klmtrack_ind_phi < 8) {
261  if (klmtrack_ind_phi_map[klmtrack_ind_phi] == 0) {
262  TRGGRLMATCHKLM* matklm = trackKLMmatch.appendNew();
263  matklm->set_dphi(dphi_klm_tmp);
264  matklm->set_sector(klmtrack_ind_phi);
265  matklm->addRelationTo(track2Dlist[i]);
266  klmtrack_ind_phi_map[klmtrack_ind_phi] = 1;
267  }
268  }
269 
270  }
271 
272 
273 //do 3d track match with cluster
274  for (int i = 0; i < track3Dlist.getEntries(); i++) {
275 
276  double dr_tmp = 99999.;
277  double dz_tmp = 99999.;
278  int cluster_ind = -1;
279  for (int j = 0; j < clusterlist.getEntries(); j++) {
280  // skip the end-cap cluster
281  double _cluster_x = clusterlist[j]->getPositionX();
282  double _cluster_y = clusterlist[j]->getPositionY();
283  double _cluster_z = clusterlist[j]->getPositionZ();
284  double _cluster_theta = atan(_cluster_z / (sqrt(_cluster_x * _cluster_x + _cluster_y * _cluster_y)));
285  _cluster_theta = 0.5 * M_PI - _cluster_theta;
286  if (_cluster_theta < M_PI * 35.0 / 180.0 || _cluster_theta > M_PI * 126.0 / 180.0) continue;
287 
288  double ds_ct[2] = {99999., 99999.};
289  calculationdistance(track3Dlist[i], clusterlist[j], ds_ct, 1);
290  if (dr_tmp > ds_ct[0]) {
291  dr_tmp = ds_ct[0];
292  dz_tmp = ds_ct[1];
293  cluster_ind = j;
294  }
295  }
296  if (dr_tmp < m_dr_threshold && dz_tmp < m_dz_threshold && cluster_ind != -1) {
297  TRGGRLMATCH* mat3d = track3Dmatch.appendNew();
298  mat3d->setDeltaR(dr_tmp);
299  mat3d->setDeltaZ(dz_tmp);
300  mat3d->addRelationTo(track3Dlist[i]);
301  mat3d->addRelationTo(clusterlist[cluster_ind]);
302  clusterlist[cluster_ind]->addRelationTo(track3Dlist[i]);
303  }
304  }
305 
306 //pick up isolated clusters as photons with energy thrshold
307  for (int j = 0; j < clusterlist.getEntries(); j++) {
308  if (photon_cluster(clusterlist[j], track_phimap, m_e_threshold)) {
309  TRGGRLPHOTON* photon = grlphoton.appendNew();
310  photon->set_e(clusterlist[j]->getEnergyDep());
311  photon->addRelationTo(clusterlist[j]);
312  }
313  }
314 
315 //endcap cluster map
316  make_eecl_map(clusterlist, eecl_phimap, eecl_phimap_fwd, eecl_phimap_bwd, eecl_sectormap_fwd, eecl_sectormap_bwd);
317  make_eklm_map(klmtrgsummary, eklm_sectormap, eklm_sectormap_fwd, eklm_sectormap_bwd);
318 
319 // Short tracking
320  std::vector<bool> map_veto(64, 0);
321  make_veto_map(track2Dlist, map_veto);
322  short_tracking(tslist, map_veto, track_phimap_i, eecl_phimap_fwd, eecl_phimap_bwd, eklm_sectormap_fwd, eklm_sectormap_bwd,
323  patterns_base0, patterns_base2, grlst, trgInfo);
324 
325 // Inner tracking
326  inner_tracking(tslist, track_phimap_i, eecl_phimap, eklm_sectormap, grlit, trgInfo);
327 
328 // EECL-EKLM matching
329  matching_eecl_eklm(eecl_sectormap_fwd, eecl_sectormap_bwd, eklm_sectormap_fwd, eklm_sectormap_bwd, trgInfo);
330 
331 }
332 
333 void TRGGRLMatchModule::endRun()
334 {
335 }
336 
337 void TRGGRLMatchModule::terminate()
338 {
339 }
340 
341 void TRGGRLMatchModule::calculationdistance(CDCTriggerTrack* _track, TRGECLCluster* _cluster, double* ds, int _match3D)
342 {
343 
344 //double _pt = _track->getTransverseMomentum(1.5);
345  double _r = 1.0 / _track->getOmega() ;
346  double _phi = _track->getPhi0() ;
347 
348  //-- cluster/TRGECL information
349  double _cluster_x = _cluster->getPositionX();
350  double _cluster_y = _cluster->getPositionY();
351  double _cluster_z = _cluster->getPositionZ();
352  double _R = sqrt(_cluster_x * _cluster_x + _cluster_y * _cluster_y);
353 //double _D = sqrt(_cluster_x * _cluster_x + _cluster_y * _cluster_y + _cluster_z * _cluster_z);
354 //double _re_scaled_p = _pt * _D / _R;
355 
356  //-- calculation
357  if (_R > abs(2 * _r)) {
358  ds[0] = 99999.;
359  } else {
360  double theta0 = _phi - asin(_R / (2 * _r));
361 
362  double ex_x0 = _R * cos(theta0), ex_y0 = _R * sin(theta0);
363  ds[0] = sqrt((ex_x0 - _cluster_x) * (ex_x0 - _cluster_x) + (ex_y0 - _cluster_y) * (ex_y0 - _cluster_y));
364  }
365  //z information
366  if (_match3D == 1) {
367  double _z0 = _track->getZ0();
368  double _slope = _track->getCotTheta();
369  double _ex_z = _z0 + _slope * 2 * _r * asin(_R / (2 * _r));
370  ds[1] = fabs(_cluster_z - _ex_z);
371 
372  }
373 
374 }
375 
376 void TRGGRLMatchModule::calculationphiangle(CDCTriggerTrack* _track, TRGECLCluster* _cluster, int& dphi_d,
377  std::vector<bool>& phimap, std::vector<bool>& phimap_i)
378 {
379 
380  //-- 2D track information
381  double _r = 1.0 / _track->getOmega() ;
382  double _phi = _track->getPhi0() ;
383 
384  //-- 2D phi angle calculation
385  double phi_p = acos(126.0 / (2 * fabs(_r))); // adjustment angle between 0 to 0.5*M_PI
386  int charge = 0;
387  if (_r > 0) {charge = 1;}
388  else if (_r < 0) {charge = -1;}
389  else {charge = 0;}
390 
391  double phi_CDC = 0.0;
392  if (charge == 1) {
393  phi_CDC = _phi + phi_p - 0.5 * M_PI;
394  } else if (charge == -1) {
395  phi_CDC = _phi - phi_p + 0.5 * M_PI;
396  } else {
397  phi_CDC = _phi;
398  }
399 
400  if (phi_CDC > 2 * M_PI) {phi_CDC = phi_CDC - 2 * M_PI;}
401  else if (phi_CDC < 0) {phi_CDC = phi_CDC + 2 * M_PI;}
402  if (_phi > 2 * M_PI) {_phi = _phi - 2 * M_PI;}
403  else if (_phi < 0) {_phi = _phi + 2 * M_PI;}
404 
405  //-- cluster/TRGECL information
406  double _cluster_x = _cluster->getPositionX();
407  double _cluster_y = _cluster->getPositionY();
408 
409  // -- ECL phi angle
410  double phi_ECL = 0.0;
411  if (_cluster_x >= 0 && _cluster_y >= 0) {phi_ECL = atan(_cluster_y / _cluster_x);}
412  else if (_cluster_x < 0 && _cluster_y >= 0) {phi_ECL = atan(_cluster_y / _cluster_x) + M_PI;}
413  else if (_cluster_x < 0 && _cluster_y < 0) {phi_ECL = atan(_cluster_y / _cluster_x) + M_PI;}
414  else if (_cluster_x >= 0 && _cluster_y < 0) {phi_ECL = atan(_cluster_y / _cluster_x) + 2 * M_PI;}
415 
416  int phi_ECL_d = 0, phi_CDC_d = 0, phi_i_d = 0;
417  // digitization on both angle
418  for (int i = 0; i < 36; i++) {
419  if (phi_ECL > i * M_PI / 18 && phi_ECL < (i + 1)*M_PI / 18) {phi_ECL_d = i;}
420  if (_phi > i * M_PI / 18 && _phi < (i + 1)*M_PI / 18) {phi_i_d = i;}
421  if (phi_CDC > i * M_PI / 18 && phi_CDC < (i + 1)*M_PI / 18) {phi_CDC_d = i;}
422  }
423 
424  phimap[phi_CDC_d] = true;
425  phimap_i[phi_i_d] = true;
426 
427  if (abs(phi_ECL_d - phi_CDC_d) == 0 || abs(phi_ECL_d - phi_CDC_d) == 36) {dphi_d = 0;}
428  else if (abs(phi_ECL_d - phi_CDC_d) == 1 || abs(phi_ECL_d - phi_CDC_d) == 35) {dphi_d = 1;}
429  else if (abs(phi_ECL_d - phi_CDC_d) == 2 || abs(phi_ECL_d - phi_CDC_d) == 34) {dphi_d = 2;}
430  else if (abs(phi_ECL_d - phi_CDC_d) == 3 || abs(phi_ECL_d - phi_CDC_d) == 33) {dphi_d = 3;}
431  else if (abs(phi_ECL_d - phi_CDC_d) == 4 || abs(phi_ECL_d - phi_CDC_d) == 32) {dphi_d = 4;}
432  else if (abs(phi_ECL_d - phi_CDC_d) == 5 || abs(phi_ECL_d - phi_CDC_d) == 31) {dphi_d = 5;}
433  else if (abs(phi_ECL_d - phi_CDC_d) == 6 || abs(phi_ECL_d - phi_CDC_d) == 30) {dphi_d = 6;}
434  else if (abs(phi_ECL_d - phi_CDC_d) == 7 || abs(phi_ECL_d - phi_CDC_d) == 29) {dphi_d = 7;}
435  else if (abs(phi_ECL_d - phi_CDC_d) == 8 || abs(phi_ECL_d - phi_CDC_d) == 28) {dphi_d = 8;}
436  else if (abs(phi_ECL_d - phi_CDC_d) == 9 || abs(phi_ECL_d - phi_CDC_d) == 27) {dphi_d = 9;}
437  else if (abs(phi_ECL_d - phi_CDC_d) == 10 || abs(phi_ECL_d - phi_CDC_d) == 26) {dphi_d = 10;}
438  else if (abs(phi_ECL_d - phi_CDC_d) == 11 || abs(phi_ECL_d - phi_CDC_d) == 25) {dphi_d = 11;}
439  else if (abs(phi_ECL_d - phi_CDC_d) == 12 || abs(phi_ECL_d - phi_CDC_d) == 24) {dphi_d = 12;}
440  else if (abs(phi_ECL_d - phi_CDC_d) == 13 || abs(phi_ECL_d - phi_CDC_d) == 23) {dphi_d = 13;}
441  else if (abs(phi_ECL_d - phi_CDC_d) == 14 || abs(phi_ECL_d - phi_CDC_d) == 22) {dphi_d = 14;}
442  else if (abs(phi_ECL_d - phi_CDC_d) == 15 || abs(phi_ECL_d - phi_CDC_d) == 21) {dphi_d = 15;}
443  else if (abs(phi_ECL_d - phi_CDC_d) == 16 || abs(phi_ECL_d - phi_CDC_d) == 20) {dphi_d = 16;}
444  else if (abs(phi_ECL_d - phi_CDC_d) == 17 || abs(phi_ECL_d - phi_CDC_d) == 19) {dphi_d = 17;}
445  else if (abs(phi_ECL_d - phi_CDC_d) == 18) {dphi_d = 18;}
446 
447 }
448 
449 void TRGGRLMatchModule::sectormatching_klm(CDCTriggerTrack* _track, StoreObjPtr<KLMTrgSummary> _klmtrgsummary, double& dphi,
450  int& phiid_klm)
451 {
452 
453  //-- 2D track information
454  double _r = 1.0 / _track->getOmega() ;
455  double _phi = _track->getPhi0() ;
456 
457  //-- 2D phi angle calculation (extrapolating up to superconducting coil)
458  double phi_p = acos(176.0 / (2 * fabs(_r))); // adjustment angle between 0 to 0.5*M_PI
459  int charge = 0;
460  if (_r > 0) {charge = 1;}
461  else if (_r < 0) {charge = -1;}
462  else {charge = 0;}
463 
464  double phi_CDC = 0.0;
465  if (charge == 1) {
466  phi_CDC = _phi + phi_p - 0.5 * M_PI;
467  } else if (charge == -1) {
468  phi_CDC = _phi - phi_p + 0.5 * M_PI;
469  } else {
470  phi_CDC = _phi;
471  }
472 
473  if (phi_CDC > 2 * M_PI) {phi_CDC = phi_CDC - 2 * M_PI;}
474  else if (phi_CDC < 0) {phi_CDC = phi_CDC + 2 * M_PI;}
475 
476  // KLM track's sector central phi
477  int _sector_mask_fw = _klmtrgsummary->getSector_mask_Forward_Barrel();
478  int _sector_mask_bw = _klmtrgsummary->getSector_mask_Backward_Barrel();
479  int _sector_mask = _sector_mask_fw | _sector_mask_bw;
480  for (int _sector = 0; _sector < 8; _sector++) {
481  if (_sector_mask & (1 << _sector)) {
482  double _sector_central = 0.25 * M_PI * _sector;
483  double dphi_temp;
484  if (fabs(phi_CDC - _sector_central) < M_PI) { dphi_temp = fabs(phi_CDC - _sector_central); }
485  else { dphi_temp = 2 * M_PI - fabs(phi_CDC - _sector_central); }
486  if (dphi_temp < dphi) {
487  dphi = dphi_temp;
488  phiid_klm = _sector;
489  }
490  }
491  }
492 
493 }
494 
495 bool TRGGRLMatchModule::photon_cluster(TRGECLCluster* _cluster, std::vector<bool> phimap, double e_threshold)
496 {
497 
498  //-- cluster/TRGECL information
499  double _cluster_x = _cluster->getPositionX();
500  double _cluster_y = _cluster->getPositionY();
501  double _cluster_z = _cluster->getPositionZ();
502  double _cluster_theta = atan(_cluster_z / (sqrt(_cluster_x * _cluster_x + _cluster_y * _cluster_y)));
503  _cluster_theta = 0.5 * M_PI - _cluster_theta;
504  bool barrel = true;
505  if (_cluster_theta < M_PI * 35.0 / 180.0 || _cluster_theta > M_PI * 126.0 / 180.0) {barrel = false;}
506  double _cluster_e = _cluster->getEnergyDep();
507 
508  // -- ECL phi angle
509  double phi_ECL = 0.0;
510  if (_cluster_x >= 0 && _cluster_y >= 0) {phi_ECL = atan(_cluster_y / _cluster_x);}
511  else if (_cluster_x < 0 && _cluster_y >= 0) {phi_ECL = atan(_cluster_y / _cluster_x) + M_PI;}
512  else if (_cluster_x < 0 && _cluster_y < 0) {phi_ECL = atan(_cluster_y / _cluster_x) + M_PI;}
513  else if (_cluster_x >= 0 && _cluster_y < 0) {phi_ECL = atan(_cluster_y / _cluster_x) + 2 * M_PI;}
514 
515  int phi_ECL_d = 0;
516  // digitization on both angle
517  for (int i = 0; i < 36; i++) {
518  if (phi_ECL > i * M_PI / 18 && phi_ECL < (i + 1)*M_PI / 18) {phi_ECL_d = i;}
519  }
520 
521  int index = phi_ECL_d, index_p = phi_ECL_d + 1, index_m = phi_ECL_d - 1;
522  if (index_p > 35) {index_p = index_p - 36;}
523  if (index_m < 0) {index_m = index_m + 36;}
524 
525  if (!phimap[index] && !phimap[index_p] && !phimap[index_m] && _cluster_e >= e_threshold && barrel) {return true;}
526  else if (!barrel) {return true;}
527  else {return false;}
528 
529 }
530 
531 int TRGGRLMatchModule::N64(int x)
532 {
533  if (x > 63) x -= 64;
534  if (x < 0) x += 64;
535  return x;
536 }
537 
538 int TRGGRLMatchModule::N36(int x)
539 {
540  if (x > 35) x -= 36;
541  if (x < 0) x += 36;
542  return x;
543 }
544 
545 void TRGGRLMatchModule::fill_pattern_base2(std::vector< std::vector<int> >& patt)
546 {
547  patt.push_back({ 0, 0, 0, 0});
548  patt.push_back({ 0, -1, 0, 0});
549  patt.push_back({ 0, -1, 1, 0});
550  patt.push_back({ 0, -1, -1, 0});
551  patt.push_back({ 0, -2, 0, 0});
552  patt.push_back({ 0, -2, 1, 0});
553  patt.push_back({ 0, -2, 2, 0});
554  patt.push_back({ 0, -2, 3, 0});
555  patt.push_back({ 0, -3, 1, 0});
556  patt.push_back({ 0, -3, 2, 0});
557  patt.push_back({ 0, -3, 3, 0});
558  patt.push_back({ 0, -4, 2, 0});
559  patt.push_back({ 0, -4, 3, 0});
560  patt.push_back({ 0, 0, 0, 1});
561  patt.push_back({ 0, 0, 1, 1});
562  patt.push_back({ 0, -1, 0, 1});
563  patt.push_back({ 0, -1, 1, 1});
564  patt.push_back({ 0, -1, 2, 1});
565  patt.push_back({ 0, -2, 2, 1});
566  patt.push_back({ 0, -2, 3, 1});
567  patt.push_back({ 0, -3, 2, 1});
568  patt.push_back({ 0, -3, 3, 1});
569  patt.push_back({ 0, 0, 0, -1});
570  patt.push_back({ 0, 0, -1, -1});
571  patt.push_back({ 0, -1, 0, -1});
572  patt.push_back({ 0, -1, -1, -1});
573  patt.push_back({ 0, -2, 0, -1});
574  patt.push_back({ 0, -2, 1, -1});
575  patt.push_back({ 0, -3, 1, -1});
576  patt.push_back({ 0, -3, 2, -1});
577  patt.push_back({ -1, -1, 0, 0});
578  patt.push_back({ -1, -1, 1, 0});
579  patt.push_back({ -1, -2, 0, 0});
580  patt.push_back({ -1, -2, 1, 0});
581  patt.push_back({ -1, -3, 1, 0});
582  patt.push_back({ -1, -3, 2, 0});
583  patt.push_back({ -1, -3, 3, 0});
584  patt.push_back({ -1, -4, 2, 0});
585  patt.push_back({ -1, -4, 3, 0});
586  patt.push_back({ 1, 0, 1, 0});
587  patt.push_back({ 1, 0, 0, 0});
588  patt.push_back({ 1, 0, -1, 0});
589  patt.push_back({ 1, -1, 0, 0});
590  patt.push_back({ 1, -1, 1, 0});
591  patt.push_back({ 1, -2, 2, 0});
592  patt.push_back({ 1, -2, 3, 0});
593  patt.push_back({ 1, -3, 2, 0});
594  patt.push_back({ 1, -3, 3, 0});
595  patt.push_back({ -1, -1, 0, 1});
596  patt.push_back({ -1, -1, 1, 1});
597  patt.push_back({ -1, -2, 0, 1});
598  patt.push_back({ -1, -2, 1, 1});
599  patt.push_back({ -1, -2, 2, 1});
600  patt.push_back({ -1, -3, 1, 1});
601  patt.push_back({ -1, -3, 2, 1});
602  patt.push_back({ -1, -3, 3, 1});
603  patt.push_back({ -1, -4, 2, 1});
604  patt.push_back({ -1, -4, 3, 1});
605  patt.push_back({ 1, 0, -1, -1});
606  patt.push_back({ 1, 0, 0, -1});
607  patt.push_back({ 1, -1, -1, -1});
608  patt.push_back({ 1, -1, 0, -1});
609  patt.push_back({ 1, -1, 1, -1});
610  patt.push_back({ 1, -2, 1, -1});
611  patt.push_back({ 1, -2, 2, -1});
612  patt.push_back({ 1, -3, 1, -1});
613  patt.push_back({ 1, -3, 2, -1});
614  patt.push_back({ -1, -1, 1, 2});
615  patt.push_back({ -1, -1, 2, 2});
616  patt.push_back({ -1, -2, 1, 2});
617  patt.push_back({ -1, -2, 2, 2});
618  patt.push_back({ -1, -2, 3, 2});
619  patt.push_back({ -1, -3, 2, 2});
620  patt.push_back({ -1, -3, 3, 2});
621  patt.push_back({ -1, -3, 4, 2});
622  patt.push_back({ 1, 0, -1, -2});
623  patt.push_back({ 1, 0, 0, -2});
624  patt.push_back({ 1, -1, 1, -2});
625  patt.push_back({ 1, -1, 0, -2});
626  patt.push_back({ 1, -1, -1, -2});
627  patt.push_back({ 1, -2, 0, -2});
628  patt.push_back({ 1, -2, 1, -2});
629  patt.push_back({ -2, -2, 0, 1});
630  patt.push_back({ -2, -2, 1, 1});
631  patt.push_back({ -2, -3, 1, 1});
632  patt.push_back({ -2, -3, 2, 1});
633  patt.push_back({ -2, -4, 2, 1});
634  patt.push_back({ -2, -4, 3, 1});
635  patt.push_back({ -2, -5, 3, 1});
636  patt.push_back({ 2, 1, 0, -1});
637  patt.push_back({ 2, 0, 1, -1});
638  patt.push_back({ 2, 0, 0, -1});
639  patt.push_back({ 2, 0, -1, -1});
640  patt.push_back({ 2, -1, 1, -1});
641  patt.push_back({ 2, -1, 0, -1});
642  patt.push_back({ 2, -2, 2, -1});
643  patt.push_back({ 2, -2, 1, -1});
644  patt.push_back({ -2, -2, 1, 2});
645  patt.push_back({ -2, -2, 2, 2});
646  patt.push_back({ -2, -3, 1, 2});
647  patt.push_back({ -2, -3, 2, 2});
648  patt.push_back({ -2, -3, 3, 2});
649  patt.push_back({ -2, -4, 2, 2});
650  patt.push_back({ -2, -4, 3, 2});
651  patt.push_back({ -2, -4, 4, 2});
652  patt.push_back({ 2, 1, 0, -2});
653  patt.push_back({ 2, 1, -1, -2});
654  patt.push_back({ 2, 0, 1, -2});
655  patt.push_back({ 2, 0, 0, -2});
656  patt.push_back({ 2, 0, -1, -2});
657  patt.push_back({ 2, 0, -2, -2});
658  patt.push_back({ 2, -1, 2, -2});
659  patt.push_back({ 2, -1, 1, -2});
660  patt.push_back({ 2, -1, 0, -2});
661  patt.push_back({ 2, -1, -1, -2});
662  patt.push_back({ 2, -2, 0, -2});
663  patt.push_back({ 2, -2, 1, -2});
664  patt.push_back({ -2, -2, 1, 3});
665  patt.push_back({ -2, -2, 2, 3});
666  patt.push_back({ -2, -3, 2, 3});
667  patt.push_back({ -2, -3, 3, 3});
668  patt.push_back({ -2, -3, 4, 3});
669  patt.push_back({ -2, -4, 3, 3});
670  patt.push_back({ -2, -4, 4, 3});
671  patt.push_back({ 2, 1, -1, -3});
672  patt.push_back({ 2, 0, -1, -3});
673  patt.push_back({ 2, 0, -2, -3});
674  patt.push_back({ 2, -1, 0, -3});
675  patt.push_back({ 2, -2, 0, -3});
676  patt.push_back({ 2, -2, 1, -3});
677  patt.push_back({ -2, -2, 2, 4});
678  patt.push_back({ -2, -3, 3, 4});
679  patt.push_back({ -2, -3, 4, 4});
680  patt.push_back({ -2, -4, 4, 4});
681  patt.push_back({ 2, -1, 0, 4});
682  patt.push_back({ 2, -1, -1, 4});
683  patt.push_back({ 2, -2, 0, 4});
684 
685 }
686 
687 void TRGGRLMatchModule::make_veto_map(StoreArray<CDCTriggerTrack> track2Dlist, std::vector<bool>& map_veto)
688 {
689  for (int i = 0; i < track2Dlist.getEntries(); i++) {
690  int _w = (int)(2271.7 * track2Dlist[i]->getOmega()) ; // omega from -33 to 33
691  if (_w >= 33) { _w = 33;}
692  else if (_w <= -33) { _w = -33;}
693  int _phi = (int)((track2Dlist[i]->getPhi0() + 2 * M_PI) / (M_PI / 32.0)); // phi_i digitized to 0 ~ 63
694 
695  int charge = 0;
696  if (_w > 0) {charge = 1;}
697  else if (_w < 0) {charge = -1;}
698  else {charge = 0;}
699 
700  _w = abs(_w);
701 
702  int L;
703  if (_w >= 0 && _w <= 8) { L = _phi; }
704  else if (_w >= 9 && _w <= 15) {
705  if (charge < 0) { L = _phi + 1; }
706  else { L = _phi; }
707  } else if (_w >= 16 && _w <= 24) {
708  if (charge < 0) { L = _phi + 2; }
709  else { L = _phi; }
710  } else if (_w >= 25 && _w <= 27) {
711  if (charge < 0) { L = _phi + 3; }
712  else { L = _phi; }
713  } else if (_w >= 28 && _w <= 30) {
714  if (charge < 0) { L = _phi + 3; }
715  else { L = _phi + 1; }
716  } else if (_w >= 31 && _w <= 32) {
717  if (charge < 0) { L = _phi + 4; }
718  else { L = _phi + 1; }
719  } else {
720  if (charge < 0) { L = _phi + 5; }
721  else { L = _phi + 1; }
722  }
723 
724  int R;
725  if (_w >= 0 && _w <= 8) { R = _phi; }
726  else if (_w >= 9 && _w <= 15) {
727  if (charge < 0) { R = _phi; }
728  else { R = _phi - 1; }
729  } else if (_w >= 16 && _w <= 24) {
730  if (charge < 0) { R = _phi; }
731  else { R = _phi - 2; }
732  } else if (_w >= 25 && _w <= 27) {
733  if (charge < 0) { R = _phi; }
734  else { R = _phi - 3; }
735  } else if (_w >= 28 && _w <= 30) {
736  if (charge < 0) { R = _phi + 1; }
737  else { R = _phi - 3; }
738  } else if (_w >= 21 && _w <= 32) {
739  if (charge < 0) { R = _phi + 1; }
740  else { R = _phi - 4; }
741  } else {
742  if (charge < 0) { R = _phi + 1; }
743  else { R = _phi - 5; }
744  }
745 
746  // L should be > R
747  for (int j = R - 1; j < L + 2; j++) {
748  map_veto[N64(j)] = true;
749  }
750  }
751 
752 }
753 
754 void TRGGRLMatchModule::make_eecl_map(StoreArray<TRGECLCluster> clusterlist,
755  std::vector<bool>& ecl_phimap, std::vector<bool>& ecl_phimap_fwd, std::vector<bool>& ecl_phimap_bwd,
756  std::vector<bool>& ecl_sectormap_fwd, std::vector<bool>& ecl_sectormap_bwd)
757 {
758  bool ecl_phimap_loose_fwd[36];
759  bool ecl_phimap_loose_bwd[36];
760  for (int i = 0; i < 36; i++) {
761  ecl_phimap_loose_fwd[i] = false;
762  ecl_phimap_loose_bwd[i] = false;
763  }
764 
765  for (int iclst = 0; iclst < clusterlist.getEntries(); iclst++) {
766  //-- cluster/TRGECL information
767  double _cluster_x = clusterlist[iclst]->getPositionX();
768  double _cluster_y = clusterlist[iclst]->getPositionY();
769 
770  // -- ECL phi angle
771  double phi_ECL = 0.0;
772  if (_cluster_x >= 0 && _cluster_y >= 0) {phi_ECL = atan(_cluster_y / _cluster_x);}
773  else if (_cluster_x < 0 && _cluster_y >= 0) {phi_ECL = atan(_cluster_y / _cluster_x) + M_PI;}
774  else if (_cluster_x < 0 && _cluster_y < 0) {phi_ECL = atan(_cluster_y / _cluster_x) + M_PI;}
775  else if (_cluster_x >= 0 && _cluster_y < 0) {phi_ECL = atan(_cluster_y / _cluster_x) + 2 * M_PI;}
776 
777  int phi_ECL_d = 0;
778  // digitization on both angle
779  for (int i = 0; i < 36; i++) {
780  if (phi_ECL > i * M_PI / 18 && phi_ECL < (i + 1)*M_PI / 18) {phi_ECL_d = i;}
781  }
782 
783  //fill endcap only
784  int _cluster_thetaid = clusterlist[iclst]->getMaxThetaId();
785  if (_cluster_thetaid < 4 || _cluster_thetaid > 15) ecl_phimap[phi_ECL_d] = true;
786  if (_cluster_thetaid < 4) ecl_phimap_fwd[phi_ECL_d] = true;
787  if (_cluster_thetaid > 15) ecl_phimap_bwd[phi_ECL_d] = true;
788  if (_cluster_thetaid < 5) ecl_phimap_loose_fwd[phi_ECL_d] = true;
789  if (_cluster_thetaid > 14) ecl_phimap_loose_bwd[phi_ECL_d] = true;
790  }
791 
792  //-- 36b into 4b
793  ecl_sectormap_fwd[0] = ecl_phimap_loose_fwd[35] or ecl_phimap_loose_fwd[0] or ecl_phimap_loose_fwd[1] or ecl_phimap_loose_fwd[2] or
794  ecl_phimap_loose_fwd[3] or ecl_phimap_loose_fwd[4] or ecl_phimap_loose_fwd[5] or ecl_phimap_loose_fwd[6] or
795  ecl_phimap_loose_fwd[7] or ecl_phimap_loose_fwd[8] or ecl_phimap_loose_fwd[9];
796  ecl_sectormap_fwd[1] = ecl_phimap_loose_fwd[8] or ecl_phimap_loose_fwd[9] or ecl_phimap_loose_fwd[10] or ecl_phimap_loose_fwd[11]
797  or
798  ecl_phimap_loose_fwd[12] or ecl_phimap_loose_fwd[13] or ecl_phimap_loose_fwd[14] or ecl_phimap_loose_fwd[15] or
799  ecl_phimap_loose_fwd[16] or ecl_phimap_loose_fwd[17] or ecl_phimap_loose_fwd[18] or ecl_phimap_loose_fwd[19];
800  ecl_sectormap_fwd[2] = ecl_phimap_loose_fwd[18] or ecl_phimap_loose_fwd[19] or ecl_phimap_loose_fwd[20]
801  or ecl_phimap_loose_fwd[21] or
802  ecl_phimap_loose_fwd[22] or ecl_phimap_loose_fwd[23] or ecl_phimap_loose_fwd[24] or ecl_phimap_loose_fwd[25] or
803  ecl_phimap_loose_fwd[26] or ecl_phimap_loose_fwd[27] or ecl_phimap_loose_fwd[28];
804  ecl_sectormap_fwd[3] = ecl_phimap_loose_fwd[26] or ecl_phimap_loose_fwd[27] or ecl_phimap_loose_fwd[28]
805  or ecl_phimap_loose_fwd[29] or
806  ecl_phimap_loose_fwd[30] or ecl_phimap_loose_fwd[31] or ecl_phimap_loose_fwd[32] or ecl_phimap_loose_fwd[33] or
807  ecl_phimap_loose_fwd[34] or ecl_phimap_loose_fwd[35] or ecl_phimap_loose_fwd[0];
808  //-- 36b into 4b
809  ecl_sectormap_bwd[0] = ecl_phimap_loose_bwd[35] or ecl_phimap_loose_bwd[0] or ecl_phimap_loose_bwd[1] or ecl_phimap_loose_bwd[2] or
810  ecl_phimap_loose_bwd[3] or ecl_phimap_loose_bwd[4] or ecl_phimap_loose_bwd[5] or ecl_phimap_loose_bwd[6] or
811  ecl_phimap_loose_bwd[7] or ecl_phimap_loose_bwd[8] or ecl_phimap_loose_bwd[9];
812  ecl_sectormap_bwd[1] = ecl_phimap_loose_bwd[8] or ecl_phimap_loose_bwd[9] or ecl_phimap_loose_bwd[10] or ecl_phimap_loose_bwd[11]
813  or
814  ecl_phimap_loose_bwd[12] or ecl_phimap_loose_bwd[13] or ecl_phimap_loose_bwd[14] or ecl_phimap_loose_bwd[15] or
815  ecl_phimap_loose_bwd[16] or ecl_phimap_loose_bwd[17] or ecl_phimap_loose_bwd[18] or ecl_phimap_loose_bwd[19];
816  ecl_sectormap_bwd[2] = ecl_phimap_loose_bwd[18] or ecl_phimap_loose_bwd[19] or ecl_phimap_loose_bwd[20]
817  or ecl_phimap_loose_bwd[21] or
818  ecl_phimap_loose_bwd[22] or ecl_phimap_loose_bwd[23] or ecl_phimap_loose_bwd[24] or ecl_phimap_loose_bwd[25] or
819  ecl_phimap_loose_bwd[26] or ecl_phimap_loose_bwd[27] or ecl_phimap_loose_bwd[28];
820  ecl_sectormap_bwd[3] = ecl_phimap_loose_bwd[26] or ecl_phimap_loose_bwd[27] or ecl_phimap_loose_bwd[28]
821  or ecl_phimap_loose_bwd[29] or
822  ecl_phimap_loose_bwd[30] or ecl_phimap_loose_bwd[31] or ecl_phimap_loose_bwd[32] or ecl_phimap_loose_bwd[33] or
823  ecl_phimap_loose_bwd[34] or ecl_phimap_loose_bwd[35] or ecl_phimap_loose_bwd[0];
824 
825 }
826 
827 void TRGGRLMatchModule::make_eklm_map(StoreObjPtr<KLMTrgSummary> _klmtrgsummary,
828  std::vector<bool>& _eklm_sectormap, std::vector<bool>& _eklm_sectormap_fwd, std::vector<bool>& _eklm_sectormap_bwd)
829 {
830 
831  int _sector_mask_fw = _klmtrgsummary->getSector_mask_Forward_Endcap();
832  int _sector_mask_bw = _klmtrgsummary->getSector_mask_Backward_Endcap();
833 
834  for (int _sector = 0; _sector < 4; _sector++) {
835  //if(_sector_mask_fw & (1<<_sector) ) _eklm_sectormap_fwd[_sector]=true;
836  if (_sector_mask_bw & (1 << _sector)) _eklm_sectormap_bwd[_sector] = true;
837  //if(_sector_mask & (1<<_sector) ) _eklm_sectormap[_sector]=true;
838  }
839  if (_sector_mask_fw & (1 << 0)) _eklm_sectormap_fwd[1] = true;
840  if (_sector_mask_fw & (1 << 1)) _eklm_sectormap_fwd[0] = true;
841  if (_sector_mask_fw & (1 << 2)) _eklm_sectormap_fwd[3] = true;
842  if (_sector_mask_fw & (1 << 3)) _eklm_sectormap_fwd[2] = true;
843 
844  for (int _sector = 0; _sector < 4; _sector++) {
845  _eklm_sectormap[_sector] = (_eklm_sectormap_fwd[_sector] || _eklm_sectormap_bwd[_sector]);
846  }
847 }
848 
849 
850 void TRGGRLMatchModule::short_tracking(StoreArray<CDCTriggerSegmentHit> tslist, std::vector<bool> map_veto,
851  std::vector<bool> phimap_i,
852  std::vector<bool> ecl_phimap_fwd,
853  std::vector<bool> ecl_phimap_bwd,
854  std::vector<bool> klm_sectormap_fwd,
855  std::vector<bool> klm_sectormap_bwd,
856  std::vector< std::vector<int> >& pattern_base0, std::vector< std::vector<int> >& pattern_base2,
857  StoreArray<TRGGRLShortTrack> grlst,
858  StoreObjPtr<TRGGRLInfo> trgInfo)
859 {
860  std::vector<bool> SL0(64, 0);
861  std::vector<bool> SL1(64, 0);
862  std::vector<bool> SL2(64, 0);
863  std::vector<bool> SL3(64, 0);
864  std::vector<bool> SL4(64, 0);
865  std::vector<bool> ST0(64, 0);
866  std::vector<bool> ST0_36b(36, 0);
867  std::vector<bool> ST2(64, 0);
868  std::vector<int> patt_ID(64, -1);
869 
870  std::vector<bool> st_ec1(64, 0);
871  std::vector<bool> st_ec1_36b(36, 0);
872  std::vector<bool> st_ec1_4b(4, 0);
873  std::vector<bool> st_ec2(64, 0);
874  std::vector<bool> st_ec2_36b(36, 0);
875  std::vector<bool> st_ec2_4b(4, 0);
876 
877 //-- collecting TSF info in SL0~4
878  for (int i = 0; i < tslist.getEntries(); i++) {
879  int id = tslist[i]->getSegmentID();
880  int sl = 0;
881  if (id >= 0 * 32 && id < 5 * 32) {sl = 0; id -= 0;}
882  else if (id >= 5 * 32 && id < 10 * 32) {sl = 1; id -= 5 * 32;}
883  else if (id >= 10 * 32 && id < 16 * 32) {sl = 2; id -= 10 * 32;}
884  else if (id >= 16 * 32 && id < 23 * 32) {sl = 3; id -= 16 * 32;}
885  else if (id >= 23 * 32 && id < 31 * 32) {sl = 4; id -= 23 * 32;}
886  else continue;
887 
888  if (sl == 0) {
889  int X = (int)(id / 5), Y = id % 5;
890  if (Y == 0 || Y == 1) { SL0[2 * X] = true; }
891  else if (Y == 3 || Y == 4) { SL0[2 * X + 1] = true; }
892  else { SL0[2 * X] = true; SL0[2 * X + 1] = true; }
893  } else if (sl == 1) {
894  int X = (int)(id / 5), Y = id % 5;
895  if (Y == 0 || Y == 1) { SL1[2 * X] = true; }
896  else if (Y == 3 || Y == 4) { SL1[2 * X + 1] = true; }
897  else { SL1[2 * X] = true; SL1[2 * X + 1] = true; }
898  } else if (sl == 2) {
899  int X = (int)(id / 3);
900  SL2[X] = true;
901  } else if (sl == 3) {
902  int X = (int)(id / 7), Y = id % 7;
903  if (Y == 0 || Y == 1 || Y == 2) { SL3[2 * X] = true; }
904  else if (Y == 4 || Y == 5 || Y == 6) { SL3[2 * X + 1] = true; }
905  else { SL3[2 * X] = true; SL3[2 * X + 1] = true; }
906  } else if (sl == 4) {
907  int X = (int)(id / 4);
908  SL4[X] = true;
909  }
910 
911  }
912 
913 //-- making veto
914  for (int i = 0; i < 64; i++) {
915  if (map_veto[i]) {SL0[i] = false; SL1[i] = false; SL2[i] = false;}
916  }
917  /*
918  for (int i = 0; i < 64; i++) { std::cout<<map_veto[63-i]; if((64-i)%10==1) std::cout<<" ";}
919  std::cout<<std::endl;
920  for (int i = 0; i < 64; i++) { std::cout<<SL4[63-i]; if((64-i)%10==1) std::cout<<" ";}
921  std::cout<<std::endl;
922  for (int i = 0; i < 64; i++) { std::cout<<SL3[63-i]; if((64-i)%10==1) std::cout<<" ";}
923  std::cout<<std::endl;
924  for (int i = 0; i < 64; i++) { std::cout<<SL2[63-i]; if((64-i)%10==1) std::cout<<" ";}
925  std::cout<<std::endl;
926  for (int i = 0; i < 64; i++) { std::cout<<SL1[63-i]; if((64-i)%10==1) std::cout<<" ";}
927  std::cout<<std::endl;
928  for (int i = 0; i < 64; i++) { std::cout<<SL0[63-i]; if((64-i)%10==1) std::cout<<" ";}
929  std::cout<<std::endl;
930  */
931 //-- doing short tracking
932 
933  std::vector< std::vector<int> > stlist_buf(0);
934 
935  // -- ST finding with SL2
936  for (int i = 0; i < 64; i++) {
937 
938  int ID0 = 0;
939  int ID1 = 0;
940  int ID2 = 0;
941  int ID3 = 0;
942  int ID4 = 0;
943  stlist_buf.push_back({0, 0, 0, 0, 0, 0});
944 
945  if (!SL2[i]) continue;
946  bool SL2_already_found = false;
947 
948  for (int p = 0; p < 137; p++) {
949 
950  // following patterns will not be used.
951  if (p == 4) continue;
952  if (p == 5) continue;
953  if (p == 17) continue;
954  if (p == 26) continue;
955  if (p == 38) continue;
956  if (p == 41) continue;
957  if (p == 42) continue;
958  if (p == 47) continue;
959  if (p == 50) continue;
960  if (p == 60) continue;
961  if (p == 63) continue;
962  if (p == 64) continue;
963  if (p == 74) continue;
964  if (p == 93) continue;
965  if (p == 94) continue;
966  if (p == 95) continue;
967  if (p == 96) continue;
968  if (p == 104) continue;
969  if (p == 113) continue;
970  if (p == 114) continue;
971  if (p == 115) continue;
972  if (p == 123) continue;
973  if (p == 134) continue;
974  if (p == 135) continue;
975  if (p == 136) continue;
976 
977  int x0 = pattern_base2[p][0];
978  int x1 = pattern_base2[p][1];
979  int x3 = pattern_base2[p][2];
980  int x4 = pattern_base2[p][3];
981 
982 
983  if (SL2[i] && SL0[N64(i + x0)] && SL1[N64(i + x1)] && SL3[N64(i + x3)] && SL4[N64(i + x4)] && !SL2_already_found) {
984  ST2[i] = true;
985  ID0 = N64(i + x0);
986  ID1 = N64(i + x1);
987  ID2 = i;
988  ID3 = N64(i + x3);
989  ID4 = N64(i + x4);
990  SL2_already_found = true; // if it has been found in previous pattern, no need to do it again.
991  }
992 
993  // if a pattern is found, no need to look for other pattern
994  if (SL2_already_found) break;
995 
996  }
997 
998  if (SL2_already_found) {
999  stlist_buf[i][0] = 1;
1000  stlist_buf[i][1] = ID0;
1001  stlist_buf[i][2] = ID1;
1002  stlist_buf[i][3] = ID2;
1003  stlist_buf[i][4] = ID3;
1004  stlist_buf[i][5] = ID4;
1005  }
1006  }
1008 //-- ST finding with SL0
1009  for (int i = 0; i < 64; i++) {
1010 
1011  if (!SL0[i]) continue;
1012  bool SL0_already_found = false;
1013 
1014  for (int p = 0; p < 137; p++) {
1015 
1016  // following patterns will not be used.
1017  if (p == 4) continue;
1018  if (p == 5) continue;
1019  if (p == 17) continue;
1020  if (p == 26) continue;
1021  if (p == 38) continue;
1022  if (p == 41) continue;
1023  if (p == 42) continue;
1024  if (p == 47) continue;
1025  if (p == 50) continue;
1026  if (p == 60) continue;
1027  if (p == 63) continue;
1028  if (p == 64) continue;
1029  if (p == 74) continue;
1030  if (p == 93) continue;
1031  if (p == 94) continue;
1032  if (p == 95) continue;
1033  if (p == 96) continue;
1034  if (p == 104) continue;
1035  if (p == 113) continue;
1036  if (p == 114) continue;
1037  if (p == 115) continue;
1038  if (p == 123) continue;
1039  if (p == 134) continue;
1040  if (p == 135) continue;
1041  if (p == 136) continue;
1042 
1043  int y1 = pattern_base0[p][0];
1044  int y2 = pattern_base0[p][1];
1045  int y3 = pattern_base0[p][2];
1046  int y4 = pattern_base0[p][3];
1047 
1048  if (SL0[i] && SL1[N64(i + y1)] && SL2[N64(i + y2)] && SL3[N64(i + y3)] && SL4[N64(i + y4)] && !SL0_already_found) {
1049  ST0[i] = true;
1050  if (patt_ID[i] < 0) { patt_ID[i] = p; }
1051  SL0_already_found = true; // if it has been found in previous pattern, no need to do it again.
1052  }
1053 
1054  // if a pattern is found, no need to look for other pattern
1055  if (SL0_already_found) break;
1056 
1057  }
1058 
1059  }
1061 //-- extrapolation
1062  for (int i = 0; i < 64; i++) {
1063  if (patt_ID[i] == -1) continue;
1064 
1065  int ec = 0, l = 0, r = 0;
1066  extrapolation(patt_ID[i], l, r, ec);
1067  if (ec == 1) {
1068  for (int e = l; e <= r; e++) { st_ec1[N64(i + e)] = true; }
1069  }
1070  if (ec == 2) {
1071  for (int e = l; e <= r; e++) { st_ec2[N64(i + e)] = true; }
1072  }
1073 
1074  }
1075 //-- 64b into 36b
1076  for (int i = 0; i < 4; i++) {
1077  ST0_36b[0 + 9 * i] = ST0[0 + 16 * i] or ST0[1 + 16 * i];
1078  ST0_36b[1 + 9 * i] = ST0[1 + 16 * i] or ST0[2 + 16 * i] or ST0[3 + 16 * i];
1079  ST0_36b[2 + 9 * i] = ST0[3 + 16 * i] or ST0[4 + 16 * i] or ST0[5 + 16 * i];
1080  ST0_36b[3 + 9 * i] = ST0[5 + 16 * i] or ST0[6 + 16 * i] or ST0[7 + 16 * i];
1081  ST0_36b[4 + 9 * i] = ST0[7 + 16 * i] or ST0[8 + 16 * i];
1082  ST0_36b[5 + 9 * i] = ST0[8 + 16 * i] or ST0[9 + 16 * i] or ST0[10 + 16 * i];
1083  ST0_36b[6 + 9 * i] = ST0[10 + 16 * i] or ST0[11 + 16 * i] or ST0[12 + 16 * i];
1084  ST0_36b[7 + 9 * i] = ST0[12 + 16 * i] or ST0[13 + 16 * i] or ST0[14 + 16 * i];
1085  ST0_36b[8 + 9 * i] = ST0[14 + 16 * i] or ST0[15 + 16 * i];
1086  st_ec1_36b[0 + 9 * i] = st_ec1[0 + 16 * i] or st_ec1[1 + 16 * i];
1087  st_ec1_36b[1 + 9 * i] = st_ec1[1 + 16 * i] or st_ec1[2 + 16 * i] or st_ec1[3 + 16 * i];
1088  st_ec1_36b[2 + 9 * i] = st_ec1[3 + 16 * i] or st_ec1[4 + 16 * i] or st_ec1[5 + 16 * i];
1089  st_ec1_36b[3 + 9 * i] = st_ec1[5 + 16 * i] or st_ec1[6 + 16 * i] or st_ec1[7 + 16 * i];
1090  st_ec1_36b[4 + 9 * i] = st_ec1[7 + 16 * i] or st_ec1[8 + 16 * i];
1091  st_ec1_36b[5 + 9 * i] = st_ec1[8 + 16 * i] or st_ec1[9 + 16 * i] or st_ec1[10 + 16 * i];
1092  st_ec1_36b[6 + 9 * i] = st_ec1[10 + 16 * i] or st_ec1[11 + 16 * i] or st_ec1[12 + 16 * i];
1093  st_ec1_36b[7 + 9 * i] = st_ec1[12 + 16 * i] or st_ec1[13 + 16 * i] or st_ec1[14 + 16 * i];
1094  st_ec1_36b[8 + 9 * i] = st_ec1[14 + 16 * i] or st_ec1[15 + 16 * i];
1095 
1096  st_ec2_36b[0 + 9 * i] = st_ec2[0 + 16 * i] or st_ec2[1 + 16 * i];
1097  st_ec2_36b[1 + 9 * i] = st_ec2[1 + 16 * i] or st_ec2[2 + 16 * i] or st_ec2[3 + 16 * i];
1098  st_ec2_36b[2 + 9 * i] = st_ec2[3 + 16 * i] or st_ec2[4 + 16 * i] or st_ec2[5 + 16 * i];
1099  st_ec2_36b[3 + 9 * i] = st_ec2[5 + 16 * i] or st_ec2[6 + 16 * i] or st_ec2[7 + 16 * i];
1100  st_ec2_36b[4 + 9 * i] = st_ec2[7 + 16 * i] or st_ec2[8 + 16 * i];
1101  st_ec2_36b[5 + 9 * i] = st_ec2[8 + 16 * i] or st_ec2[9 + 16 * i] or st_ec2[10 + 16 * i];
1102  st_ec2_36b[6 + 9 * i] = st_ec2[10 + 16 * i] or st_ec2[11 + 16 * i] or st_ec2[12 + 16 * i];
1103  st_ec2_36b[7 + 9 * i] = st_ec2[12 + 16 * i] or st_ec2[13 + 16 * i] or st_ec2[14 + 16 * i];
1104  st_ec2_36b[8 + 9 * i] = st_ec2[14 + 16 * i] or st_ec2[15 + 16 * i];
1105  }
1106 //-- 36b into 4b
1107  st_ec1_4b[0] = st_ec1_36b[35] or st_ec1_36b[0] or st_ec1_36b[1] or st_ec1_36b[2] or st_ec1_36b[3] or st_ec1_36b[4] or st_ec1_36b[5]
1108  or st_ec1_36b[6] or st_ec1_36b[7] or st_ec1_36b[8] or st_ec1_36b[9];
1109  st_ec1_4b[1] = st_ec1_36b[8] or st_ec1_36b[9] or st_ec1_36b[10] or st_ec1_36b[11] or st_ec1_36b[12] or st_ec1_36b[13]
1110  or st_ec1_36b[14] or st_ec1_36b[15] or st_ec1_36b[16] or st_ec1_36b[17] or st_ec1_36b[18] or st_ec1_36b[19];
1111  st_ec1_4b[2] = st_ec1_36b[18] or st_ec1_36b[19] or st_ec1_36b[20] or st_ec1_36b[21] or st_ec1_36b[22] or st_ec1_36b[23]
1112  or st_ec1_36b[24] or st_ec1_36b[25] or st_ec1_36b[26] or st_ec1_36b[27] or st_ec1_36b[28];
1113  st_ec1_4b[3] = st_ec1_36b[26] or st_ec1_36b[27] or st_ec1_36b[28] or st_ec1_36b[29] or st_ec1_36b[30] or st_ec1_36b[31]
1114  or st_ec1_36b[32] or st_ec1_36b[33] or st_ec1_36b[34] or st_ec1_36b[35] or st_ec1_36b[0];
1115  st_ec2_4b[0] = st_ec2_36b[35] or st_ec2_36b[0] or st_ec2_36b[1] or st_ec2_36b[2] or st_ec2_36b[3] or st_ec2_36b[4] or st_ec2_36b[5]
1116  or st_ec2_36b[6] or st_ec2_36b[7] or st_ec2_36b[8] or st_ec2_36b[9];
1117  st_ec2_4b[1] = st_ec2_36b[8] or st_ec2_36b[9] or st_ec2_36b[10] or st_ec2_36b[11] or st_ec2_36b[12] or st_ec2_36b[13]
1118  or st_ec2_36b[14] or st_ec2_36b[15] or st_ec2_36b[16] or st_ec2_36b[17] or st_ec2_36b[18] or st_ec2_36b[19];
1119  st_ec2_4b[2] = st_ec2_36b[18] or st_ec2_36b[19] or st_ec2_36b[20] or st_ec2_36b[21] or st_ec2_36b[22] or st_ec2_36b[23]
1120  or st_ec2_36b[24] or st_ec2_36b[25] or st_ec2_36b[26] or st_ec2_36b[27] or st_ec2_36b[28];
1121  st_ec2_4b[3] = st_ec2_36b[26] or st_ec2_36b[27] or st_ec2_36b[28] or st_ec2_36b[29] or st_ec2_36b[30] or st_ec2_36b[31]
1122  or st_ec2_36b[32] or st_ec2_36b[33] or st_ec2_36b[34] or st_ec2_36b[35] or st_ec2_36b[0];
1123 
1124 
1125 
1126 
1127 //-- Summary info
1128 
1129  int N_ST = 0;
1130  int N_ST_fwd = 0;
1131  int N_ST_bwd = 0;
1132  bool s2s3 = false;
1133  bool s2s5 = false;
1134  bool s2so = false;
1135  bool s2s30 = false;
1136  bool s2f3 = false;
1137  bool s2f5 = false;
1138  bool s2fo = false;
1139  bool s2f30 = false;
1140  int secl = 0;
1141  int secl_fwd = 0;
1142  int secl_bwd = 0;
1143  int sklm = 0;
1144  int sklm_fwd = 0;
1145  int sklm_bwd = 0;
1146 
1147 //-- short track counting on ST2
1148  for (int i = 0; i < 64; i++) {
1149  if (ST2[i]) {
1150  N_ST++;
1151  ST2[i] = false;
1152  int L = i - 1, R = i + 1;
1153  while (ST2[N64(L)]) {
1154  ST2[N64(L)] = false;
1155  L--;
1156  }
1157  while (ST2[N64(R)]) {
1158  ST2[N64(R)] = false;
1159  R++;
1160  }
1161 
1162  //-- Fill the store array
1163  L++; R--;
1164  int index = N64((L + R) / 2); // fill the middle one when multiple ST is found continuously in the map
1165  TRGGRLShortTrack* st = grlst.appendNew();
1166  st->set_TS_ID(0, stlist_buf[index][1]);
1167  st->set_TS_ID(1, stlist_buf[index][2]);
1168  st->set_TS_ID(2, stlist_buf[index][3]);
1169  st->set_TS_ID(3, stlist_buf[index][4]);
1170  st->set_TS_ID(4, stlist_buf[index][5]);
1171  }
1172  }
1173  for (int i = 0; i < 64; i++) {
1174  if (st_ec1[i]) N_ST_fwd++;
1175  }
1176  for (int i = 0; i < 64; i++) {
1177  if (st_ec2[i]) N_ST_bwd++;
1178  }
1179 
1180 //-- b2b info with ST0 and phi_i map
1181  for (int i = 0; i < 36; i++) {
1182  s2s3 = (ST0_36b[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)])) or s2s3;
1183  s2s5 = (ST0_36b[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)]
1184  or ST0_36b[N36(i + 16)] or ST0_36b[N36(i + 20)])) or s2s5;
1185  s2so = (ST0_36b[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)]
1186  or ST0_36b[N36(i + 16)] or ST0_36b[N36(i + 20)]
1187  or ST0_36b[N36(i + 15)] or ST0_36b[N36(i + 21)]
1188  or ST0_36b[N36(i + 14)] or ST0_36b[N36(i + 22)]
1189  or ST0_36b[N36(i + 13)] or ST0_36b[N36(i + 23)]
1190  or ST0_36b[N36(i + 12)] or ST0_36b[N36(i + 24)]
1191  or ST0_36b[N36(i + 11)] or ST0_36b[N36(i + 25)]
1192  or ST0_36b[N36(i + 10)] or ST0_36b[N36(i + 26)]
1193  or ST0_36b[N36(i + 9)] or ST0_36b[N36(i + 27)])) or s2so ;
1194  s2s30 = (ST0_36b[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)]
1195  or ST0_36b[N36(i + 16)] or ST0_36b[N36(i + 20)]
1196  or ST0_36b[N36(i + 15)] or ST0_36b[N36(i + 21)]
1197  or ST0_36b[N36(i + 14)] or ST0_36b[N36(i + 22)]
1198  or ST0_36b[N36(i + 13)] or ST0_36b[N36(i + 23)]
1199  or ST0_36b[N36(i + 12)] or ST0_36b[N36(i + 24)]
1200  or ST0_36b[N36(i + 11)] or ST0_36b[N36(i + 25)]
1201  or ST0_36b[N36(i + 10)] or ST0_36b[N36(i + 26)]
1202  or ST0_36b[N36(i + 9)] or ST0_36b[N36(i + 27)]
1203  or ST0_36b[N36(i + 8)] or ST0_36b[N36(i + 28)]
1204  or ST0_36b[N36(i + 7)] or ST0_36b[N36(i + 29)]
1205  or ST0_36b[N36(i + 6)] or ST0_36b[N36(i + 30)]
1206  or ST0_36b[N36(i + 5)] or ST0_36b[N36(i + 31)]
1207  or ST0_36b[N36(i + 4)] or ST0_36b[N36(i + 32)]
1208  or ST0_36b[N36(i + 3)] or ST0_36b[N36(i + 33)])) or s2s30 ;
1209 
1210 
1211  s2f3 = (phimap_i[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)])) or s2f3;
1212  s2f5 = (phimap_i[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)]
1213  or ST0_36b[N36(i + 16)] or ST0_36b[N36(i + 20)])) or s2f5;
1214  s2fo = (phimap_i[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)]
1215  or ST0_36b[N36(i + 16)] or ST0_36b[N36(i + 20)]
1216  or ST0_36b[N36(i + 15)] or ST0_36b[N36(i + 21)]
1217  or ST0_36b[N36(i + 14)] or ST0_36b[N36(i + 22)]
1218  or ST0_36b[N36(i + 13)] or ST0_36b[N36(i + 23)]
1219  or ST0_36b[N36(i + 12)] or ST0_36b[N36(i + 24)]
1220  or ST0_36b[N36(i + 11)] or ST0_36b[N36(i + 25)]
1221  or ST0_36b[N36(i + 10)] or ST0_36b[N36(i + 26)]
1222  or ST0_36b[N36(i + 9)] or ST0_36b[N36(i + 27)])) or s2fo ;
1223  s2f30 = (phimap_i[i] and (ST0_36b[N36(i + 18)] or ST0_36b[N36(i + 17)] or ST0_36b[N36(i + 19)]
1224  or ST0_36b[N36(i + 16)] or ST0_36b[N36(i + 20)]
1225  or ST0_36b[N36(i + 15)] or ST0_36b[N36(i + 21)]
1226  or ST0_36b[N36(i + 14)] or ST0_36b[N36(i + 22)]
1227  or ST0_36b[N36(i + 13)] or ST0_36b[N36(i + 23)]
1228  or ST0_36b[N36(i + 12)] or ST0_36b[N36(i + 24)]
1229  or ST0_36b[N36(i + 11)] or ST0_36b[N36(i + 25)]
1230  or ST0_36b[N36(i + 10)] or ST0_36b[N36(i + 26)]
1231  or ST0_36b[N36(i + 9)] or ST0_36b[N36(i + 27)]
1232  or ST0_36b[N36(i + 8)] or ST0_36b[N36(i + 28)]
1233  or ST0_36b[N36(i + 7)] or ST0_36b[N36(i + 29)]
1234  or ST0_36b[N36(i + 6)] or ST0_36b[N36(i + 30)]
1235  or ST0_36b[N36(i + 5)] or ST0_36b[N36(i + 31)]
1236  or ST0_36b[N36(i + 4)] or ST0_36b[N36(i + 32)]
1237  or ST0_36b[N36(i + 3)] or ST0_36b[N36(i + 33)])) or s2f30 ;
1238 
1239  }
1240 
1241 //short-ecl matching at endcap
1242  for (int i = 0; i < 36; i++) {
1243  if (ecl_phimap_fwd[i] and st_ec1_36b[i])secl_fwd++;
1244  }
1245  for (int i = 0; i < 36; i++) {
1246  if (ecl_phimap_bwd[i] and st_ec2_36b[i])secl_bwd++;
1247  }
1248  secl = secl_fwd + secl_bwd;
1249 
1250 //short-klm matching at endcap
1251  for (int i = 0; i < 4; i++) {
1252  if (klm_sectormap_fwd[i] and st_ec1_4b[i])sklm_fwd++;
1253  }
1254  for (int i = 0; i < 4; i++) {
1255  if (klm_sectormap_bwd[i] and st_ec2_4b[i])sklm_bwd++;
1256  }
1257  sklm = sklm_fwd + sklm_bwd;
1258 
1259 //-- set results
1260  trgInfo->setNshorttrk(N_ST);
1261  trgInfo->setNshorttrk_fwd(N_ST_fwd);
1262  trgInfo->setNshorttrk_bwd(N_ST_bwd);
1263  trgInfo->sets2s3(s2s3);
1264  trgInfo->sets2s5(s2s5);
1265  trgInfo->sets2so(s2so);
1266  trgInfo->sets2s30(s2s30);
1267  trgInfo->sets2f3(s2f3);
1268  trgInfo->sets2f5(s2f5);
1269  trgInfo->sets2fo(s2fo);
1270  trgInfo->sets2f30(s2f30);
1271  trgInfo->setbwdsb(0);
1272  trgInfo->setbwdnb(0);
1273  trgInfo->setfwdsb(0);
1274  trgInfo->setfwdnb(0);
1275  trgInfo->setbrlfb(0);
1276  trgInfo->setbrlnb(0);
1277  trgInfo->setNsecl(secl);
1278  trgInfo->setNsecl_fwd(secl_fwd);
1279  trgInfo->setNsecl_bwd(secl_bwd);
1280  trgInfo->setNsklm(sklm);
1281  trgInfo->setNsklm_fwd(sklm_fwd);
1282  trgInfo->setNsklm_bwd(sklm_bwd);
1283 
1284  //for (int i = 0; i < 64; i++) {
1285  // std::cout << st_ec1[i] << " ";
1286  //}
1287  //std::cout << std::endl;
1288  //for (int i = 0; i < 64; i++) {
1289  // std::cout << st_ec2[i] << " ";
1290  //}
1291  //std::cout << std::endl;
1292  //for (int i = 0; i < 36; i++) {
1293  // std::cout << st_ec1_36b[i] << " ";
1294  //}
1295  //std::cout << std::endl;
1296  //for (int i = 0; i < 36; i++) {
1297  // std::cout << st_ec2_36b[i] << " ";
1298  //}
1299  //std::cout << std::endl;
1300  //for (int i = 0; i < 36; i++) {
1301  // std::cout << ecl_phimap_fwd[i] << " ";
1302  //}
1303  //std::cout << std::endl;
1304  //for (int i = 0; i < 36; i++) {
1305  // std::cout << ecl_phimap_bwd[i] << " ";
1306  //}
1307  //std::cout << std::endl;
1308  //std::cout << secl << " " << secl_fwd << " " << secl_bwd << std::endl;
1309 
1310 }
1311 
1312 
1313 void TRGGRLMatchModule::inner_tracking(StoreArray<CDCTriggerSegmentHit> tslist,
1314  std::vector<bool> phimap_i,
1315  std::vector<bool> ecl_phimap,
1316  std::vector<bool> klm_sectormap,
1317  StoreArray<TRGGRLInnerTrack> grlit,
1318  StoreObjPtr<TRGGRLInfo> trgInfo)
1319 {
1320  std::vector<bool> SL0(64, 0);
1321  std::vector<bool> SL1(64, 0);
1322  std::vector<bool> SL2(64, 0);
1323  std::vector<bool> IT0(64, 0);
1324  std::vector<bool> IT0_36b(36, 0);
1325  std::vector<bool> IT0_4b(4, 0);
1326 
1327  //-- collecting TSF info in SL0~2
1328  for (int i = 0; i < tslist.getEntries(); i++) {
1329  int id = tslist[i]->getSegmentID();
1330  int sl = 0;
1331  if (id >= 0 * 32 && id < 5 * 32) {sl = 0; id -= 0;}
1332  else if (id >= 5 * 32 && id < 10 * 32) {sl = 1; id -= 5 * 32;}
1333  else if (id >= 10 * 32 && id < 16 * 32) {sl = 2; id -= 10 * 32;}
1334  else continue;
1335 
1336  if (sl == 0) {
1337  int X = (int)(id / 5), Y = id % 5;
1338  if (Y == 0 || Y == 1) { SL0[2 * X] = true; }
1339  else if (Y == 3 || Y == 4) { SL0[2 * X + 1] = true; }
1340  else { SL0[2 * X] = true; SL0[2 * X + 1] = true; }
1341  } else if (sl == 1) {
1342  int X = (int)(id / 5), Y = id % 5;
1343  if (Y == 0 || Y == 1) { SL1[2 * X] = true; }
1344  else if (Y == 3 || Y == 4) { SL1[2 * X + 1] = true; }
1345  else { SL1[2 * X] = true; SL1[2 * X + 1] = true; }
1346  } else if (sl == 2) {
1347  int X = (int)(id / 3);
1348  SL2[X] = true;
1349  }
1350  }
1351 
1352 
1353  // -- Inner Track finding with SL0
1354  for (int i = 0; i < 64; i++) {
1355  int j1 = i - 4;
1356  if (j1 < 0) j1 = j1 + 64;
1357  int j2 = i - 3;
1358  if (j2 < 0) j2 = j2 + 64;
1359  int j3 = i - 2;
1360  if (j3 < 0) j3 = j3 + 64;
1361  int j4 = i - 1;
1362  if (j4 < 0) j4 = j4 + 64;
1363  int j5 = i;
1364  int j6 = i + 1;
1365  if (j6 > 63)j6 = j6 - 64;
1366  int j7 = i + 2;
1367  if (j7 > 63)j7 = j7 - 64;
1368  if (
1369  SL0[i] &&
1370  (SL1[j1] || SL1[j2] || SL1[j3] || SL1[j4] || SL1[j5]) &&
1371  (SL2[j3] || SL2[j4] || SL2[j5] || SL2[j6] || SL2[j7])
1372  ) {
1373  IT0[i] = true;
1374  } else {
1375  IT0[i] = false;
1376  }
1377  }
1378 
1379  //-- 64b into 36b
1380  for (int i = 0; i < 4; i++) {
1381  IT0_36b[0 + 9 * i] = IT0[0 + 16 * i] or IT0[1 + 16 * i];
1382  IT0_36b[1 + 9 * i] = IT0[1 + 16 * i] or IT0[2 + 16 * i] or IT0[3 + 16 * i];
1383  IT0_36b[2 + 9 * i] = IT0[3 + 16 * i] or IT0[4 + 16 * i] or IT0[5 + 16 * i];
1384  IT0_36b[3 + 9 * i] = IT0[5 + 16 * i] or IT0[6 + 16 * i] or IT0[7 + 16 * i];
1385  IT0_36b[4 + 9 * i] = IT0[7 + 16 * i] or IT0[8 + 16 * i];
1386  IT0_36b[5 + 9 * i] = IT0[8 + 16 * i] or IT0[9 + 16 * i] or IT0[10 + 16 * i];
1387  IT0_36b[6 + 9 * i] = IT0[10 + 16 * i] or IT0[11 + 16 * i] or IT0[12 + 16 * i];
1388  IT0_36b[7 + 9 * i] = IT0[12 + 16 * i] or IT0[13 + 16 * i] or IT0[14 + 16 * i];
1389  IT0_36b[8 + 9 * i] = IT0[14 + 16 * i] or IT0[15 + 16 * i];
1390  }
1391 
1392  //-- 36b into 4b
1393  IT0_4b[0] = IT0_36b[35] or IT0_36b[0] or IT0_36b[1] or IT0_36b[2] or IT0_36b[3] or IT0_36b[4] or IT0_36b[5] or IT0_36b[6]
1394  or IT0_36b[7] or IT0_36b[8] or IT0_36b[9];
1395  IT0_4b[1] = IT0_36b[8] or IT0_36b[9] or IT0_36b[10] or IT0_36b[11] or IT0_36b[12] or IT0_36b[13] or IT0_36b[14] or IT0_36b[15]
1396  or IT0_36b[16] or IT0_36b[17] or IT0_36b[18] or IT0_36b[19];
1397  IT0_4b[2] = IT0_36b[18] or IT0_36b[19] or IT0_36b[20] or IT0_36b[21] or IT0_36b[22] or IT0_36b[23] or IT0_36b[24] or IT0_36b[25]
1398  or IT0_36b[26] or IT0_36b[27] or IT0_36b[28];
1399  IT0_4b[3] = IT0_36b[26] or IT0_36b[27] or IT0_36b[28] or IT0_36b[29] or IT0_36b[30] or IT0_36b[31] or IT0_36b[32] or IT0_36b[33]
1400  or IT0_36b[34] or IT0_36b[36] or IT0_36b[0];
1401 
1402  //-- Summary info
1403  int N_IT = 0;
1404  bool i2fo = false;
1405  bool i2io = false;
1406  int iecl = 0;
1407  int iklm = 0;
1408 
1409  //-- inner track counting
1410  for (int i = 0; i < 64; i++) {
1411  if (IT0[i]) N_IT++;
1412  TRGGRLInnerTrack* it = grlit.appendNew();
1413  it->set_TS_ID(0, i);
1414  }
1415 
1416  //-- b2b info with IT0 and phi_i map
1417  for (int i = 0; i < 36; i++) {
1418  i2fo = (phimap_i[i] and (IT0_36b[N36(i + 18)] or IT0_36b[N36(i + 17)] or IT0_36b[N36(i + 19)]
1419  or IT0_36b[N36(i + 16)] or IT0_36b[N36(i + 20)]
1420  or IT0_36b[N36(i + 15)] or IT0_36b[N36(i + 21)]
1421  or IT0_36b[N36(i + 14)] or IT0_36b[N36(i + 22)]
1422  or IT0_36b[N36(i + 13)] or IT0_36b[N36(i + 23)]
1423  or IT0_36b[N36(i + 12)] or IT0_36b[N36(i + 24)]
1424  or IT0_36b[N36(i + 11)] or IT0_36b[N36(i + 25)]
1425  or IT0_36b[N36(i + 10)] or IT0_36b[N36(i + 26)]
1426  or IT0_36b[N36(i + 9)] or IT0_36b[N36(i + 27)])) or i2fo ;
1427  }
1428  //-- b2b info with IT0
1429  for (int i = 0; i < 36; i++) {
1430  i2io = (IT0_36b[i] and (IT0_36b[N36(i + 18)] or IT0_36b[N36(i + 17)] or IT0_36b[N36(i + 19)]
1431  or IT0_36b[N36(i + 16)] or IT0_36b[N36(i + 20)]
1432  or IT0_36b[N36(i + 15)] or IT0_36b[N36(i + 21)]
1433  or IT0_36b[N36(i + 14)] or IT0_36b[N36(i + 22)]
1434  or IT0_36b[N36(i + 13)] or IT0_36b[N36(i + 23)]
1435  or IT0_36b[N36(i + 12)] or IT0_36b[N36(i + 24)]
1436  or IT0_36b[N36(i + 11)] or IT0_36b[N36(i + 25)]
1437  or IT0_36b[N36(i + 10)] or IT0_36b[N36(i + 26)]
1438  or IT0_36b[N36(i + 9)] or IT0_36b[N36(i + 27)])) or i2io ;
1439  }
1440  //inner-ecl matching at endcap
1441  bool IT0_36b_temp[36 * 2];
1442  for (int i = 0; i < 36; i++) {
1443  IT0_36b_temp[i] = IT0_36b[i];
1444  IT0_36b_temp[i + 36] = IT0_36b[i];
1445  }
1446  for (int i = 0; i < 36; i++) {
1447  if (ecl_phimap[i] and
1448  (IT0_36b_temp[i + 36] or IT0_36b_temp[i + 36 + 1] or IT0_36b_temp[i + 36 + 2] or IT0_36b_temp[i + 36 + 3]
1449  or IT0_36b_temp[i + 36 + 4] or
1450  IT0_36b_temp[i + 36 - 1] or IT0_36b_temp[i + 36 - 2] or IT0_36b_temp[i + 36 - 3] or IT0_36b_temp[i + 36 - 4])
1451  )iecl++;
1452  }
1453 
1454  //std::cout << "sector map " ;
1455  //for (int i = 0; i < 4; i++) {
1456  // std::cout << " " << i << " " << IT0_4b[i] << " " << klm_sectormap[i];
1457  //}
1458  //std::cout << std::endl;
1459 
1460  //inner-klm matching at endcap
1461  for (int i = 0; i < 4; i++) {
1462  if (klm_sectormap[i] and IT0_4b[i])iklm++;
1463  }
1464  //-- set results
1465  trgInfo->setNinnertrk(N_IT);
1466  trgInfo->seti2fo(i2fo);
1467  trgInfo->seti2io(i2io);
1468  trgInfo->setNiecl(iecl);
1469  trgInfo->setNiklm(iklm);
1470 
1471  //for (int i = 0; i < 64; i++) {
1472  // std::cout << SL0[i] << " ";
1473  //}
1474  //std::cout << std::endl;
1475  //for (int i = 0; i < 64; i++) {
1476  // std::cout << SL1[i] << " ";
1477  //}
1478  //std::cout << std::endl;
1479  //for (int i = 0; i < 64; i++) {
1480  // std::cout << SL2[i] << " ";
1481  //}
1482  //std::cout << std::endl;
1483  //for (int i = 0; i < 64; i++) {
1484  // std::cout << IT0[i] << " ";
1485  //}
1486  //std::cout << std::endl;
1487  //for (int i = 0; i < 36; i++) {
1488  // std::cout << IT0_36b[i] << " ";
1489  //}
1490  //std::cout << std::endl;
1491  //for (int i = 0; i < 36; i++) {
1492  // std::cout << phimap_i[i] << " ";
1493  //}
1494  //std::cout << std::endl;
1495  //for (int i = 0; i < 36; i++) {
1496  // std::cout << ecl_phimap[i] << " ";
1497  //}
1498  //std::cout << std::endl;
1499  //std::cout << i2fo << " " << iecl << std::endl;
1500 
1501 }
1502 
1503 void TRGGRLMatchModule::matching_eecl_eklm(std::vector<bool> _eecl_sectormap_fw,
1504  std::vector<bool> _eecl_sectormap_bw,
1505  std::vector<bool> _eklm_sectormap_fw,
1506  std::vector<bool> _eklm_sectormap_bw,
1507  StoreObjPtr<TRGGRLInfo> trgInfo)
1508 {
1509  int ieclklm = 0;
1510  for (int i = 0; i < 4; i++) {
1511  if (_eklm_sectormap_fw[i] && _eecl_sectormap_fw[i])ieclklm++;
1512  if (_eklm_sectormap_bw[i] && _eecl_sectormap_bw[i])ieclklm++;
1513  }
1514 
1515  trgInfo->setNeecleklm(ieclklm);
1516 
1517 }
1518 
1519 void
1520 TRGGRLMatchModule::extrapolation(int pattern, int& l, int& r, int& ec)
1521 {
1522  if (pattern == 6) {ec = 1; l = 0; r = 1;}
1523  if (pattern == 7) {ec = 1; l = 0; r = 1;}
1524  if (pattern == 8) {ec = 1; l = 0; r = 1;}
1525  if (pattern == 9) {ec = 1; l = 0; r = 2;}
1526  if (pattern == 10) {ec = 1; l = 0; r = 2;}
1527  if (pattern == 11) {ec = 1; l = 0; r = 1;}
1528  if (pattern == 12) {ec = 1; l = 0; r = 2;}
1529  if (pattern == 18) {ec = 1; l = 0; r = 2;}
1530  if (pattern == 19) {ec = 1; l = 0; r = 2;}
1531  if (pattern == 20) {ec = 1; l = 0; r = 4;}
1532  if (pattern == 21) {ec = 1; l = 0; r = 4;}
1533  if (pattern == 28) {ec = 1; l = -4; r = 0;}
1534  if (pattern == 29) {ec = 1; l = -3; r = 0;}
1535  if (pattern == 34) {ec = 1; l = 0; r = 1;}
1536  if (pattern == 35) {ec = 1; l = 0; r = 3;}
1537  if (pattern == 36) {ec = 1; l = 1; r = 3;}
1538  if (pattern == 37) {ec = 1; l = 0; r = 3;}
1539  if (pattern == 44) {ec = 1; l = -4; r = 0;}
1540  if (pattern == 45) {ec = 1; l = -2; r = 0;}
1541  if (pattern == 46) {ec = 1; l = -3; r = 0;}
1542  if (pattern == 54) {ec = 1; l = 1; r = 7;}
1543  if (pattern == 55) {ec = 1; l = 1; r = 6;}
1544  if (pattern == 56) {ec = 1; l = 1; r = 5;}
1545  if (pattern == 57) {ec = 1; l = 1; r = 5;}
1546  if (pattern == 64) {ec = 1; l = -6; r = -1;}
1547  if (pattern == 73) {ec = 1; l = 3; r = 13;}
1548  if (pattern == 81) {ec = 1; l = -10; r = -3;}
1549  if (pattern == 86) {ec = 1; l = 3; r = 12;}
1550  if (pattern == 87) {ec = 1; l = 3; r = 6;}
1551  if (pattern == 100) {ec = 1; l = 7; r = 20;}
1552  if (pattern == 101) {ec = 1; l = 5; r = 20;}
1553  if (pattern == 102) {ec = 1; l = 5; r = 20;}
1554  if (pattern == 103) {ec = 1; l = 4; r = 14;}
1555  if (pattern == 111) {ec = 1; l = -12; r = -5;}
1556  if (pattern == 112) {ec = 1; l = -18; r = -5;}
1557  if (pattern == 116) {ec = 1; l = -11; r = -6;}
1558  if (pattern == 120) {ec = 1; l = 7; r = 21;}
1559  if (pattern == 121) {ec = 1; l = 7; r = 14;}
1560  if (pattern == 122) {ec = 1; l = 7; r = 21;}
1561  if (pattern == 127) {ec = 1; l = -21; r = -8;}
1562  if (pattern == 128) {ec = 1; l = -15; r = -7;}
1563  if (pattern == 129) {ec = 1; l = -12; r = -7;}
1564  if (pattern == 132) {ec = 1; l = 10; r = 18;}
1565  if (pattern == 133) {ec = 1; l = 8; r = 18;}
1566 
1567  if (pattern == 0) {ec = 2; l = -3; r = 1;}
1568  if (pattern == 1) {ec = 2; l = -3; r = 1;}
1569  if (pattern == 3) {ec = 2; l = -3; r = 0;}
1570  if (pattern == 13) {ec = 2; l = 0; r = 3;}
1571  if (pattern == 14) {ec = 2; l = 0; r = 4;}
1572  if (pattern == 15) {ec = 2; l = 0; r = 5;}
1573  if (pattern == 22) {ec = 2; l = -4; r = -1;}
1574  if (pattern == 23) {ec = 2; l = -5; r = -1;}
1575  if (pattern == 24) {ec = 2; l = -3; r = 0;}
1576  if (pattern == 25) {ec = 2; l = -4; r = 0;}
1577  if (pattern == 30) {ec = 2; l = 1; r = 5;}
1578  if (pattern == 39) {ec = 2; l = -2; r = 0;}
1579  if (pattern == 40) {ec = 2; l = -2; r = 0;}
1580  if (pattern == 48) {ec = 2; l = 2; r = 6;}
1581  if (pattern == 49) {ec = 2; l = 3; r = 8;}
1582  if (pattern == 58) {ec = 2; l = -9; r = -3;}
1583  if (pattern == 59) {ec = 2; l = -9; r = -3;}
1584  if (pattern == 67) {ec = 2; l = 5; r = 11;}
1585  if (pattern == 75) {ec = 2; l = -13; r = -6;}
1586  if (pattern == 82) {ec = 2; l = 5; r = 9;}
1587  if (pattern == 83) {ec = 2; l = 5; r = 9;}
1588  if (pattern == 89) {ec = 2; l = -10; r = -4;}
1589  if (pattern == 92) {ec = 2; l = -10; r = -4;}
1590  if (pattern == 97) {ec = 2; l = 7; r = 19;}
1591  if (pattern == 105) {ec = 2; l = -16; r = -10;}
1592  if (pattern == 106) {ec = 2; l = -17; r = -7;}
1593  if (pattern == 109) {ec = 2; l = -17; r = -6;}
1594  if (pattern == 111) {ec = 2; l = -16; r = -7;}
1595  if (pattern == 117) {ec = 2; l = 9; r = 19;}
1596  if (pattern == 118) {ec = 2; l = 9; r = 19;}
1597  if (pattern == 124) {ec = 2; l = -17; r = -8;}
1598  if (pattern == 125) {ec = 2; l = -17; r = -8;}
1599  if (pattern == 126) {ec = 2; l = -17; r = -8;}
1600 
1601 }
1602 
1603 
Belle2::CDCTriggerTrack
Track created by the CDC trigger.
Definition: CDCTriggerTrack.h:22
Belle2::Module
Base class for Modules.
Definition: Module.h:72
Belle2::RelationsInterface::addRelationTo
void addRelationTo(const RelationsInterface< BASE > *object, float weight=1.0, const std::string &namedRelation="") const
Add a relation from this object to another object (with caching).
Definition: RelationsObject.h:142
Belle2::StoreAccessorBase::isRequired
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Definition: StoreAccessorBase.h:78
Belle2::StoreAccessorBase::registerInDataStore
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Definition: StoreAccessorBase.h:52
Belle2::StoreAccessorBase::create
bool create(bool replace=false)
Create a default object in the data store.
Definition: StoreAccessorBase.h:107
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::StoreArray::registerRelationTo
bool registerRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut, const std::string &namedRelation="") const
Register a relation to the given StoreArray.
Definition: StoreArray.h:140
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:95
Belle2::TRGECLCluster
Example Detector.
Definition: TRGECLCluster.h:24
Belle2::TRGECLCluster::getPositionZ
double getPositionZ() const
Get Energy weighted position Z.
Definition: TRGECLCluster.h:130
Belle2::TRGECLCluster::getEnergyDep
double getEnergyDep() const
The method to get deposited energy.
Definition: TRGECLCluster.h:119
Belle2::TRGECLCluster::getPositionX
double getPositionX() const
The method to get hit average time Get Energy weighted position X.
Definition: TRGECLCluster.h:126
Belle2::TRGECLCluster::getPositionY
double getPositionY() const
Get Energy weighted position Y.
Definition: TRGECLCluster.h:128
Belle2::TRGGRLInnerTrack
a class for neutral ECL cluster in TRGGRL
Definition: TRGGRLInnerTrack.h:22
Belle2::TRGGRLInnerTrack::set_TS_ID
void set_TS_ID(int i, int id)
set TS ID of SL i
Definition: TRGGRLInnerTrack.h:37
Belle2::TRGGRLMATCHKLM
a class for CDC2D-KLM Matching in TRGGRL
Definition: TRGGRLMATCHKLM.h:21
Belle2::TRGGRLMATCHKLM::set_sector
void set_sector(int sector)
set the klm sector id
Definition: TRGGRLMATCHKLM.h:39
Belle2::TRGGRLMATCHKLM::set_dphi
void set_dphi(double dphi)
set the dphi
Definition: TRGGRLMATCHKLM.h:33
Belle2::TRGGRLMATCH
a class for CDC2D-ECL Matching in TRGGRL
Definition: TRGGRLMATCH.h:21
Belle2::TRGGRLMATCH::set_dphi_d
void set_dphi_d(double dphi_d)
set the dphi_d
Definition: TRGGRLMATCH.h:49
Belle2::TRGGRLMATCH::setDeltaZ
void setDeltaZ(double deltaz)
set the Delta Z
Definition: TRGGRLMATCH.h:46
Belle2::TRGGRLMATCH::set_e
void set_e(double e)
set the cluster energy
Definition: TRGGRLMATCH.h:52
Belle2::TRGGRLMATCH::setDeltaR
void setDeltaR(double deltar)
set the Delta R
Definition: TRGGRLMATCH.h:43
Belle2::TRGGRLMatchModule
Match between CDC trigger track and ECL trigger cluster.
Definition: TRGGRLMatchModule.h:39
Belle2::TRGGRLMatchModule::m_klmtrgsummarylist
std::string m_klmtrgsummarylist
the KLM track list
Definition: TRGGRLMatchModule.h:172
Belle2::TRGGRLMatchModule::eklm_sectormap
std::vector< bool > eklm_sectormap
8 bits phi map of KLM clusters at endcap
Definition: TRGGRLMatchModule.h:160
Belle2::TRGGRLMatchModule::m_TRGGRLInfo
StoreObjPtr< TRGGRLInfo > m_TRGGRLInfo
output for TRGGRLInfo
Definition: TRGGRLMatchModule.h:122
Belle2::TRGGRLMatchModule::m_2dmatch_tracklist
std::string m_2dmatch_tracklist
the distance in phi direction between track and cluster
Definition: TRGGRLMatchModule.h:178
Belle2::TRGGRLMatchModule::N36
int N36(int x)
Force an int to be witnin 0 to 35.
Definition: TRGGRLMatchModule.cc:538
Belle2::TRGGRLMatchModule::m_grlitCollectionName
std::string m_grlitCollectionName
GRL inner track list.
Definition: TRGGRLMatchModule.h:192
Belle2::TRGGRLMatchModule::m_dr_threshold
double m_dr_threshold
max value of dr to be identified as match
Definition: TRGGRLMatchModule.h:136
Belle2::TRGGRLMatchModule::m_dphi_d_threshold
int m_dphi_d_threshold
max value of dphi_d to be identified as match, 1 digit = 10 degrees
Definition: TRGGRLMatchModule.h:140
Belle2::TRGGRLMatchModule::patterns_base2
std::vector< std::vector< int > > patterns_base2
Short tracking patterns based on SL2.
Definition: TRGGRLMatchModule.h:198
Belle2::TRGGRLMatchModule::initialize
virtual void initialize() override
Initialize the parameters.
Definition: TRGGRLMatchModule.cc:84
Belle2::TRGGRLMatchModule::m_phimatch_tracklist
std::string m_phimatch_tracklist
the matched 2d track list by phi matching
Definition: TRGGRLMatchModule.h:180
Belle2::TRGGRLMatchModule::patterns_base0
std::vector< std::vector< int > > patterns_base0
Short tracking patterns based on SL0.
Definition: TRGGRLMatchModule.h:196
Belle2::TRGGRLMatchModule::track_phimap_i
std::vector< bool > track_phimap_i
36 bits phi map of all 2D tracks
Definition: TRGGRLMatchModule.h:148
Belle2::TRGGRLMatchModule::photon_cluster
bool photon_cluster(TRGECLCluster *cluster, std::vector< bool > track_phimap, double e_threshold)
determine photon from isolated cluster
Definition: TRGGRLMatchModule.cc:495
Belle2::TRGGRLMatchModule::eecl_phimap
std::vector< bool > eecl_phimap
36 bits phi map of ECL clusters at endcap
Definition: TRGGRLMatchModule.h:150
Belle2::TRGGRLMatchModule::event
virtual void event() override
Event processor.
Definition: TRGGRLMatchModule.cc:157
Belle2::TRGGRLMatchModule::make_veto_map
void make_veto_map(StoreArray< CDCTriggerTrack > track2Dlist, std::vector< bool > &map_veto)
Make the full track phi veto map for short tracking.
Definition: TRGGRLMatchModule.cc:687
Belle2::TRGGRLMatchModule::eklm_sectormap_fwd
std::vector< bool > eklm_sectormap_fwd
8 bits sector map of KLM clusters at forward endcap
Definition: TRGGRLMatchModule.h:162
Belle2::TRGGRLMatchModule::endRun
virtual void endRun() override
End-of-run action.
Definition: TRGGRLMatchModule.cc:333
Belle2::TRGGRLMatchModule::calculationdistance
void calculationdistance(CDCTriggerTrack *track, TRGECLCluster *cluster, double *ds, int _match3D)
calculate dr and dz between track and cluster
Definition: TRGGRLMatchModule.cc:341
Belle2::TRGGRLMatchModule::calculationphiangle
void calculationphiangle(CDCTriggerTrack *track, TRGECLCluster *cluster, int &dphi_d, std::vector< bool > &track_phimap, std::vector< bool > &track_phimap_i)
calculate dphi_d between track and cluster
Definition: TRGGRLMatchModule.cc:376
Belle2::TRGGRLMatchModule::terminate
virtual void terminate() override
Termination action.
Definition: TRGGRLMatchModule.cc:337
Belle2::TRGGRLMatchModule::~TRGGRLMatchModule
virtual ~TRGGRLMatchModule()
Destructor.
Definition: TRGGRLMatchModule.cc:80
Belle2::TRGGRLMatchModule::m_dz_threshold
double m_dz_threshold
max value of dz to be identified as match
Definition: TRGGRLMatchModule.h:138
Belle2::TRGGRLMatchModule::short_tracking
void short_tracking(StoreArray< CDCTriggerSegmentHit > tslist, std::vector< bool > map_veto, std::vector< bool > phimap_i, std::vector< bool > ecl_phimap_fwd, std::vector< bool > ecl_phimap_bwd, std::vector< bool > klm_sectormap_fwd, std::vector< bool > klm_sectormap_bwd, std::vector< std::vector< int > > &pattern_base0, std::vector< std::vector< int > > &pattern_base2, StoreArray< TRGGRLShortTrack > grlst, StoreObjPtr< TRGGRLInfo > trgInfo)
Short tracking logic.
Definition: TRGGRLMatchModule.cc:850
Belle2::TRGGRLMatchModule::eecl_sectormap_fwd
std::vector< bool > eecl_sectormap_fwd
8 bits sector map of ECL clusters at forward endcap
Definition: TRGGRLMatchModule.h:156
Belle2::TRGGRLMatchModule::m_2d_tracklist
std::string m_2d_tracklist
the 2D finder track list
Definition: TRGGRLMatchModule.h:166
Belle2::TRGGRLMatchModule::beginRun
virtual void beginRun() override
Called when entering a new run.
Definition: TRGGRLMatchModule.cc:153
Belle2::TRGGRLMatchModule::extrapolation
void extrapolation(int pattern, int &l, int &r, int &ec)
Short track extrapolation (to endcap) function.
Definition: TRGGRLMatchModule.cc:1520
Belle2::TRGGRLMatchModule::m_grlstCollectionName
std::string m_grlstCollectionName
GRL short track list.
Definition: TRGGRLMatchModule.h:190
Belle2::TRGGRLMatchModule::m_klmmatch_tracklist
std::string m_klmmatch_tracklist
the matched 2d track list by KLM matching
Definition: TRGGRLMatchModule.h:184
Belle2::TRGGRLMatchModule::m_TrgGrlInformationName
std::string m_TrgGrlInformationName
Name of the StoreArray holding projects information from grl.
Definition: TRGGRLMatchModule.h:194
Belle2::TRGGRLMatchModule::N64
int N64(int x)
Force an int to be witnin 0 to 63.
Definition: TRGGRLMatchModule.cc:531
Belle2::TRGGRLMatchModule::track_phimap
std::vector< bool > track_phimap
36 bits phi map of all 2D tracks
Definition: TRGGRLMatchModule.h:146
Belle2::TRGGRLMatchModule::make_eecl_map
void make_eecl_map(StoreArray< TRGECLCluster > clusterlist, std::vector< bool > &ecl_phimap, std::vector< bool > &ecl_phimap_fwd, std::vector< bool > &ecl_phimap_bwd, std::vector< bool > &ecl_sectormap_fwd, std::vector< bool > &ecl_sectormap_bwd)
Make the ecl endcap phi map for inner/short track matching.
Definition: TRGGRLMatchModule.cc:754
Belle2::TRGGRLMatchModule::sectormatching_klm
void sectormatching_klm(CDCTriggerTrack *track, StoreObjPtr< KLMTrgSummary > klmtrgsummary, double &dphi, int &klmtrack_ind_phi)
calculate dphi between 2D track and KLM track
Definition: TRGGRLMatchModule.cc:449
Belle2::TRGGRLMatchModule::m_grlphotonlist
std::string m_grlphotonlist
Non-matched cluster list at GRL.
Definition: TRGGRLMatchModule.h:186
Belle2::TRGGRLMatchModule::eecl_phimap_bwd
std::vector< bool > eecl_phimap_bwd
36 bits phi map of ECL clusters at backward endcap
Definition: TRGGRLMatchModule.h:154
Belle2::TRGGRLMatchModule::eecl_phimap_fwd
std::vector< bool > eecl_phimap_fwd
36 bits phi map of ECL clusters at forward endcap
Definition: TRGGRLMatchModule.h:152
Belle2::TRGGRLMatchModule::fill_pattern_base2
void fill_pattern_base2(std::vector< std::vector< int > > &patt)
Fill the patterns in short tracking logic.
Definition: TRGGRLMatchModule.cc:545
Belle2::TRGGRLMatchModule::m_3d_tracklist
std::string m_3d_tracklist
the 3D NN track list
Definition: TRGGRLMatchModule.h:168
Belle2::TRGGRLMatchModule::m_e_threshold
double m_e_threshold
min value of isolated cluster energy
Definition: TRGGRLMatchModule.h:142
Belle2::TRGGRLMatchModule::eklm_sectormap_bwd
std::vector< bool > eklm_sectormap_bwd
8 bits sector map of KLM clusters at backward endcap
Definition: TRGGRLMatchModule.h:164
Belle2::TRGGRLMatchModule::m_clusterlist
std::string m_clusterlist
the ecl cluster list
Definition: TRGGRLMatchModule.h:170
Belle2::TRGGRLMatchModule::m_hitCollectionName
std::string m_hitCollectionName
Track Segment list.
Definition: TRGGRLMatchModule.h:188
Belle2::TRGGRLMatchModule::eecl_sectormap_bwd
std::vector< bool > eecl_sectormap_bwd
8 bits sector map of ECL clusters at backward endcap
Definition: TRGGRLMatchModule.h:158
Belle2::TRGGRLMatchModule::make_eklm_map
void make_eklm_map(StoreObjPtr< KLMTrgSummary > klmtrgsummary, std::vector< bool > &eklm_sectormap, std::vector< bool > &eklm_sectormap_fwd, std::vector< bool > &eklm_sectormap_bwd)
Make the klm endcap phi map for inner/short track matching.
Definition: TRGGRLMatchModule.cc:827
Belle2::TRGGRLMatchModule::m_3dmatch_tracklist
std::string m_3dmatch_tracklist
the matched 3d track list
Definition: TRGGRLMatchModule.h:182
Belle2::TRGGRLMatch
A class to represent a matching candidate in TRGGRL A matching candidate consists of a TRGCDCTrack an...
Definition: TRGGRLMatch.h:24
Belle2::TRGGRLPHOTON
a class for neutral ECL cluster in TRGGRL
Definition: TRGGRLPHOTON.h:21
Belle2::TRGGRLPHOTON::set_e
void set_e(double e)
set energy
Definition: TRGGRLPHOTON.h:39
Belle2::TRGGRLShortTrack
a class for neutral ECL cluster in TRGGRL
Definition: TRGGRLShortTrack.h:22
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:650
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17