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