Belle II Software development
CDCTriggerNeuroDQMOnlineModule.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#include <framework/dataobjects/EventMetaData.h>
9
10#include <tracking/dataobjects/RecoTrack.h>
11#include <trg/cdc/modules/dqmneuro/CDCTriggerNeuroDQMOnlineModule.h>
12
13#include <TDirectory.h>
14
15#include <cmath>
16
17using namespace Belle2;
18//-----------------------------------------------------------------
19// Register the Module
20//-----------------------------------------------------------------
21REG_MODULE(CDCTriggerNeuroDQMOnline);
22
23//-----------------------------------------------------------------
24// Implementation
25//-----------------------------------------------------------------
26
27CDCTriggerNeuroDQMOnlineModule::CDCTriggerNeuroDQMOnlineModule() : HistoModule()
28{
29 //Set module properties
30 setDescription("CDC Trigger DQM Online module for HLT/Expressreco");
31 setPropertyFlags(c_ParallelProcessingCertified); // specify this flag if you need parallel processing
32 addParam("unpacked2DTracksName", m_unpacked2DTracksName,
33 "The name of the StoreArray of the unpacked 2D finder tracks",
34 std::string("CDCTrigger2DFinderTracks"));
35 addParam("simNeuroTracksName", m_simNeuroTracksName,
36 "The name of the StoreArray of the Neurotrigger tracks from HWSIM",
37 std::string("TSimNeuroTracks"));
38 addParam("unpackedNeuroTracksName", m_unpackedNeuroTracksName,
39 "The name of the StoreArray of the unpacked neurotrigger tracks",
40 std::string("CDCTriggerNeuroTracks"));
41 addParam("unpackedNeuroInput2dTracksName", m_unpackedNeuroInput2DTracksName,
42 "The name of the StoreArray of the neurotrigger input 2d tracks",
43 std::string("CDCTriggerNNInput2DFinderTracks"));
44 addParam("unpackedNeuroInputSegmentHits", m_unpackedNeuroInputSegmentHitsName,
45 "The name of the StoreArray of the neurotrigger input segment hits",
46 std::string("CDCTriggerNNInputSegmentHits"));
47 addParam("unpackedNeuroInputAllStereoSegmentHitsName", m_unpackedNeuroInputAllSegmentHitsName,
48 "The name of the StoreArray of all segmenthits arriving at the NN boards",
49 std::string("CDCTriggerNNInputAllStereoSegmentHits"));
50 addParam("histogramDirectoryName", m_histogramDirectoryName,
51 "Name of the directory where histograms will be placed",
52 std::string("TRGCDCTNN2"));
53 addParam("RecoTracksName", m_recoTracksName,
54 "Name of the RecoTrack StoreArray. Leave empty for skipping them.",
55 std::string("RecoTracks"));
56 addParam("useSimTracks", m_useSimTracks,
57 "switch on to use simulated tracks for plots, error logs and in debug output"
58 "Useful for debugging SW/HW Errors:",
59 false);
60 addParam("useRecoTracks", m_useRecoTracks,
61 "switch on to use recotracks",
62 true);
63
64}
65
66
70
71//------------------------------------------------------------------
72// Function to define histograms
73//-----------------------------------------------------------------
74
75void CDCTriggerNeuroDQMOnlineModule::defineHisto()
76{
77 // Create a separate histogram directory and cd into it.
78 TDirectory* oldDir = gDirectory;
79 if (m_histogramDirectoryName != "") {
80 oldDir->mkdir(m_histogramDirectoryName.c_str());
81 oldDir->cd(m_histogramDirectoryName.c_str());
82 }
83 //----------------------------------------------------------------
84
85 // define neurotrigger histograms
86
87 // histograms with recotracks (and hwsimtracks):
88
89 m_neuroHWOutdzall = new TH1F("NeuroHWOutZ-RecoZ",
90 "z Resolution of unpacked and valid neuro tracks; delta z [cm]",
91 200, -100, 100);
92 m_neuroHWOutdz0 = new TH1F("Q0NeuroHWOutZ-RecoZ",
93 "Quadrant0 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
94 200, -100, 100);
95 m_neuroHWOutdz1 = new TH1F("Q1NeuroHWOutZ-RecoZ",
96 "Quadrant1 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
97 200, -100, 100);
98 m_neuroHWOutdz2 = new TH1F("Q2NeuroHWOutZ-RecoZ",
99 "Quadrant2 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
100 200, -100, 100);
101 m_neuroHWOutdz3 = new TH1F("Q3NeuroHWOutZ-RecoZ",
102 "Quadrant3 z Resolution of unpacked and valid neuro tracks; delta z [cm]",
103 200, -100, 100);
104 m_neuroHWSimRecodZ = new TH1F("NeuroHWSimZ-RecoZ",
105 "z Resolution of Simulated HW Tracks; delta z [cm]",
106 200, -100, 100);
107
108 // histograms with just hwneuro and hw2dtracks:
109
110 m_neuroHWOutZ = new TH1F("NeuroHWOutZ",
111 "z distribution of unpacked and valid neuro tracks; z [cm]",
112 200, -100, 100);
113 m_recoZ = new TH1F("RecoTrackZ",
114 "z distribution of all RecoTracks; z [cm]",
115 400, -200, 200);
116 m_recoZ_related = new TH1F("RecoTrackZ_related",
117 "z distribution of all related Recotracks; z [cm]",
118 400, -200, 200);
119 m_neuroHWOutSTTZ = new TH1F("NeuroHWOutSTTZ",
120 "z distribution of unpacked and valid first not updated per event Neurotracks and p<0.7GeV; z [cm]",
121 200, -100, 100);
122 m_neuroHWOutCosTheta = new TH1F("NeuroHWOutCosTheta",
123 "cos theta distribution of unpacked and valid neuro tracks; cos(#theta) ",
124 100, -1, 1);
125 m_neuroHWOutPhi0 = new TH1F("NeuroHWOutPhi0",
126 "phi distribution of unpacked and valid neuro tracks; #phi [#circ]",
127 80, 0, 360); // shift to reduce the binning error
128 m_neuroHWOutP = new TH1F("NeuroHWOutP",
129 "P distribution of unpacked neuro tracks; p_{T} [GeV]",
130 100, 0, 3);
131 m_neuroHWOutPt = new TH1F("NeuroHWOutPt",
132 "Pt distribution of unpacked neuro tracks; p_{T} [GeV]",
133 10, 0, 3);
134 m_neuroHWOutm_time = new TH1F("NeuroHWOutM_time", "m_time distribution of unpacked neuro tracks; clock cycle",
135 48, 0, 48);
136 m_neuroHWValTracksNumber = new TH1F("NeuroHWValTracksNumber", "number of valid neurotracks per event; track count",
137 20, 0, 20);
138 m_neuroHWSector = new TH1F("NeuroHWExpert",
139 "Expert of unpacked neuro tracks; Expert",
140 5, 0, 5);
141 m_neuroHWInTSID = new TH1F("NeuroHWInTSID", "ID of incoming track segments",
142 2336, 0, 2336);
143 m_neuroHWInTSIDSel = new TH1F("NeuroHWInSelTSID", "ID of selected NNT track segments",
144 2336, 0, 2336);
145 m_neuroHWInCDCFE = new TH1F("NeuroHWInCDCFE", "Number of incoming CDCFE board",
146 300, 0, 300);
147 m_neuroHWInm_time = new TH1F("NeuroHWInM_time", "m_time distribution from incoming 2dtracks; clock cycle",
148 48, 0, 48);
149 m_neuroHWIn2DTracksNumber = new TH1F("NeuroHWIn2DTracksNumber", "number of incoming 2dtracks per event; track count",
150 20, 0, 20);
151 m_neuroHWValTSCountAx = new TH1F("NeuroHWValTSCountAx", "Number of axial TS related to a valid NNTrack", 6, 0, 6);
152 m_neuroHWValTSCountSt = new TH1F("NeuroHWValTSCountSt", "Number of stereo TS related to a valid NNTrack", 5, 0, 5);
153
154 // now the histograms with hwsim neurotracks:
155
156 m_neuroHWOutHwSimdZ = new TH1F("NeuroHWOutZ-NeuroHWSimZ",
157 "dz Distribution of Valid Neuro Tracks and Simulated HW Tracks; z [cm]",
158 200, -100, 100);
159 m_neuroHWSimZ = new TH1F("NeuroHWSimZ",
160 "z Distribution of Simulated HW Tracks; z [cm]",
161 200, -100, 100);
162 m_neuroHWSimCosTheta = new TH1F("NeuroHWSimCosTheta",
163 "cos theta Distribution of Simulated HW Tracks; cos(#theta) ",
164 100, -1, 1);
165 m_errcount = m_errdict.size();
166 m_neuroErrors = new TH1F("Neurotrigger-Errors", "Errors in the Neuro Hardware", m_errcount, 0, m_errcount);
167 // cd back to root directory
168 oldDir->cd();
169}
170void CDCTriggerNeuroDQMOnlineModule::initialize()
171{
172 // Register histograms (calls back defineHisto)
173
174 REG_HISTOGRAM
175
176 // require event time and hwneuro related arrays:
177
178 m_eventTime.isOptional("CDCTriggerNeuroETFT0");
179 m_unpacked2DTracks.isRequired(m_unpacked2DTracksName);
180
181 m_unpackedNeuroTracks.isRequired(m_unpackedNeuroTracksName);
182 m_unpackedNeuroInput2DTracks.isRequired(m_unpackedNeuroInput2DTracksName);
183 m_unpackedNeuroInputSegmentHits.isRequired(m_unpackedNeuroInputSegmentHitsName);
184 m_unpackedNeuroInputAllSegmentHits.isRequired(m_unpackedNeuroInputAllSegmentHitsName);
185 m_unpackedNeuroInputVectorName = m_unpackedNeuroTracksName + "Input";
186 m_unpackedNeuroInputVector.isRequired(m_unpackedNeuroInputVectorName);
187
188 // require recotracks, if activated:
189
190 if (m_useRecoTracks) {m_RecoTracks.isRequired("RecoTracks");}
191
192 //require hwsimtracks, if activated:
193
194 if (m_useSimTracks) {
195 m_simNeuroTracks.isRequired(m_simNeuroTracksName);
196 m_simNeuroInputVectorName = m_simNeuroTracksName + "Input";
197 m_simNeuroInputVector.isRequired(m_simNeuroInputVectorName);
198 }
199
200 // require certain relations
201
202 m_unpackedNeuroInput2DTracks.requireRelationTo(m_unpackedNeuroTracks);
203 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputSegmentHits);
204 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputVector);
205 if (m_useSimTracks) {
206 m_unpackedNeuroTracks.requireRelationTo(m_simNeuroTracks);
207 }
208 if (m_useRecoTracks) {
209 m_RecoTracks.requireRelationTo(m_unpackedNeuroTracks);
210 }
211 if (m_useSimTracks && m_useRecoTracks) {
212 m_RecoTracks.requireRelationTo(m_simNeuroTracks);
213 }
214
215
216}
217
218void CDCTriggerNeuroDQMOnlineModule::beginRun()
219{
220 // Just to make sure, reset all the histograms.
221
222 // histograms with recotracks (and hwsimtracks):
223
224 m_neuroHWOutdzall->Reset();
225 m_neuroHWOutdz0->Reset();
226 m_neuroHWOutdz1->Reset();
227 m_neuroHWOutdz2->Reset();
228 m_neuroHWOutdz3->Reset();
229 m_neuroHWSimRecodZ->Reset();
230
231 // histograms with only hwneurotracks
232
233 m_neuroHWOutZ->Reset();
234 m_recoZ->Reset();
235 m_recoZ_related->Reset();
236 m_neuroHWOutSTTZ->Reset();
237 m_neuroHWOutCosTheta->Reset();
238 m_neuroHWOutPhi0->Reset();
239 m_neuroHWOutPt->Reset();
240 m_neuroHWOutP->Reset();
241 m_neuroHWOutm_time->Reset();
242 m_neuroHWValTracksNumber->Reset();
243 m_neuroHWSector->Reset();
244 m_neuroHWInTSID->Reset();
245 m_neuroHWInTSIDSel->Reset();
246 m_neuroHWInCDCFE->Reset();
247 m_neuroHWInm_time->Reset();
248 m_neuroHWIn2DTracksNumber->Reset();
249
250 // histograms with hwsim tracks:
251
252 m_neuroHWOutHwSimdZ->Reset();
253 m_neuroHWSimZ->Reset();
254 m_neuroHWSimCosTheta->Reset();
255 m_neuroErrors->Reset();
256 for (unsigned i = 0; i < m_errcount; ++i) {
257 m_neuroErrors->GetXaxis()->SetBinLabel(i + 1, m_errdict[i].c_str());
258 }
259 //m_neuroErrorsRaw->Reset();
260}
261void CDCTriggerNeuroDQMOnlineModule::event()
262{
263 if (m_unpackedNeuroInputSegmentHits.getEntries() == 0) {
264 B2DEBUG(150, "No unpacked TS found, skipping event.");
265 return;
266 }
267
268 fillHWPlots();
269
270 if (m_useRecoTracks) {fillRecoPlots();}
271
272 if (m_useSimTracks) {
273 fillSimPlots();
274 makeDebugOutput();
275 }
276
277
278
279}
280
281void CDCTriggerNeuroDQMOnlineModule::fillHWPlots()
282{
283
284 unsigned valtrackcount = 0;
285
286 // first, fill the tsid plots and the cdcfe plot:
287
288 for (const CDCTriggerSegmentHit& hit : m_unpackedNeuroInputAllSegmentHits) {
289 m_neuroHWInTSID->Fill(hit.getSegmentID());
290 m_neuroHWInCDCFE->Fill((int)(std::roundf(hit.getSegmentID()) * 2 + 8));
291 m_neuroHWInCDCFE->Fill((int)(std::roundf(hit.getSegmentID()) * 2 + 9));
292 }
293 for (const CDCTriggerSegmentHit& hit : m_unpackedNeuroInputSegmentHits) {
294 m_neuroHWInTSIDSel->Fill(hit.getSegmentID());
295 }
296
297 // now, we loop over the hardware neurotracks and fill the
298 // corresponding histograms
299
300 bool firsttrack = true;
301 for (CDCTriggerTrack& neuroHWTrack : m_unpackedNeuroTracks) {
302 bool valtrack = false;
303 try {
304 valtrack = neuroHWTrack.getValidStereoBit();
305 } catch (...) {
306 B2WARNING("HWTrack doesn't have 'valid bit', get it from relations now ...");
307 valtrack = isValidPattern(getPattern(&neuroHWTrack, m_unpackedNeuroInputSegmentHitsName));
308 }
309 if (valtrack) {
310 int nTsAx = 0;
311 int nTsSt = 0;
312 for (auto ts : neuroHWTrack.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentHitsName)) {
313 if (ts.getISuperLayer() % 2 == 0) {
314 nTsAx ++;
315 } else {
316 nTsSt ++;
317 }
318 }
319 m_neuroHWValTSCountAx->Fill(nTsAx);
320 m_neuroHWValTSCountSt->Fill(nTsSt);
321 if (nTsAx < 4) {
322 neuroHWTrack.setQualityVector(256);
323 }
324 if (nTsSt < 3) {
325 neuroHWTrack.setQualityVector(512);
326 }
327 valtrackcount ++;
328 m_neuroHWOutZ->Fill(neuroHWTrack.getZ0());
329 m_neuroHWOutCosTheta->Fill(copysign(1.0,
330 neuroHWTrack.getCotTheta()) / sqrt(1. / (neuroHWTrack.getCotTheta()*neuroHWTrack.getCotTheta())));
331 double phinorm = neuroHWTrack.getPhi0() * 180. / M_PI;
332 if (phinorm < 0.) {phinorm += 360.;}
333 m_neuroHWOutPhi0->Fill(phinorm);
334 m_neuroHWOutPt->Fill(neuroHWTrack.getPt());
335 float momentum = neuroHWTrack.getPt() / sin(acos(neuroHWTrack.getCotTheta() / sqrt(1 + neuroHWTrack.getCotTheta() *
336 neuroHWTrack.getCotTheta())));
337 m_neuroHWOutP->Fill(momentum);
338 if (momentum < 0.7 && firsttrack && neuroHWTrack.getFoundOldTrack()[0] == false) {
339 m_neuroHWOutSTTZ->Fill(neuroHWTrack.getZ0());
340 firsttrack = false;
341 }
342
343 m_neuroHWOutm_time->Fill(neuroHWTrack.getTime());
344 m_neuroHWSector->Fill(neuroHWTrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getSector());
345
346
347 CDCTriggerTrack* twodHWTrack = neuroHWTrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroInput2DTracksName);
348 m_neuroHWInm_time->Fill(twodHWTrack->getTime());
349
350 // fill the error plots here, but only if simtracks are available
351 // first, get the related simtrack
352 if (m_useSimTracks) {
353 CDCTriggerTrack* neuroSimTrack = neuroHWTrack.getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksName);
354 if (!neuroSimTrack) {
355 B2WARNING("No Simtrack related to HWTrack! This should not happen!");
356 continue;
357 }
358 std::vector<float> unpackedInput =
359 neuroHWTrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
360 std::vector<float> simInput =
361 neuroSimTrack->getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getInput();
362 bool sameInputId = true;
363 bool sameInputAlpha = true;
364 bool scaleErr = false;
365 bool missingHwTS = false;
366 bool missingSwTS = false;
367 bool timeErr = false;
368 for (unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
369 int hwZero = 0;
370 int hwSimZero = 0;
371 if (unpackedInput[ii] != simInput[ii]) {sameInputId = false;}
372 if (unpackedInput[ii + 2] != simInput[ii + 2]) {sameInputAlpha = false;}
373 if (unpackedInput[ii + 1] != simInput[ii + 1]) {timeErr = true;}
374 if (unpackedInput[ii + 1] == 0 && simInput[ii + 1] > 0.99) {scaleErr = true;}
375 if (simInput[ii + 1] == 0 && unpackedInput[ii + 1] > 0.99) {scaleErr = true;}
376 if (unpackedInput[ii] == 0 && unpackedInput[ii + 1] == 0 && unpackedInput[ii + 2] == 0) {hwZero = 1;}
377 if (simInput[ii] == 0 && simInput[ii + 1] == 0 && simInput[ii + 2] == 0) {hwSimZero = 1;}
378 if (hwZero > hwSimZero) {missingSwTS = true;}
379 if (hwZero < hwSimZero) {missingHwTS = true;}
380 }
381 double diff = neuroHWTrack.getZ0() - neuroSimTrack->getZ0();
382 if (std::abs(diff) > 1.) {neuroHWTrack.setQualityVector(2);}
383 if (!sameInputId) {neuroHWTrack.setQualityVector(4);}
384 if (!sameInputAlpha) {neuroHWTrack.setQualityVector(8);}
385 if (scaleErr) {neuroHWTrack.setQualityVector(16);}
386 if (missingSwTS) {neuroHWTrack.setQualityVector(32);}
387 if (missingHwTS) {neuroHWTrack.setQualityVector(64);}
388 if (timeErr) {neuroHWTrack.setQualityVector(1024);}
389
390 }
391 // now fill the error histogram:
392 unsigned qvec = neuroHWTrack.getQualityVector();
393 //m_neuroErrorsRaw->Fill(qvec);
394 m_neuroErrors->Fill(m_errcount - 1);
395 for (unsigned k = 0; k < m_errcount; k++) {
396 if (qvec & (1 << k)) {m_neuroErrors->Fill(k);}
397 }
398 }
399
400 }
401 m_neuroHWIn2DTracksNumber->Fill(m_unpackedNeuroInput2DTracks.getEntries());
402 m_neuroHWValTracksNumber->Fill(valtrackcount);
403}
404
405
406
407void CDCTriggerNeuroDQMOnlineModule::fillSimPlots()
408{
409
410 for (CDCTriggerTrack& neuroSimTrack : m_simNeuroTracks) {
411 CDCTriggerTrack* neuroHWTrack = nullptr;
412 bool valtrack = false;
413 try {
414 valtrack = neuroSimTrack.getValidStereoBit();
415 } catch (...) {
416 B2WARNING("SimTrack doesn't have 'valid bit', get it from relations now ...");
417 valtrack = isValidPattern(getPattern(&neuroSimTrack, m_unpackedNeuroInputSegmentHitsName));
418 }
419 if (valtrack) {
420
421 m_neuroHWSimZ->Fill(neuroSimTrack.getZ0());
422 m_neuroHWSimCosTheta->Fill(copysign(1.0,
423 neuroSimTrack.getCotTheta()) / sqrt(1. / (neuroSimTrack.getCotTheta()*neuroSimTrack.getCotTheta())));
424
425 neuroHWTrack = neuroSimTrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroTracksName);
426 if (neuroHWTrack) {
427 bool valhwtrack = false;
428 try {
429 valhwtrack = neuroHWTrack->getValidStereoBit();
430 } catch (...) {
431 B2WARNING("HWTrack doesn't have 'valid bit', get it from relations now ...");
432 valhwtrack = isValidPattern(getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentHitsName));
433 }
434 if (valhwtrack) {
435 double diff = neuroHWTrack->getZ0() - neuroSimTrack.getZ0();
436 m_neuroHWOutHwSimdZ->Fill(diff);
437 }
438 }
439
440 // now check for recotracks and fill the delta plot
441
442 if (m_useRecoTracks) {
443
444 // try to find related neurotrack
445
446 RecoTrack* recoTrack = neuroSimTrack.getRelatedFrom<RecoTrack>(m_recoTracksName);
447 if (recoTrack) {
448 double zTarget = 0;
449 bool foundValidRep = false;
450
451 for (genfit::AbsTrackRep* rep : recoTrack->getRepresentations()) {
452 if (!recoTrack->wasFitSuccessful(rep))
453 continue;
454 // get state (position, momentum etc.) from hit closest to IP and
455 // extrapolate to z-axis (may throw an exception -> continue to next representation)
456 try {
457 genfit::MeasuredStateOnPlane state =
458 recoTrack->getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
459 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
460
461 zTarget = state.getPos().Z();
462 } catch (...) {
463 continue;
464 }
465 // break loop
466 foundValidRep = true;
467 break;
468 }
469 if (!foundValidRep) {
470 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
471 } else {
472 //no need to check valid bit again
473 m_neuroHWSimRecodZ->Fill(neuroSimTrack.getZ0() - zTarget);
474 }
475 }
476 }
477 }
478 }
479}
480
481void CDCTriggerNeuroDQMOnlineModule::makeDebugOutput()
482{
483 StoreObjPtr<EventMetaData> eventMetaData;
484 static constexpr std::array<int, 9> nWiresInSuperLayer = {
485 160, 160, 192, 224, 256, 288, 320, 352, 384
486 };
487 unsigned axhwts = 0;
488 unsigned sthwts = 0;
489
490 std::vector<TSLine> hwtsoutput;
491 for (const CDCTriggerSegmentHit& xhit : m_unpackedNeuroInputSegmentHits) {
492 if (xhit.getISuperLayer() % 2 == 0) {
493 axhwts ++;
494 } else {
495 sthwts ++;
496 }
497 int iSL = xhit.getISuperLayer();
498 int iTS = xhit.getIWire();
499 int nwires = nWiresInSuperLayer[ iSL ];
500 if (iSL == 8) {
501 iTS += 16;
502 if (iTS > nwires) {
503 iTS -= nwires;
504 }
505 }
506 int tsIDInTracker = iTS - nwires * xhit.getQuadrant() / 4;
507 if (tsIDInTracker < 0) {
508 tsIDInTracker += nwires;
509 }
510 TSLine l(xhit);
511 l.strline = "("
512 + padto(std::to_string(xhit.getISuperLayer()), 2) + ", "
513 + padto(std::to_string(xhit.getQuadrant()), 1) + ", "
514 + padto(std::to_string(xhit.getSegmentID()), 4) + ", "
515 + padto(std::to_string(xhit.getIWire()), 5) + ", "
516 + padto(std::to_string(xhit.getPriorityPosition()), 2) + ", "
517 + padto(std::to_string(xhit.getLeftRight()), 2) + ", "
518 + padto(std::to_string(xhit.priorityTime()), 4) + ", "
519 + padto(std::to_string(xhit.foundTime()), 3) + ", "
520 + padto(std::to_string(tsIDInTracker), 4) + ") | ";
521
522 unsigned count2d = 0;
523 for (CDCTriggerTrack& track : m_unpackedNeuroInput2DTracks) {
524 count2d++;
525 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentHitsName)) {
526 l.strline += std::to_string(count2d);
527 } else {
528 l.strline += ".";
529 }
530 }
531 l.strline += " | ";
532 unsigned counthwn = 0;
533 for (CDCTriggerTrack& track : m_unpackedNeuroTracks) {
534 counthwn++;
535 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentHitsName)) {
536 if (track.getValidStereoBit()) {
537 l.strline += std::to_string(counthwn);
538 } else {
539 l.strline += "x";
540 }
541 } else {
542 l.strline += ".";
543 }
544 }
545 l.strline += " | ";
546
547 unsigned countswn = 0;
548 for (CDCTriggerTrack& track : m_simNeuroTracks) {
549 countswn++;
550 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentHitsName)) {
551 if (track.getValidStereoBit()) {
552 l.strline += std::to_string(countswn);
553 } else {
554 l.strline += "x";
555 }
556 } else {
557 l.strline += ".";
558 }
559 }
560 l.strline += " | ";
561
562 if (m_useRecoTracks) {
563 unsigned countreco = 0;
564 for (const auto& track : m_RecoTracks) {
565 countreco++;
566 bool related = false;
567 for (const CDCTriggerSegmentHit& ts : track.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentHitsName)) {
568 if (&ts == &xhit) {related = true;}
569 }
570 if (related) {
571 l.strline += std::to_string(countreco);
572 } else {
573 l.strline += ".";
574 }
575 }
576 l.strline += " | ";
577 }
578 sorted_insert(hwtsoutput, l, m_unpackedNeuroInputSegmentHitsName, m_unpackedNeuroInput2DTracksName, m_unpackedNeuroTracksName);
579 }
580
581 std::string axhw = std::to_string(axhwts) + " / " + std::to_string(sthwts);
582 std::string hwtsstring = "(SL, Q, SID , WID , PP, LR, pT , fT , TSID) | HWNNIn2D | HWNeuro | SWNeuro | ";
583 if (m_useRecoTracks) {hwtsstring += "Reco | ";}
584 B2DEBUG(10, padright(" ", 100));
585 B2DEBUG(10, "----------------------------------------------------------------------------------------------------");
586 B2DEBUG(10, padright(" ", 100));
587 std::string experimentstring = "Experiment " + std::to_string(eventMetaData->getExperiment()) + " Run " +
588 std::to_string(eventMetaData->getRun()) + " Event " + std::to_string(eventMetaData->getEvent());
589 B2DEBUG(10, padright(experimentstring, 100));
590 B2DEBUG(10, padright(" ", 100));
591 B2DEBUG(10, padright(" ", 100));
592 B2DEBUG(10, padright("Number of NN HW TS (Axial/Stereo): ", 40) << padright(axhw, 60));
593 B2DEBUG(10, padright("Number of HW 2DFinderTracks: ", 40) << padright(std::to_string(m_unpacked2DTracks.getEntries()),
594 60));
595 unsigned f2dtrn = 0;
596 for (CDCTriggerTrack& ltrack : m_unpacked2DTracks) {
597 f2dtrn++;
598 std::stringstream strpt;
599 std::stringstream stromega;
600 std::stringstream strphi;
601 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
602 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
603 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
604 std::string trs = " HW2DFinderTrack Nr. " + std::to_string(f2dtrn) + " (pt, omega, phi) = ";
605 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ")";
606 B2DEBUG(15, padright(trs, 100));
607 }
608 B2DEBUG(10, padright("Number of HW NNInput2DFinderTracks: ",
609 40) << padright(std::to_string(m_unpackedNeuroInput2DTracks.getEntries()), 60));
610 unsigned n2dtrn = 0;
611 for (CDCTriggerTrack& ltrack : m_unpackedNeuroInput2DTracks) {
612 n2dtrn++;
613 std::stringstream strpt;
614 std::stringstream stromega;
615 std::stringstream strphi;
616 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
617 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
618 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
619 std::string trs = " HWNeuroInput2DTrack Nr. " + std::to_string(n2dtrn) + " (pt, omega, phi) = ";
620 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ", " + ")";
621 B2DEBUG(15, padright(trs, 100));
622 }
623 B2DEBUG(10, padright("Number of HW NeuroTracks: ",
624 40) << padright(std::to_string(m_unpackedNeuroTracks.getEntries()), 60));
625 unsigned hwntrn = 0;
626 for (CDCTriggerTrack& ltrack : m_unpackedNeuroTracks) {
627 hwntrn++;
628 std::stringstream strpt;
629 std::stringstream stromega;
630 std::stringstream strphi;
631 std::stringstream strtheta;
632 std::stringstream strz;
633 std::stringstream hwomega;
634 std::stringstream hwphi;
635 std::stringstream hwtheta;
636 std::stringstream hwz;
637 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
638 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
639 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
640 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
641 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
642 hwomega << std::fixed << std::setprecision(0) << ltrack.getRawOmega();
643 hwphi << std::fixed << std::setprecision(0) << ltrack.getRawPhi0();
644 hwtheta << std::fixed << std::setprecision(0) << ltrack.getRawTheta();
645 hwz << std::fixed << std::setprecision(0) << ltrack.getRawZ();
646 std::string trs = " HWNeuroTrack Nr. " + std::to_string(hwntrn) + " (pt,om,phi,theta,z)=(";
647 trs += padto(strpt.str(), 4) + "," + padto(stromega.str(), 6) + "," + padto(strphi.str(), 6) + "," + padto(strtheta.str(),
648 6) + "," + padto(strz.str(), 6) + "),(x," + padto(hwomega.str(), 3) + "," + padto(hwphi.str(), 3) + "," + padto(hwtheta.str(),
649 3) + "," + padto(hwz.str(), 3) + ")";
650 B2DEBUG(15, padright(trs, 100));
651 std::string infostr = ", Found old track: ( ";
652 for (bool x : ltrack.getFoundOldTrack()) {
653 infostr += std::to_string(x);
654 }
655 infostr += "), ";
656 infostr = padright(infostr, 50);
657 infostr += "Drift threshold: ( ";
658 for (bool x : ltrack.getDriftThreshold()) {
659 infostr += std::to_string(x);
660 }
661 infostr += ")";
662 infostr += (ltrack.getValidStereoBit()) ? " valid" : " NOT valid";
663 B2DEBUG(15, padright(infostr, 100));
664 std::string infostr2 = " std. ETF vld:";
665 infostr2 += std::to_string(m_eventTime.isValid());
666 infostr2 += ", ETFT0: ";
667 if (m_eventTime.isValid()) {
668 infostr2 += std::to_string(m_eventTime->getBinnedEventT0(Const::CDC));
669 } else {
670 infostr2 += " ";
671 }
672 infostr2 += ", ETF in CC: ";
673 infostr2 += std::to_string(ltrack.getETF_unpacked());
674 infostr2 += ", ETF recalculated: ";
675 infostr2 += std::to_string(ltrack.getETF_recalced());
676 B2DEBUG(15, padright(infostr2, 100));
677 std::string info2str = " Expert Network Number: " + std::to_string(ltrack.getExpert());
678 info2str += ", TSVector: (";
679 for (unsigned x : ltrack.getTSVector()) {
680 info2str += std::to_string(x) + " ";
681 }
682 info2str += ")";
683 info2str += ", Quality=";
684 info2str += std::to_string(ltrack.getQualityVector());
685 B2DEBUG(15, padright(info2str, 100));
686 CDCTriggerTrack* ftrack = ltrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroInput2DTracksName);
687 CDCTriggerTrack* strack = ftrack->getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksName);
688 if (strack) {
689 std::vector<float> unpackedInput =
690 ltrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
691 std::vector<float> simInput =
692 strack->getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getInput();
693 B2DEBUG(20, padright(" Input Vector unpacked (id, t, alpha), sim (id, t, alpha), delta (id, t, alpha):", 100));
694 for (unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
695 std::string lla = " " + std::to_string(ii / 3) + ")";
696 std::string llb = " " + std::to_string(ii / 3) + ")";
697 lla += "(" + padright(std::to_string(unpackedInput[ii]), 8) + " " + padright(std::to_string(unpackedInput[ii + 1]),
698 8) + " " + padright(std::to_string(unpackedInput[ii + 2]), 8) + "),(" + padright(std::to_string(simInput[ii]),
699 8) + " " + padright(std::to_string(simInput[ii + 1]), 8) + " " + padright(std::to_string(simInput[ii + 2]),
700 8) + "),(" + padright(std::to_string(unpackedInput[ii] - simInput[ii]),
701 8) + " " + padright(std::to_string(unpackedInput[ii + 1] - simInput[ii + 1]),
702 8) + " " + padright(std::to_string(unpackedInput[ii + 2] - simInput[ii + 2]), 8) + ")";
703 llb += " (" + padright(std::to_string(int(unpackedInput[ii] * 4096)),
704 8) + " " + padright(std::to_string(int(unpackedInput[ii + 1] * 4096)),
705 8) + " " + padright(std::to_string(int(unpackedInput[ii + 2] * 4096)),
706 8) + "),(" + padright(std::to_string(int(simInput[ii] * 4096)), 8) + " " + padright(std::to_string(int(simInput[ii + 1] * 4096)),
707 8) + " " + padright(std::to_string(int(simInput[ii + 2] * 4096)),
708 8) + "),(" + padright(std::to_string(int(unpackedInput[ii] * 4096 - simInput[ii] * 4096)),
709 8) + " " + padright(std::to_string(int(unpackedInput[ii + 1] * 4096 - simInput[ii + 1] * 4096)),
710 8) + " " + padright(std::to_string(int(unpackedInput[ii + 2] * 4096 - simInput[ii + 2] * 4096)), 8) + ")";
711
712 B2DEBUG(30, padright(lla, 100));
713 B2DEBUG(20, padright(llb, 100));
714 }
715 }
716 }
717 if (m_useRecoTracks) {
718 B2DEBUG(10, padright("Number of RecoTracks: ", 40) << padright(std::to_string(m_RecoTracks.getEntries()), 60));
719 unsigned recotrn = 0;
720 for (RecoTrack& ltrack : m_RecoTracks) {
721 double phi0Target = 0;
722 double invptTarget = 0;
723 double thetaTarget = 0;
724 double zTarget = 0;
725 double d0Target = 0;
726 bool foundValidRep = false;
727 for (genfit::AbsTrackRep* rep : ltrack.getRepresentations()) {
728 if (!ltrack.wasFitSuccessful(rep))
729 continue;
730 // get state (position, momentum etc.) from hit closest to IP and
731 // extrapolate to z-axis (may throw an exception -> continue to next representation)
732 try {
733 genfit::MeasuredStateOnPlane state =
734 ltrack.getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
735 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
736 // TODO check after matching
737 // // flip tracks if necessary, such that trigger tracks and reco tracks
738 // // point in the same direction
739 // if (state.getMom().Dot(m_tracks[itrack]->getDirection()) < 0) {
740 // state.setPosMom(state.getPos(), -state.getMom());
741 // state.setChargeSign(-state.getCharge());
742 // }
743 // get track parameters
744 phi0Target = state.getMom().Phi() * 180. / M_PI ;
745 if (phi0Target < 0.) {phi0Target = phi0Target + 360. ;}
746 invptTarget = state.getCharge() * state.getMom().Pt();
747 thetaTarget = acos(state.getMom().CosTheta()) * 180 / M_PI;
748 zTarget = state.getPos().Z();
749 d0Target = state.getPos().Perp();
750 } catch (...) {
751 continue;
752 }
753 // break loop
754 foundValidRep = true;
755 break;
756 }
757 if (!foundValidRep) {
758 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
759 continue;
760 }
761 recotrn++;
762 std::stringstream strpt;
763 std::stringstream stromega;
764 std::stringstream strphi;
765 std::stringstream strtheta;
766 std::stringstream strz;
767 strpt << std::fixed << std::setprecision(2) << invptTarget;
768 stromega << std::fixed << std::setprecision(2) << d0Target;
769 strphi << std::fixed << std::setprecision(2) << phi0Target;
770 strtheta << std::fixed << std::setprecision(2) << thetaTarget;
771 strz << std::fixed << std::setprecision(2) << zTarget;
772 std::string trs = " RecoTrack Nr. " + std::to_string(recotrn) + " (invpt, d0, phi, theta, z) = ";
773 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ", " + padto(strtheta.str(),
774 6) + ", " + padto(strz.str(), 6) + ")";
775 B2DEBUG(15, padright(trs, 100));
776 }
777 }
778 B2DEBUG(10, padright(" ", 100));
779 B2DEBUG(10, padright(" ", 100));
780 B2DEBUG(15, padright("Detailed information about HW TS ", 100));
781 B2DEBUG(15, padright(" ", 100));
782 B2DEBUG(15, padright(hwtsstring, 100));
783 for (auto x : hwtsoutput) {
784 B2DEBUG(15, padright(x.strline, 100));
785 }
786 B2DEBUG(15, padright(" ", 100));
787
788
789}
790
791
792void CDCTriggerNeuroDQMOnlineModule::fillRecoPlots()
793{
794 for (RecoTrack& recoTrack : m_RecoTracks) {
795 double zTarget = 0;
796 bool foundValidRep = false;
797 for (genfit::AbsTrackRep* rep : recoTrack.getRepresentations()) {
798 if (!recoTrack.wasFitSuccessful(rep))
799 continue;
800 // get state (position, momentum etc.) from hit closest to IP and
801 // extrapolate to z-axis (may throw an exception -> continue to next representation)
802 try {
803 genfit::MeasuredStateOnPlane state =
804 recoTrack.getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
805 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
806 zTarget = state.getPos().Z();
807 } catch (...) {
808 continue;
809 }
810 // break loop
811 foundValidRep = true;
812 break;
813 }
814 if (!foundValidRep) {
815 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
816 continue;
817 }
818 m_recoZ->Fill(zTarget);
819 // try to find related neurotrack
820
821 CDCTriggerTrack* neuroHWTrack = recoTrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroTracksName);
822 if (!neuroHWTrack) {continue;}
823 bool valtrack = false;
824
825 //check valid bit, else continue (valid ^= enough stereo track segments)
826
827 try {
828 valtrack = neuroHWTrack->getValidStereoBit();
829 } catch (...) {
830 B2WARNING("HWTrack doesn't have 'valid bit', get it from relations now ...");
831 valtrack = isValidPattern(getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentHitsName));
832 }
833 if (!valtrack) {continue;}
834 // TODO check after matching
835 // // flip tracks if necessary, such that trigger tracks and reco tracks
836 // // point in the same direction
837 // if (state.getMom().Dot(m_tracks[itrack]->getDirection()) < 0) {
838 // state.setPosMom(state.getPos(), -state.getMom());
839 // state.setChargeSign(-state.getCharge());
840 // }
841 m_recoZ_related->Fill(zTarget);
842 m_neuroHWOutdzall->Fill(neuroHWTrack->getZ0() - zTarget);
843 switch (neuroHWTrack->getQuadrant()) {
844 case -1:
845 B2WARNING("Neurotrack quadrant was not set!");
846 break;
847 case 0:
848 m_neuroHWOutdz0->Fill(neuroHWTrack->getZ0() - zTarget);
849 break;
850 case 1:
851 m_neuroHWOutdz1->Fill(neuroHWTrack->getZ0() - zTarget);
852 break;
853 case 2:
854 m_neuroHWOutdz2->Fill(neuroHWTrack->getZ0() - zTarget);
855 break;
856 case 3:
857 m_neuroHWOutdz3->Fill(neuroHWTrack->getZ0() - zTarget);
858 break;
859 }
860 }
861}
865
866
Belle2::CDCTriggerNeuroDQMOnlineModule::m_simNeuroInputVector
StoreArray< CDCTriggerMLPInput > m_simNeuroInputVector
StoreArray for neuro input vector from TSIM.
Definition CDCTriggerNeuroDQMOnlineModule.h:216
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInput2DTracks
StoreArray< CDCTriggerTrack > m_unpackedNeuroInput2DTracks
StoreArray for neuro input 2dfinder tracks.
Definition CDCTriggerNeuroDQMOnlineModule.h:210
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroTracks
StoreArray< CDCTriggerTrack > m_unpackedNeuroTracks
StoreArray for neuro tracks from unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:206
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputSegmentHitsName
std::string m_unpackedNeuroInputSegmentHitsName
Name for neuro input Track segments.
Definition CDCTriggerNeuroDQMOnlineModule.h:187
Belle2::CDCTriggerNeuroDQMOnlineModule::event
void event() override
Function to process event record.
Definition CDCTriggerNeuroDQMOnlineModule.cc:261
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpacked2DTracksName
std::string m_unpacked2DTracksName
Name for 2D finder tracks from unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:179
Belle2::CDCTriggerNeuroDQMOnlineModule::endRun
void endRun() override
Function to process end_run record.
Definition CDCTriggerNeuroDQMOnlineModule.cc:862
Belle2::CDCTriggerNeuroDQMOnlineModule::m_useSimTracks
bool m_useSimTracks
Switch to turn on use of hw sim tracks.
Definition CDCTriggerNeuroDQMOnlineModule.h:198
Belle2::CDCTriggerNeuroDQMOnlineModule::terminate
void terminate() override
Function to terminate module.
Definition CDCTriggerNeuroDQMOnlineModule.cc:867
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInput2DTracksName
std::string m_unpackedNeuroInput2DTracksName
Name for neuro input 2d finder tracks.
Definition CDCTriggerNeuroDQMOnlineModule.h:185
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputVector
StoreArray< CDCTriggerMLPInput > m_unpackedNeuroInputVector
StoreArray for neuro input vector from unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:208
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputAllSegmentHitsName
std::string m_unpackedNeuroInputAllSegmentHitsName
Name for TS hits from unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:177
Belle2::CDCTriggerNeuroDQMOnlineModule::m_simNeuroTracks
StoreArray< CDCTriggerTrack > m_simNeuroTracks
StoreArray for neuro tracks from TSIM.
Definition CDCTriggerNeuroDQMOnlineModule.h:214
Belle2::CDCTriggerNeuroDQMOnlineModule::m_simNeuroInputVectorName
std::string m_simNeuroInputVectorName
Name for simulated neuro input vector using HW TS, HW 2D.
Definition CDCTriggerNeuroDQMOnlineModule.h:191
Belle2::CDCTriggerNeuroDQMOnlineModule::beginRun
void beginRun() override
Function to process begin_run record.
Definition CDCTriggerNeuroDQMOnlineModule.cc:218
Belle2::CDCTriggerNeuroDQMOnlineModule::m_histogramDirectoryName
std::string m_histogramDirectoryName
Name of the histogram directory in ROOT file.
Definition CDCTriggerNeuroDQMOnlineModule.h:174
Belle2::CDCTriggerNeuroDQMOnlineModule::m_recoTracksName
std::string m_recoTracksName
Name for the RecoTrack array name.
Definition CDCTriggerNeuroDQMOnlineModule.h:193
Belle2::CDCTriggerNeuroDQMOnlineModule::m_useRecoTracks
bool m_useRecoTracks
Switch to turn on use of recotracks.
Definition CDCTriggerNeuroDQMOnlineModule.h:196
Belle2::CDCTriggerNeuroDQMOnlineModule::m_simNeuroTracksName
std::string m_simNeuroTracksName
name of the storearray for hwsim tracks
Definition CDCTriggerNeuroDQMOnlineModule.h:189
Belle2::CDCTriggerNeuroDQMOnlineModule::getPattern
unsigned getPattern(CDCTriggerTrack *track, std::string hitCollectionName)
get pattern of the track
Definition CDCTriggerNeuroDQMOnlineModule.h:77
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputVectorName
std::string m_unpackedNeuroInputVectorName
Name for neuro input vector from unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:183
Belle2::CDCTriggerNeuroDQMOnlineModule::isValidPattern
bool isValidPattern(unsigned pattern)
Validity of the pattern.
Definition CDCTriggerNeuroDQMOnlineModule.h:87
Belle2::CDCTriggerNeuroDQMOnlineModule::m_eventTime
StoreObjPtr< BinnedEventT0 > m_eventTime
storeobjpointer for event time
Definition CDCTriggerNeuroDQMOnlineModule.h:220
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputSegmentHits
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputSegmentHits
StoreArray for neuro input Track segments.
Definition CDCTriggerNeuroDQMOnlineModule.h:212
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpacked2DTracks
StoreArray< CDCTriggerTrack > m_unpacked2DTracks
StoreArray for 2D finder tracks from unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:204
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroTracksName
std::string m_unpackedNeuroTracksName
Name for neuro tracks from unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:181
Belle2::CDCTriggerNeuroDQMOnlineModule::m_RecoTracks
StoreArray< RecoTrack > m_RecoTracks
StoreArray for RecoTracks.
Definition CDCTriggerNeuroDQMOnlineModule.h:218
Belle2::CDCTriggerNeuroDQMOnlineModule::m_unpackedNeuroInputAllSegmentHits
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputAllSegmentHits
StoreArray for all TS hits from neuro unpacker.
Definition CDCTriggerNeuroDQMOnlineModule.h:202
Belle2::CDCTriggerNeuroDQMOnlineModule::defineHisto
void defineHisto() override
Histogram definitions such as TH1(), TH2(), TNtuple(), TTree()....
Definition CDCTriggerNeuroDQMOnlineModule.cc:75
Belle2::CDCTriggerSegmentHit
Combination of several CDCHits to a track segment hit for the trigger.
Definition CDCTriggerSegmentHit.h:23
Belle2::CDCTriggerTrack::getTime
float getTime() const
get the track found time
Definition CDCTriggerTrack.h:114
Belle2::CDCTriggerTrack::getValidStereoBit
bool getValidStereoBit() const
returns true, if at least 3 stereo ts were found
Definition CDCTriggerTrack.h:132
Belle2::CDCTriggerTrack::getQuadrant
short getQuadrant() const
get the quadrant
Definition CDCTriggerTrack.h:124
Belle2::HistoModule::HistoModule
HistoModule()
Constructor.
Definition HistoModule.h:32
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition Module.cc:214
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition Module.cc:208
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:80
Belle2::RecoTrack::getRepresentations
const std::vector< genfit::AbsTrackRep * > & getRepresentations() const
Return a list of track representations. You are not allowed to modify or delete them!
Definition RecoTrack.h:638
Belle2::RecoTrack::wasFitSuccessful
bool wasFitSuccessful(const genfit::AbsTrackRep *representation=nullptr) const
Returns true if the last fit with the given representation was successful.
Definition RecoTrack.cc:336
Belle2::RecoTrack::getMeasuredStateOnPlaneClosestTo
const genfit::MeasuredStateOnPlane & getMeasuredStateOnPlaneClosestTo(const ROOT::Math::XYZVector &closestPoint, const genfit::AbsTrackRep *representation=nullptr)
Return genfit's MasuredStateOnPlane, that is closest to the given point useful for extrapolation of m...
Definition RecoTrack.cc:426
Belle2::RelationsInterface::getRelatedFrom
FROM * getRelatedFrom(const std::string &name="", const std::string &namedRelation="") const
Get the object from which this object has a relation.
Definition RelationsObject.h:263
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:559
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition Module.h:649
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition beamHelpers.h:28
Belle2
Abstract base class for different kinds of events.
Definition MillepedeAlgorithm.h:17