Belle II Software  release-05-02-19
KLMTriggerModule.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2010 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Dmitri Liventsev *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <trg/klm/modules/klmtrigger/KLMTriggerModule.h>
12 
13 // framework - DataStore
14 #include <framework/datastore/StoreArray.h>
15 #include <framework/datastore/StoreObjPtr.h>
16 
17 // event data
18 #include <framework/dataobjects/EventMetaData.h>
19 
20 // digits
21 #include <klm/dataobjects/KLMDigit.h>
22 
23 #include <trg/klm/dataobjects/KLMTriggerHit.h>
24 #include <trg/klm/dataobjects/KLMTriggerTrack.h>
25 
26 #include <unordered_map>
27 
28 
29 using namespace std;
30 using namespace Belle2;
31 
32 //-----------------------------------------------------------------
33 // Register the Module
34 //-----------------------------------------------------------------
35 REG_MODULE(KLMTrigger)
36 
37 //-----------------------------------------------------------------
38 // Implementation
39 //-----------------------------------------------------------------
40 
41 KLMTriggerModule::KLMTriggerModule() : Module()
42 {
43  setDescription("KLM trigger simulation");
45  addParam("MaxChisq", m_maxChisq,
46  "Maximum chi squared for a track",
47  double(7.0));
48  addParam("MaxIP", m_maxIP,
49  "Maximum impact parameter for a track",
50  double(7.0));
51  addParam("MinLayers", m_minLayers,
52  "Minimum number of fired layers for a track",
53  int(10));
54  addParam("TrgKLMTracks", m_klmtrackCollectionName, "Name of the StoreArray holding the track list", string("TRGKLMTracks"));
55  addParam("TrgKLMHits", m_klmhitCollectionName, "Name of the StoreArray holding the hit list", string("TRGKLMHits"));
56 }
57 
59 {
60  StoreArray<KLMDigit> klmDigits;
61 
63  klmTriggerHits.registerInDataStore();
64  klmTriggerHits.registerRelationTo(klmDigits);
65 
67  klmTriggerTracks.registerInDataStore();
68  klmTriggerTracks.registerRelationTo(klmTriggerHits);
69 }
70 
72 {
73  StoreObjPtr<EventMetaData> evtMetaData;
74  B2DEBUG(100, "KLMTrigger: Experiment " << evtMetaData->getExperiment() << ", run " << evtMetaData->getRun());
75  m_nEvents = 0;
76  m_nTracks = 0;
77 }
78 
80 {
81  ++m_nEvents;
82 
83  fillHits();
84  fillTracks();
85  calcChisq();
86 }
87 
89 {
90 // B2INFO("KLMTrigger: Processed " << m_nEvents << " events, found " << m_nTracks << " tracks");
91 }
92 
94 {
95  StoreArray<KLMDigit> klmDigits;
96  if (!klmDigits.isValid())
97  return;
98 
100 
101  int nEntries = klmDigits.getEntries();
102  for (int i = 0; i < nEntries; ++i) {
103  const KLMDigit* bklmDigit_i = klmDigits[i];
104  if (bklmDigit_i->getSubdetector() != KLMElementNumbers::c_BKLM)
105  continue;
106  for (int j = i + 1; j < nEntries; ++j) {
107  const KLMDigit* bklmDigit_j = klmDigits[j];
108  if (bklmDigit_j->getSubdetector() != KLMElementNumbers::c_BKLM)
109  continue;
110 
111  if (bklmDigit_i->getSection() == bklmDigit_j->getSection() &&
112  bklmDigit_i->getSector() == bklmDigit_j->getSector() &&
113  bklmDigit_i->getLayer() == bklmDigit_j->getLayer() &&
114  bklmDigit_i->isPhiReadout() != bklmDigit_j->isPhiReadout()) { // phi-theta match
115  int section = bklmDigit_i->getSection();
116  int sector = bklmDigit_i->getSector() - 1; // zero-based
117  int layer = bklmDigit_i->getLayer() - 1; // zero-based
118  int phiStrip = 0;
119  int zStrip = 0;
120  if (bklmDigit_i->isPhiReadout()) {
121  phiStrip = bklmDigit_i->getStrip() - 1; //zero-based
122  zStrip = bklmDigit_j->getStrip() - 1; // zero-based
123  } else {
124  zStrip = bklmDigit_i->getStrip() - 1; // zero-based
125  phiStrip = bklmDigit_j->getStrip() - 1; // zero-based
126  }
127 
128  int xInt = 0, yInt = 0, zInt = 0;
129  double x = 0.0, y = 0.0, z = 0.0;
130  geometryConverter(section, sector, layer, phiStrip, zStrip, xInt, yInt, zInt);
131  // covert 1/8 cm to cm
132  x = (double)(xInt >> 3);
133  y = (double)(yInt >> 3);
134  z = (double)(zInt >> 3);
135 
136  KLMTriggerHit* hit = klmTriggerHits.appendNew(section, sector, layer, phiStrip, zStrip);
137  hit->setX(x);
138  hit->setY(y);
139  hit->setZ(z);
140  hit->setXInt(xInt);
141  hit->setYInt(yInt);
142  hit->setZInt(zInt);
143  hit->addRelationTo(klmDigits[i]);
144  hit->addRelationTo(klmDigits[j]);
145  }
146  }
147  }
148 // B2INFO("KLM TSIM: " << klmTriggerHits.getEntries() << " hits made");
149 }
150 
151 
152 
153 
155 {
157  if (!klmTriggerHits.isValid())
158  return;
159 
161 
162  std::unordered_map<int, KLMTriggerTrack*> trackMap;
163 
164  int nEntries = klmTriggerHits.getEntries();
165 // B2INFO("KLM TSIM: " << nEntries << " hits found");
166  for (int i = 0; i < nEntries; ++i) {
167  const KLMTriggerHit* hit = klmTriggerHits[i];
168 
169  int section = hit->getSection();
170  int sector = hit->getSector();
171 
172  int sectorID = section * c_TotalSectors + sector;
173 
174  if (trackMap.find(sectorID) == trackMap.end())
175  trackMap[sectorID] = klmTriggerTracks.appendNew(section, sector);
176 
177  trackMap[sectorID]->addRelationTo(klmTriggerHits[i]);
178  }
179 }
180 
181 
183 {
185  if (!klmTriggerTracks.isValid())
186  return;
187 
188  int nEntries = klmTriggerTracks.getEntries();
189  for (int i = 0; i < nEntries; ++i) {
190  KLMTriggerTrack* track = klmTriggerTracks[i];
191  RelationVector<KLMTriggerHit> hits = track->getRelationsWith<KLMTriggerHit>(m_klmhitCollectionName);
192 
193  int nHits = hits.size();
194 // B2INFO("KLM TSIM: " << nHits << " hits attached to track");
195  int sumX = 0, sumY = 0, sumZ = 0, sumXX = 0, sumXY = 0, sumXZ = 0, sumYY = 0, sumZZ = 0;
196  int nLayers = 0;
197  int firstLayer = c_TotalLayers;
198  int lastLayer = 0;
199 // bool firedLayers[c_TotalLayers] = { };
200  std::unordered_map<int, bool> layersMap;
201 
202  for (int j = 0; j < nHits; ++j) {
203  const KLMTriggerHit* hit = hits[j];
204 
205  const int xInt = hit->getXInt();
206  const int yInt = hit->getYInt();
207  const int zInt = hit->getZInt();
208  const int layer = hit->getLayer();
209 
210  // calculate sums
211  sumX += xInt;
212  sumY += yInt;
213  sumZ += zInt;
214  sumXX += xInt * xInt;
215  sumXY += xInt * yInt;
216  sumXZ += xInt * zInt;
217  sumYY += yInt * yInt;
218  sumZZ += zInt * zInt;
219 
220  // find minimum and maximum layers
221  if (layer < firstLayer)
222  firstLayer = layer;
223  if (layer > lastLayer)
224  lastLayer = layer;
225 // firedLayers[layer] = true;
226  layersMap[layer] = true;
227  }
228 
229  // mimic firmware integer widths
230 // if(abs(sumX)>262144) // 5 bits upto 18 bits
231 // sumX = 0;
232 // if(abs(sumY)>262144)
233 // sumY = 0;
234 // if(abs(sumZ)>262144)
235 // sumZ = 0;
236 
237 // if(abs(sumXX)>5.37e8) // 10 bits upto 29 bits
238 // sumXX = 0;
239 // if(abs(sumXY)>5.37e8)
240 // sumXY = 0;
241 // if(abs(sumXZ)>5.37e8)
242 // sumXZ = 0;
243 // if(abs(sumYY)>5.37e8)
244 // sumYY = 0;
245 // if(abs(sumZZ)>5.37e8)
246 // sumZZ = 0;
247 
248  sumX = sumX >> 5;
249  sumY = sumY >> 5;
250  sumZ = sumZ >> 5;
251 
252  sumXX = sumXX >> 10;
253  sumXY = sumXY >> 10;
254  sumXZ = sumXZ >> 10;
255  sumYY = sumYY >> 10;
256  sumZZ = sumZZ >> 10;
257 
258  // calculate chisq
259  int denom = sumXX * nHits - sumX * sumX;
260  /* cppcheck-suppress variableScope */
261  double denomInversed = 0.0;
262  double slopeXY = 0.0;
263  double interceptXY = 0.0;
264  double chisqXY = 0.0;
265  double ipXY = 0.0;
266  double slopeXZ = 0.0;
267  double interceptXZ = 0.0;
268  double chisqXZ = 0.0;
269  double ipXZ = 0.0;
270 
271  denom = denom >> 4;
272 // if(abs(denomInt)<1.074e6) { // 14 bits upto 30 bits
273  if (denom != 0) {
274  denomInversed = 1.0 / denom;
275 
276  slopeXY = denomInversed * (sumXY * nHits - sumX * sumY);
277  interceptXY = denomInversed * (sumXX * sumY - sumX * sumXY);
278 
279  slopeXZ = denomInversed * (sumXZ * nHits - sumX * sumZ);
280  interceptXZ = denomInversed * (sumXX * sumZ - sumX * sumXZ);
281 
282  // denominator shift compensation
283  slopeXY /= 16;
284  interceptXY /= 16;
285 
286  slopeXZ /= 16;
287  interceptXZ /= 16;
288 
289  // to avoid additional division, and square root calculation,
290  // in the firmware we calculate ip^2 and
291  // approximate 1/(1+slope*slope) as (1-slope*slope)
292  // mimic this behaviour here
293  ipXY = interceptXY * interceptXY * (1.0 - slopeXY * slopeXY);
294  chisqXY = slopeXY * slopeXY * sumXX + interceptXY * interceptXY * nHits + sumYY + 2.0 * slopeXY * interceptXY * sumX - 2.0 *
295  slopeXY * sumXY - 2.0 * interceptXY * sumY;
296 
297  ipXZ = interceptXZ * interceptXZ * (1.0 - slopeXZ * slopeXZ);
298  chisqXZ = slopeXZ * slopeXZ * sumXX + interceptXZ * interceptXZ * nHits + sumZZ + 2.0 * slopeXZ * interceptXZ * sumX - 2.0 *
299  slopeXZ * sumXZ - 2.0 * interceptXZ * sumZ;
300 
301  // sumX, sumXX shift compensation (first factor)
302  // and convert 1/8 cm -> cm (second factor)
303  interceptXY *= (32 / 8);
304  chisqXY *= (1024 / 64);
305  ipXY *= (1024 / 64);
306 
307  interceptXZ *= (32 / 8);
308  chisqXZ *= (1024 / 64);
309  ipXZ *= (1024 / 64);
310  }
311 
312 // // calculate number of fired layers
313 // for(int i = 0; i < c_TotalLayers; ++i)
314 // if(firedLayers[i] == true)
315 // ++nLayers;
316  nLayers = layersMap.size();
317 
318  track->setSlopeXY(slopeXY);
319  track->setInterceptXY(interceptXY);
320  track->setChisqXY(chisqXY);
321  track->setImpactParameterXY(ipXY);
322 
323  track->setSlopeXZ(slopeXZ);
324  track->setInterceptXZ(interceptXZ);
325  track->setChisqXZ(chisqXZ);
326  track->setImpactParameterXZ(ipXZ);
327 
328  track->setFirstLayer(firstLayer);
329  track->setLastLayer(lastLayer);
330  track->setNLayers(nLayers);
331 
332  // to avoid additional division, in the firmware we do not calculate chisq/n
333  // we compare chisq to threshold*n
334  // mimic this behaviour here
335  if (chisqXY < m_maxChisq * nHits && ipXY < m_maxIP &&
336  chisqXZ < m_maxChisq * nHits && ipXZ < m_maxIP &&
337  nLayers > m_minLayers)
338  track->setTrigger(true);
339  }
340  m_nTracks += nEntries;
341 }
342 
343 
344 //void KLMTriggerModule::geometryConverter(bool section, int sector, int layer, int phiStrip, int zStrip, double& x, double& y, double& z)
345 //{
346 // // lengths are in centimeters
347 // const double phi_width[c_TotalLayers] = {4.0, 4.0, 4.90, 5.11, 5.32, 5.53, 4.30, 4.46, 4.62, 4.77, 4.93, 5.09, 5.25, 5.40, 5.56};
348 // const int phi_nstrips[c_TotalLayers] = {37, 42, 36, 36, 36, 36, 48, 48, 48, 48, 48, 48, 48, 48, 48};
349 // const double cosine[c_TotalSectors] = {1.0, 0.707107, 0.0, -0.707107, -1.0, -0.707107, 0.0, 0.707107};
350 // const double sine[c_TotalSectors] = {0.0, 0.707107, 1.0, 0.707107, 0.0, -0.707107, -1.0, -0.707107};
351 // const double z_width = (layer < 2 ? 4.0 : 4.52);
352 // const double z_offset = 47.0;
353 // const double r0 = 201.9;
354 // const double gap_height = 4.4;
355 // const double first_gap_height = 4.1;
356 // const double iron_height = 4.7;
357 // const double frame_thickness = 0.3;
358 //
359 // const double tan_pi_to_8 = 0.414214;
360 // const double gap_iron_width = (layer == 0 ? 7.94 : 3.0);
361 // const int y_offset_sign = (layer == 0 ? -1 : 1);
362 // const double spacer_width = 0.6;
363 // const double scint_height = 1.0;
364 // const double ps_inner_height = 0.635;
365 // const double ps_outer_height = 0.47625;
366 // const double glass_height = 0.238125;
367 // const double gas_height = 0.2;
368 //
369 // if(layer == 0)
370 // x = r0 + 0.5 * first_gap_height;
371 // else
372 // x = r0 + first_gap_height + iron_height + (layer - 1) * (gap_height + iron_height) + 0.5 * gap_height;
373 // y = (0.5 + phiStrip - 0.5 * phi_nstrips[layer]) * phi_width[layer];
374 // z = (0.5 + zStrip) * z_width + frame_thickness;
375 //
376 // // some small corrections
377 // if(layer < 2) { // scints
378 // if(layer == 0)
379 // y += ((x + 0.5 * first_gap_height) * tan_pi_to_8 - gap_iron_width - frame_thickness - 0.5 * phi_nstrips[layer] * phi_width[layer]) *
380 // y_offset_sign;
381 // else
382 // y += ((x + 0.5 * gap_height) * tan_pi_to_8 - gap_iron_width - frame_thickness - 0.5 * phi_nstrips[layer] * phi_width[layer]) *
383 // y_offset_sign;
384 // // x correction should go later, since in y correction calculation previous x is used (ActiveMiddleRadius vs ModuleMiddleRadius)
385 // x += -(0.5 * scint_height - 0.5 * (ps_inner_height - ps_outer_height));
386 // } else { // RPCs
387 // x += -(glass_height + 0.5 * gas_height);
388 // z += spacer_width;
389 // }
390 //
391 // // backward part flip
392 // if(!section) {
393 // y = -y;
394 // z = -z;
395 // }
396 //
397 // // detector asymmetry shift
398 // z += z_offset;
399 //
400 // // rotate the sector to its position
401 // double x_tmp = x, y_tmp = y;
402 // x_tmp = x_tmp*cosine[sector] - y_tmp*sine[sector];
403 // y_tmp = x_tmp*sine[sector] + y_tmp*cosine[sector];
404 //}
405 
406 
407 void KLMTriggerModule::geometryConverter(int section, int sector, int layer, int phiStrip, int zStrip, int& x, int& y, int& z)
408 {
409  const int c_LayerXCoord[c_TotalLayers] = {1628, 1700, 1773, 1846, 1919, 1992, 2064, 2137, 2210, 2283, 2356, 2428, 2501, 2574, 2647};
410  const int c_LayerY0[c_TotalLayers] = { -2403, -2566, -2744, -2862, -2979, -3097, -3234, -3354, -3474, -3587, -3708, -3828, -3948, -4061, -4181};
411  const int c_PhiWidth[c_TotalLayers] = {128, 128, 157, 164, 170, 177, 138, 143, 148, 153, 158, 163, 168, 173, 178};
412 
413  const int c_Z01 = 18;
414  const int c_Z02 = 25;
415  const int c_ZWidth1 = 32;
416  const int c_ZWidth2 = 36;
417  const int c_ZOffset = 376;
418 
419  bool flipped = false;
420  int dy = 0;
421  int dz = 0;
422  int z0 = 0;
423  int zWidth = 0;
424 
425  // define if module is flipped
426  if (layer == 0 && section == 0 && sector == 0) // layer 0, backward, sector 0
427  flipped = true;
428  else if (layer == 0 && section == 0 && sector == 1)
429  flipped = true;
430  else if (layer == 0 && section == 0 && sector == 2)
431  flipped = false;
432  else if (layer == 0 && section == 0 && sector == 3)
433  flipped = false;
434  else if (layer == 0 && section == 0 && sector == 4)
435  flipped = false;
436  else if (layer == 0 && section == 0 && sector == 5)
437  flipped = false;
438  else if (layer == 0 && section == 0 && sector == 6)
439  flipped = true;
440  else if (layer == 0 && section == 0 && sector == 7)
441  flipped = true;
442  else if (layer == 0 && section == 1 && sector == 0) // layer 0, forward, sector 0
443  flipped = true;
444  else if (layer == 0 && section == 1 && sector == 1)
445  flipped = true;
446  else if (layer == 0 && section == 1 && sector == 2)
447  flipped = true;
448  else if (layer == 0 && section == 1 && sector == 3)
449  flipped = false;
450  else if (layer == 0 && section == 1 && sector == 4)
451  flipped = false;
452  else if (layer == 0 && section == 1 && sector == 5)
453  flipped = false;
454  else if (layer == 0 && section == 1 && sector == 6)
455  flipped = false;
456  else if (layer == 0 && section == 1 && sector == 7)
457  flipped = true;
458  else if (layer == 1 && section == 0 && sector == 0) // layer 1, backward, sector 0
459  flipped = false;
460  else if (layer == 1 && section == 0 && sector == 1)
461  flipped = false;
462  else if (layer == 1 && section == 0 && sector == 2)
463  flipped = false;
464  else if (layer == 1 && section == 0 && sector == 3)
465  flipped = true;
466  else if (layer == 1 && section == 0 && sector == 4)
467  flipped = true;
468  else if (layer == 1 && section == 0 && sector == 5)
469  flipped = true;
470  else if (layer == 1 && section == 0 && sector == 6)
471  flipped = true;
472  else if (layer == 1 && section == 0 && sector == 7)
473  flipped = false;
474  else if (layer == 1 && section == 1 && sector == 0) // layer 1, forward, sector 0
475  flipped = false;
476  else if (layer == 1 && section == 1 && sector == 1)
477  flipped = false;
478  else if (layer == 1 && section == 1 && sector == 2)
479  flipped = true;
480  else if (layer == 1 && section == 1 && sector == 3)
481  flipped = true;
482  else if (layer == 1 && section == 1 && sector == 4)
483  flipped = true;
484  else if (layer == 1 && section == 1 && sector == 5)
485  flipped = true;
486  else if (layer == 1 && section == 1 && sector == 6)
487  flipped = false;
488  else if (layer == 1 && section == 1 && sector == 7)
489  flipped = false;
490  else if (layer > 2 && section == 0) // backward RPCs
491  flipped = true;
492  else
493  flipped = false;
494 
495  // convert channels to x, y, z
496  if (layer < 2) {
497  z0 = c_Z01;
498  zWidth = c_ZWidth1;
499  } else {
500  z0 = c_Z02;
501  zWidth = c_ZWidth2;
502  }
503 
504  // corrections to y && z
505  if (layer == 2 || layer == 4 || layer == 8 ||
506  layer == 10 || layer == 11 || layer == 13) {
507  if (phiStrip > 45)
508  dy = -9;
509  else if (phiStrip > 40)
510  dy = -8;
511  else if (phiStrip > 35)
512  dy = -7;
513  else if (phiStrip > 29)
514  dy = -6;
515  else if (phiStrip > 24)
516  dy = -5;
517  else if (phiStrip > 18)
518  dy = -4;
519  else if (phiStrip > 13)
520  dy = -3;
521  else if (phiStrip > 8)
522  dy = -2;
523  else if (phiStrip > 2)
524  dy = -1;
525  else
526  dy = 0;
527  } else if (layer == 3 || layer == 6 or
528  layer == 7 || layer == 9) {
529  if (phiStrip > 47)
530  dy = -18;
531  else if (phiStrip > 45)
532  dy = -17;
533  else if (phiStrip > 42)
534  dy = -16;
535  else if (phiStrip > 39)
536  dy = -15;
537  else if (phiStrip > 36)
538  dy = -14;
539  else if (phiStrip > 34)
540  dy = -13;
541  else if (phiStrip > 31)
542  dy = -12;
543  else if (phiStrip > 28)
544  dy = -11;
545  else if (phiStrip > 25)
546  dy = -10;
547  else if (phiStrip > 23)
548  dy = -9;
549  else if (phiStrip > 20)
550  dy = -8;
551  else if (phiStrip > 17)
552  dy = -7;
553  else if (phiStrip > 15)
554  dy = -6;
555  else if (phiStrip > 12)
556  dy = -5;
557  else if (phiStrip > 9)
558  dy = -4;
559  else if (phiStrip > 6)
560  dy = -3;
561  else if (phiStrip > 4)
562  dy = -2;
563  else if (phiStrip > 1)
564  dy = -1;
565  else
566  dy = 0;
567  } else
568  dy = 0;
569 
570  if (layer == 4)
571  dy = -dy;
572 
573  if (layer >= 2) {
574  if (zStrip > 45)
575  dz = 8;
576  else if (zStrip > 38)
577  dz = 7;
578  else if (zStrip > 32)
579  dz = 6;
580  else if (zStrip > 26)
581  dz = 5;
582  else if (zStrip > 20)
583  dz = 4;
584  else if (zStrip > 13)
585  dz = 3;
586  else if (zStrip > 7)
587  dz = 2;
588  else if (zStrip > 1)
589  dz = 1;
590  else
591  dz = 0;
592  } else
593  dz = 0;
594 
595  y = c_LayerY0[layer] + dy + phiStrip * c_PhiWidth[layer];
596  if (flipped)
597  y = -y;
598 
599  z = z0 + dz + zStrip * zWidth;
600  if (section == 1)
601  z = z + c_ZOffset;
602  else
603  z = -z + c_ZOffset;
604 
605  x = c_LayerXCoord[layer];
606  y = y >> 2; // y values are defined in 1/32 cm here, round up to 1/8 cm
607 //z = z;
608 }
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
Belle2::KLMDigit::getSubdetector
int getSubdetector() const
Get subdetector number.
Definition: KLMDigit.h:89
Belle2::KLMTriggerModule::endRun
virtual void endRun() override
This method is called if the current run ends.
Definition: KLMTriggerModule.cc:88
Belle2::KLMTriggerModule::m_klmhitCollectionName
std::string m_klmhitCollectionName
name of StoreArray Hits
Definition: KLMTriggerModule.h:89
Belle2::KLMTriggerTrack
Store KLM TRG track information as a ROOT object.
Definition: KLMTriggerTrack.h:30
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:150
Belle2::KLMTriggerModule::m_minLayers
int m_minLayers
Trigger threshold on the number of fired layers.
Definition: KLMTriggerModule.h:79
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:216
Belle2::KLMTriggerModule::geometryConverter
void geometryConverter(int section, int sector, int layer, int phiStrip, int zStrip, int &x, int &y, int &z)
Convert sector, layer and channel numbers to x, y, z coordinates.
Definition: KLMTriggerModule.cc:407
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::Module::c_ParallelProcessingCertified
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition: Module.h:82
Belle2::KLMTriggerModule::m_nEvents
int m_nEvents
Total number of processed events.
Definition: KLMTriggerModule.h:82
Belle2::KLMTriggerModule::initialize
virtual void initialize() override
Initialize the Module.
Definition: KLMTriggerModule.cc:58
Belle2::KLMTriggerModule::event
virtual void event() override
This method is the core of the module.
Definition: KLMTriggerModule.cc:79
Belle2::KLMDigit::getSection
int getSection() const
Get section number.
Definition: KLMDigit.h:107
Belle2::KLMTriggerModule::fillTracks
void fillTracks()
Create tracks from 2D hits.
Definition: KLMTriggerModule.cc:154
Belle2::KLMDigit::getSector
int getSector() const
Get sector number.
Definition: KLMDigit.h:125
Belle2::KLMDigit::getLayer
int getLayer() const
Get layer number.
Definition: KLMDigit.h:143
Belle2::KLMTriggerModule::m_maxChisq
double m_maxChisq
Trigger threshold on chisq.
Definition: KLMTriggerModule.h:75
Belle2::KLMDigit
KLM digit (class representing a digitized hit in RPCs or scintillators).
Definition: KLMDigit.h:40
Belle2::KLMDigit::isPhiReadout
bool isPhiReadout() const
Whether BKLM digit is in phi or z plane.
Definition: KLMDigit.cc:134
Belle2::Module
Base class for Modules.
Definition: Module.h:74
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:210
Belle2::KLMTriggerModule::c_TotalSectors
static const int c_TotalSectors
Total number of sectors (eight, a constant)
Definition: KLMTriggerModule.h:70
Belle2::KLMTriggerModule::m_klmtrackCollectionName
std::string m_klmtrackCollectionName
name of StoreArray Tracks
Definition: KLMTriggerModule.h:87
Belle2::RelationVector
Class for type safe access to objects that are referred to in relations.
Definition: DataStore.h:38
Belle2::KLMTriggerModule::m_maxIP
double m_maxIP
Trigger threshold on the impact parameter.
Definition: KLMTriggerModule.h:77
Belle2::KLMTriggerModule::beginRun
virtual void beginRun() override
Called when entering a new run.
Definition: KLMTriggerModule.cc:71
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::KLMTriggerModule::m_nTracks
int m_nTracks
Total number of found tracks.
Definition: KLMTriggerModule.h:84
Belle2::KLMTriggerModule::fillHits
void fillHits()
Create 2D hits from KLM Digits.
Definition: KLMTriggerModule.cc:93
Belle2::KLMTriggerHit
Store KLM TRG hit information as a ROOT object.
Definition: KLMTriggerHit.h:30
Belle2::KLMElementNumbers::c_BKLM
@ c_BKLM
BKLM.
Definition: KLMElementNumbers.h:47
Belle2::StoreArray::isValid
bool isValid() const
Check wether the array was registered.
Definition: StoreArray.h:298
Belle2::KLMTriggerModule::c_TotalLayers
static const int c_TotalLayers
Total number of layers (fifteen, a constant)
Definition: KLMTriggerModule.h:72
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:562
Belle2::KLMTriggerModule::calcChisq
void calcChisq()
Calculate track parameters, chi squared, impact parameter and number of fired layers.
Definition: KLMTriggerModule.cc:182
Belle2::KLMDigit::getStrip
int getStrip() const
Get strip number.
Definition: KLMDigit.h:179
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:226