11 #include "trg/cdc/modules/dqmneuro/CDCTriggerNeuroDQMModule.h"
13 #include <framework/dataobjects/EventMetaData.h>
15 #include "TDirectory.h"
16 #include <tracking/dataobjects/RecoTrack.h>
34 setDescription(
"CDC Trigger DQM module");
35 setPropertyFlags(c_ParallelProcessingCertified);
36 addParam(
"limitedoutput", m_limitedoutput,
37 "Switch to supress output for online dqm purposes. ",
39 addParam(
"unpackedSegmentHitsName", m_unpackedSegmentHitsName,
40 "The name of the StoreArray of the unpacked CDCTriggerSegmentHits",
41 string(
"CDCTriggerSegmentHits"));
42 addParam(
"unpacked2DTracksName", m_unpacked2DTracksName,
43 "The name of the StoreArray of the unpacked 2D finder tracks",
44 string(
"CDCTrigger2DFinderTracks"));
45 addParam(
"unpackedNeuroTracksName", m_unpackedNeuroTracksName,
46 "The name of the StoreArray of the unpacked neurotrigger tracks",
47 string(
"CDCTriggerNeuroTracks"));
48 addParam(
"unpackedNeuroInput2dTracksName", m_unpackedNeuroInput2DTracksName,
49 "The name of the StoreArray of the neurotrigger input 2d tracks",
50 string(
"CDCTriggerNNInput2DFinderTracks"));
51 addParam(
"unpackedNeuroInputSegmentHits", m_unpackedNeuroInputSegmentsName,
52 "The name of the StoreArray of the neurotrigger input segment hits",
53 string(
"CDCTriggerNNInputSegmentHits"));
54 addParam(
"simNeuroTracksName", m_simNeuroTracksName,
55 "The name of the StoreArray of the neurotrigger tracks from TSIM",
57 addParam(
"histogramDirectoryName", m_histogramDirectoryName,
58 "Name of the directory where histograms will be placed",
60 addParam(
"simSegmentHitsName", m_simSegmentHitsName,
61 "StoreArray name for simulated TS hits",
string(
""));
62 addParam(
"sim2DTracksSWTSName", m_sim2DTracksSWTSName,
63 "StoreArray name for simulated 2D finder tracks using simulated TS",
string(
""));
64 addParam(
"simNeuroTracksSWTSSW2DName", m_simNeuroTracksSWTSSW2DName,
65 "StoreArray name for neuro tracks using simulated TS and simulated 2D",
string(
""));
66 addParam(
"showRecoTracks", m_showRecoTracks,
67 "switch to turn on a comparison with the reconstruction, DEPRECATED! Use RecoTracks='RecoTracks' (='') instead!",
69 addParam(
"RecoTracks", m_recoTracksName,
70 "Name of the RecoTrack StoreArray. Leave empty for skipping them.",
72 addParam(
"recoTrackMultiplicity", m_recoTrackMultiplicity,
73 "Select events with a specific RecoTrack track multiplicity. -1 for all events",
75 addParam(
"skipWithoutHWTS", m_skipWithoutHWTS,
76 "Switch to skip events without unpacked TS",
78 addParam(
"maxRecoZDist", m_maxRecoZDist,
79 "Select only RecoTracks with a maximum z distance to the IP. -1.0 for all tracks",
81 addParam(
"maxRecoD0Dist", m_maxRecoD0Dist,
82 "Select only RecoTracks with a maximum d0 distance to the z axis. -1.0 for all tracks",
84 addParam(
"nSameTS", m_nsamets,
85 "Number of identical track segments to be required for matching between HW and SW Neurotrigger",
90 CDCTriggerNeuroDQMModule::~CDCTriggerNeuroDQMModule()
98 void CDCTriggerNeuroDQMModule::defineHisto()
101 TDirectory* oldDir = gDirectory;
102 if (m_histogramDirectoryName !=
"") {
103 oldDir->mkdir(m_histogramDirectoryName.c_str());
104 oldDir->cd(m_histogramDirectoryName.c_str());
109 if (m_unpackedNeuroTracksName !=
"") {
110 m_neuroHWOutZ =
new TH1F(
"NeuroHWOutZ",
111 "z distribution of unpacked neuro tracks; z [cm]",
113 m_neuroHWOutCosTheta =
new TH1F(
"NeuroHWOutCosTheta",
114 "cos theta distribution of unpacked neuro tracks; cos(#theta) ",
116 m_neuroHWOutPhi0 =
new TH1F(
"NeuroHWOutPhi0",
117 "phi distribution of unpacked neuro tracks; #phi [#circ]",
119 m_neuroHWOutInvPt =
new TH1F(
"NeuroHWOutInvPt",
120 "Inverse Pt distribution of unpacked neuro tracks; p_{T}^{-1} [GeV^{-1}]",
122 m_neuroHWOutPt =
new TH1F(
"NeuroHWOutPt",
123 "Pt distribution of unpacked neuro tracks; p_{T} [GeV]",
125 m_neuroHWOutHitPattern =
new TH1F(
"NeuroUnpackedHitPattern",
126 "stereo hit pattern of unpacked neuro tracks; pattern",
128 m_neuroHWOutm_time =
new TH1F(
"NeuroHWOutM_time",
"m_time distribution of unpacked neuro tracks; clock cycle",
130 m_neuroHWOutTrackCount =
new TH1F(
"NeuroHWOutTrackCount",
131 "number of unpacked neuro tracks per event",
133 m_neuroHWSector =
new TH1F(
"NeuroHWSector",
134 "sector of unpacked neuro tracks; sector",
138 m_neuroHWInInvPt =
new TH1F(
"NeuroHWInInvPt",
139 "Inverse Pt distribution from incoming 2dtrack; p_{T}^{-1} [GeV^{-1}]",
141 m_neuroHWInPhi0 =
new TH1F(
"NeuroHWInPhi0",
"Phi0 of incoming 2dtrack; #phi [#circ]",
143 m_neuroHWInm_time =
new TH1F(
"NeuroHWInM_time",
"m_time distribution from incoming 2dtracks; clock cycle",
145 m_neuroHWInTrackCount =
new TH1F(
"NeuroHWInTrackCount",
"number of neuro input 2dtracks per event",
147 m_neuroHWOutVsInTrackCount =
new TH1F(
"NeuroHWOutVsInTrackCount",
148 "number of neuroHWOutTracks - number of 2dinTracks",
150 m_neuroHWInTSID =
new TH1F(
"NeuroHWInTSID",
"ID of incoming track segments",
152 m_neuroHWInTSCount =
new TH1F(
"NeuroHWInTSCount",
" number of TS per event",
154 m_neuroHWSelTSID =
new TH1F(
"NeuroHWSelTSID",
"ID of selected track segments",
156 m_neuroHWSelTSCount =
new TH1F(
"NeuroHWSelTSCount",
"number of selected TS per SL; sl", 9, 0, 9);
158 if (!m_limitedoutput && m_unpacked2DTracksName !=
"") {
159 m_2DHWInTSPrioT_Layer0 =
new TH1F(
"2DHWInTSPrioT_Layer0",
"Priority time of track segments in layer 0",
161 m_2DHWInTSPrioT_Layer2 =
new TH1F(
"2DHWInTSPrioT_Layer2",
"Priority time of track segments in layer 2",
163 m_2DHWInTSPrioT_Layer4 =
new TH1F(
"2DHWInTSPrioT_Layer4",
"Priority time of track segments in layer 4",
165 m_2DHWInTSPrioT_Layer6 =
new TH1F(
"2DHWInTSPrioT_Layer6",
"Priority time of track segments in layer 6",
167 m_2DHWInTSPrioT_Layer8 =
new TH1F(
"2DHWInTSPrioT_Layer8",
"Priority time of track segments in layer 8",
169 m_2DHWInTSFoundT_Layer0 =
new TH1F(
"2DHWInTSFoundT_Layer0",
"Found time of track segments in layer 0",
171 m_2DHWInTSFoundT_Layer2 =
new TH1F(
"2DHWInTSFoundT_Layer2",
"Found time of track segments in layer 2",
173 m_2DHWInTSFoundT_Layer4 =
new TH1F(
"2DHWInTSFoundT_Layer4",
"Found time of track segments in layer 4",
175 m_2DHWInTSFoundT_Layer6 =
new TH1F(
"2DHWInTSFoundT_Layer6",
"Found time of track segments in layer 6",
177 m_2DHWInTSFoundT_Layer8 =
new TH1F(
"2DHWInTSFoundT_Layer8",
"Found time of track segments in layer 8",
181 m_2DHWInTSPrioB_Layer0 =
new TH1F(
"2DHWInTSPrioB_Layer0",
"Priority bits of track segments in layer 0",
183 m_2DHWInTSPrioB_Layer2 =
new TH1F(
"2DHWInTSPrioB_Layer2",
"Priority bits of track segments in layer 2",
185 m_2DHWInTSPrioB_Layer4 =
new TH1F(
"2DHWInTSPrioB_Layer4",
"Priority bits of track segments in layer 4",
187 m_2DHWInTSPrioB_Layer6 =
new TH1F(
"2DHWInTSPrioB_Layer6",
"Priority bits of track segments in layer 6",
189 m_2DHWInTSPrioB_Layer8 =
new TH1F(
"2DHWInTSPrioB_Layer8",
"Priority bits of track segments in layer 8",
191 m_2DHWInTSLR_Layer0 =
new TH1F(
"2DHWInTSLR_Layer0",
"Left/Right of track segments in layer 0",
193 m_2DHWInTSLR_Layer2 =
new TH1F(
"2DHWInTSLR_Layer2",
"Left/Right of track segments in layer 2",
195 m_2DHWInTSLR_Layer4 =
new TH1F(
"2DHWInTSLR_Layer4",
"Left/Right of track segments in layer 4",
197 m_2DHWInTSLR_Layer6 =
new TH1F(
"2DHWInTSLR_Layer6",
"Left/Right of track segments in layer 6",
199 m_2DHWInTSLR_Layer8 =
new TH1F(
"2DHWInTSLR_Layer8",
"Left/Right of track segments in layer 8",
202 if (!m_limitedoutput && m_unpackedNeuroTracksName !=
"") {
204 m_neuroHWOutQuad5Z =
new TH1F(
"NeuroHWOutQuad5Z",
205 "z distribution of neuro tracks; z [cm]",
207 m_neuroHWOutQuad5CosTheta =
new TH1F(
"NeuroHWOutQuad5CosTheta",
208 "cos theta distribution of neuro tracks; cos(#theta) ",
210 m_neuroHWOutQuad5InvPt =
new TH1F(
"NeuroHWOutQuad5InvPt",
211 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
213 m_neuroHWOutQuad5Phi0 =
new TH1F(
"NeuroHWOutQuad5Phi0",
214 "phi distribution from unpacker; #phi [#circ]",
217 m_neuroHWOutQuad0Z =
new TH1F(
"NeuroHWOutQuad0Z",
218 "z distribution of neuro tracks; z [cm]",
220 m_neuroHWOutQuad0CosTheta =
new TH1F(
"NeuroHWOutQuad0CosTheta",
221 "cos theta distribution of neuro tracks; cos(#theta) ",
223 m_neuroHWOutQuad0InvPt =
new TH1F(
"NeuroHWOutQuad0InvPt",
224 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
226 m_neuroHWOutQuad0Phi0 =
new TH1F(
"NeuroHWOutQuad0Phi0",
227 "phi distribution from unpacker; #phi [#circ]",
230 m_neuroHWOutQuad1Z =
new TH1F(
"NeuroHWOutQuad1Z",
231 "z distribution of neuro tracks; z [cm]",
233 m_neuroHWOutQuad1CosTheta =
new TH1F(
"NeuroHWOutQuad1CosTheta",
234 "cos theta distribution of neuro tracks; cos(#theta) ",
236 m_neuroHWOutQuad1Phi0 =
new TH1F(
"NeuroHWOutQuad1Phi0",
237 "phi distribution from unpacker; #phi [#circ]",
239 m_neuroHWOutQuad1InvPt =
new TH1F(
"NeuroHWOutQuad1InvPt",
240 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
243 m_neuroHWOutQuad2Z =
new TH1F(
"NeuroHWOutQuad2Z",
244 "z distribution of neuro tracks; z [cm]",
246 m_neuroHWOutQuad2CosTheta =
new TH1F(
"NeuroHWOutQuad2CosTheta",
247 "cos theta distribution of neuro tracks; cos(#theta) ",
249 m_neuroHWOutQuad2Phi0 =
new TH1F(
"NeuroHWOutQuad2Phi0",
250 "phi distribution from unpacker; #phi [#circ]",
252 m_neuroHWOutQuad2InvPt =
new TH1F(
"NeuroHWOutQuad2InvPt",
253 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
256 m_neuroHWOutQuad3Z =
new TH1F(
"NeuroHWOutQuad3Z",
257 "z distribution of neuro tracks; z [cm]",
259 m_neuroHWOutQuad3CosTheta =
new TH1F(
"NeuroHWOutQuad3CosTheta",
260 "cos theta distribution of neuro tracks; cos(#theta) ",
262 m_neuroHWOutQuad3Phi0 =
new TH1F(
"NeuroHWOutQuad3Phi0",
263 "phi distribution from unpacker; #phi [#circ]",
265 m_neuroHWOutQuad3InvPt =
new TH1F(
"NeuroHWOutQuad3InvPt",
266 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
268 m_neuroHWInTSPrioT_Layer0 =
new TH1F(
"NeuroHWInTSPrioT_Layer0",
"Priority time of track segments in layer 0",
270 m_neuroHWInTSPrioT_Layer1 =
new TH1F(
"NeuroHWInTSPrioT_Layer1",
"Priority time of track segments in layer 1",
272 m_neuroHWInTSPrioT_Layer2 =
new TH1F(
"NeuroHWInTSPrioT_Layer2",
"Priority time of track segments in layer 2",
274 m_neuroHWInTSPrioT_Layer3 =
new TH1F(
"NeuroHWInTSPrioT_Layer3",
"Priority time of track segments in layer 3",
276 m_neuroHWInTSPrioT_Layer4 =
new TH1F(
"NeuroHWInTSPrioT_Layer4",
"Priority time of track segments in layer 4",
278 m_neuroHWInTSPrioT_Layer5 =
new TH1F(
"NeuroHWInTSPrioT_Layer5",
"Priority time of track segments in layer 5",
280 m_neuroHWInTSPrioT_Layer6 =
new TH1F(
"NeuroHWInTSPrioT_Layer6",
"Priority time of track segments in layer 6",
282 m_neuroHWInTSPrioT_Layer7 =
new TH1F(
"NeuroHWInTSPrioT_Layer7",
"Priority time of track segments in layer 7",
284 m_neuroHWInTSPrioT_Layer8 =
new TH1F(
"NeuroHWInTSPrioT_Layer8",
"Priority time of track segments in layer 8",
286 m_neuroHWInTSFoundT_Layer0 =
new TH1F(
"NeuroHWInTSFoundT_Layer0",
"Found time of track segments in layer 0",
288 m_neuroHWInTSFoundT_Layer1 =
new TH1F(
"NeuroHWInTSFoundT_Layer1",
"Found time of track segments in layer 1",
290 m_neuroHWInTSFoundT_Layer2 =
new TH1F(
"NeuroHWInTSFoundT_Layer2",
"Found time of track segments in layer 2",
292 m_neuroHWInTSFoundT_Layer3 =
new TH1F(
"NeuroHWInTSFoundT_Layer3",
"Found time of track segments in layer 3",
294 m_neuroHWInTSFoundT_Layer4 =
new TH1F(
"NeuroHWInTSFoundT_Layer4",
"Found time of track segments in layer 4",
296 m_neuroHWInTSFoundT_Layer5 =
new TH1F(
"NeuroHWInTSFoundT_Layer5",
"Found time of track segments in layer 5",
298 m_neuroHWInTSFoundT_Layer6 =
new TH1F(
"NeuroHWInTSFoundT_Layer6",
"Found time of track segments in layer 6",
300 m_neuroHWInTSFoundT_Layer7 =
new TH1F(
"NeuroHWInTSFoundT_Layer7",
"Found time of track segments in layer 7",
302 m_neuroHWInTSFoundT_Layer8 =
new TH1F(
"NeuroHWInTSFoundT_Layer8",
"Found time of track segments in layer 8",
306 m_neuroHWInTSPrioB_Layer0 =
new TH1F(
"NeuroHWInTSPrioB_Layer0",
"Priority bits of track segments in layer 0",
308 m_neuroHWInTSPrioB_Layer1 =
new TH1F(
"NeuroHWInTSPrioB_Layer1",
"Priority bits of track segments in layer 1",
310 m_neuroHWInTSPrioB_Layer2 =
new TH1F(
"NeuroHWInTSPrioB_Layer2",
"Priority bits of track segments in layer 2",
312 m_neuroHWInTSPrioB_Layer3 =
new TH1F(
"NeuroHWInTSPrioB_Layer3",
"Priority bits of track segments in layer 3",
314 m_neuroHWInTSPrioB_Layer4 =
new TH1F(
"NeuroHWInTSPrioB_Layer4",
"Priority bits of track segments in layer 4",
316 m_neuroHWInTSPrioB_Layer5 =
new TH1F(
"NeuroHWInTSPrioB_Layer5",
"Priority bits of track segments in layer 5",
318 m_neuroHWInTSPrioB_Layer6 =
new TH1F(
"NeuroHWInTSPrioB_Layer6",
"Priority bits of track segments in layer 6",
320 m_neuroHWInTSPrioB_Layer7 =
new TH1F(
"NeuroHWInTSPrioB_Layer7",
"Priority bits of track segments in layer 7",
322 m_neuroHWInTSPrioB_Layer8 =
new TH1F(
"NeuroHWInTSPrioB_Layer8",
"Priority bits of track segments in layer 8",
326 m_neuroHWInTSLR_Layer0 =
new TH1F(
"NeuroHWInTSLR_Layer0",
"Left/Right of track segments in layer 0",
328 m_neuroHWInTSLR_Layer1 =
new TH1F(
"NeuroHWInTSLR_Layer1",
"Left/Right of track segments in layer 1",
330 m_neuroHWInTSLR_Layer2 =
new TH1F(
"NeuroHWInTSLR_Layer2",
"Left/Right of track segments in layer 2",
332 m_neuroHWInTSLR_Layer3 =
new TH1F(
"NeuroHWInTSLR_Layer3",
"Left/Right of track segments in layer 3",
334 m_neuroHWInTSLR_Layer4 =
new TH1F(
"NeuroHWInTSLR_Layer4",
"Left/Right of track segments in layer 4",
336 m_neuroHWInTSLR_Layer5 =
new TH1F(
"NeuroHWInTSLR_Layer5",
"Left/Right of track segments in layer 5",
338 m_neuroHWInTSLR_Layer6 =
new TH1F(
"NeuroHWInTSLR_Layer6",
"Left/Right of track segments in layer 6",
340 m_neuroHWInTSLR_Layer7 =
new TH1F(
"NeuroHWInTSLR_Layer7",
"Left/Right of track segments in layer 7",
342 m_neuroHWInTSLR_Layer8 =
new TH1F(
"NeuroHWInTSLR_Layer8",
"Left/Right of track segments in layer 8",
344 m_neuroHWSelTSPrioT_Layer0 =
new TH1F(
"NeuroHWSelTSPrioT_Layer0",
"Priority time of track segments in layer 0",
346 m_neuroHWSelTSPrioT_Layer1 =
new TH1F(
"NeuroHWSelTSPrioT_Layer1",
"Priority time of track segments in layer 1",
348 m_neuroHWSelTSPrioT_Layer2 =
new TH1F(
"NeuroHWSelTSPrioT_Layer2",
"Priority time of track segments in layer 2",
350 m_neuroHWSelTSPrioT_Layer3 =
new TH1F(
"NeuroHWSelTSPrioT_Layer3",
"Priority time of track segments in layer 3",
352 m_neuroHWSelTSPrioT_Layer4 =
new TH1F(
"NeuroHWSelTSPrioT_Layer4",
"Priority time of track segments in layer 4",
354 m_neuroHWSelTSPrioT_Layer5 =
new TH1F(
"NeuroHWSelTSPrioT_Layer5",
"Priority time of track segments in layer 5",
356 m_neuroHWSelTSPrioT_Layer6 =
new TH1F(
"NeuroHWSelTSPrioT_Layer6",
"Priority time of track segments in layer 6",
358 m_neuroHWSelTSPrioT_Layer7 =
new TH1F(
"NeuroHWSelTSPrioT_Layer7",
"Priority time of track segments in layer 7",
360 m_neuroHWSelTSPrioT_Layer8 =
new TH1F(
"NeuroHWSelTSPrioT_Layer8",
"Priority time of track segments in layer 8",
362 m_neuroHWSelTSFoundT_Layer0 =
new TH1F(
"NeuroHWSelTSFoundT_Layer0",
363 "First found time of selected TS - found time of Neuro Track in SL 0",
365 m_neuroHWSelTSFoundT_Layer1 =
new TH1F(
"NeuroHWSelTSFoundT_Layer1",
366 "First found time of selected TS - found time of Neuro Track in SL 1",
368 m_neuroHWSelTSFoundT_Layer2 =
new TH1F(
"NeuroHWSelTSFoundT_Layer2",
369 "First found time of selected TS - found time of Neuro Track in SL 2",
371 m_neuroHWSelTSFoundT_Layer3 =
new TH1F(
"NeuroHWSelTSFoundT_Layer3",
372 "First found time of selected TS - found time of Neuro Track in SL 3",
374 m_neuroHWSelTSFoundT_Layer4 =
new TH1F(
"NeuroHWSelTSFoundT_Layer4",
375 "First found time of selected TS - found time of Neuro Track in SL 4",
377 m_neuroHWSelTSFoundT_Layer5 =
new TH1F(
"NeuroHWSelTSFoundT_Layer5",
378 "First found time of selected TS - found time of Neuro Track in SL 5",
380 m_neuroHWSelTSFoundT_Layer6 =
new TH1F(
"NeuroHWSelTSFoundT_Layer6",
381 "First found time of selected TS - found time of Neuro Track in SL 6",
383 m_neuroHWSelTSFoundT_Layer7 =
new TH1F(
"NeuroHWSelTSFoundT_Layer7",
384 "First found time of selected TS - found time of Neuro Track in SL 7",
386 m_neuroHWSelTSFoundT_Layer8 =
new TH1F(
"NeuroHWSelTSFoundT_Layer8",
387 "First found time of selected TS - found time of Neuro Track in SL 8",
391 m_neuroHWSelTSPrioB_Layer0 =
new TH1F(
"NeuroHWSelTSPrioB_Layer0",
"Priority bits of track segments in layer 0",
393 m_neuroHWSelTSPrioB_Layer1 =
new TH1F(
"NeuroHWSelTSPrioB_Layer1",
"Priority bits of track segments in layer 1",
395 m_neuroHWSelTSPrioB_Layer2 =
new TH1F(
"NeuroHWSelTSPrioB_Layer2",
"Priority bits of track segments in layer 2",
397 m_neuroHWSelTSPrioB_Layer3 =
new TH1F(
"NeuroHWSelTSPrioB_Layer3",
"Priority bits of track segments in layer 3",
399 m_neuroHWSelTSPrioB_Layer4 =
new TH1F(
"NeuroHWSelTSPrioB_Layer4",
"Priority bits of track segments in layer 4",
401 m_neuroHWSelTSPrioB_Layer5 =
new TH1F(
"NeuroHWSelTSPrioB_Layer5",
"Priority bits of track segments in layer 5",
403 m_neuroHWSelTSPrioB_Layer6 =
new TH1F(
"NeuroHWSelTSPrioB_Layer6",
"Priority bits of track segments in layer 6",
405 m_neuroHWSelTSPrioB_Layer7 =
new TH1F(
"NeuroHWSelTSPrioB_Layer7",
"Priority bits of track segments in layer 7",
407 m_neuroHWSelTSPrioB_Layer8 =
new TH1F(
"NeuroHWSelTSPrioB_Layer8",
"Priority bits of track segments in layer 8",
411 m_neuroHWSelTSLR_Layer0 =
new TH1F(
"NeuroHWSelTSLR_Layer0",
"Left/Right of track segments in layer 0",
413 m_neuroHWSelTSLR_Layer1 =
new TH1F(
"NeuroHWSelTSLR_Layer1",
"Left/Right of track segments in layer 1",
415 m_neuroHWSelTSLR_Layer2 =
new TH1F(
"NeuroHWSelTSLR_Layer2",
"Left/Right of track segments in layer 2",
417 m_neuroHWSelTSLR_Layer3 =
new TH1F(
"NeuroHWSelTSLR_Layer3",
"Left/Right of track segments in layer 3",
419 m_neuroHWSelTSLR_Layer4 =
new TH1F(
"NeuroHWSelTSLR_Layer4",
"Left/Right of track segments in layer 4",
421 m_neuroHWSelTSLR_Layer5 =
new TH1F(
"NeuroHWSelTSLR_Layer5",
"Left/Right of track segments in layer 5",
423 m_neuroHWSelTSLR_Layer6 =
new TH1F(
"NeuroHWSelTSLR_Layer6",
"Left/Right of track segments in layer 6",
425 m_neuroHWSelTSLR_Layer7 =
new TH1F(
"NeuroHWSelTSLR_Layer7",
"Left/Right of track segments in layer 7",
427 m_neuroHWSelTSLR_Layer8 =
new TH1F(
"NeuroHWSelTSLR_Layer8",
"Left/Right of track segments in layer 8",
429 m_neuroHWInputID_Layer0 =
new TH1F(
"NeuroHWInputID_Layer0",
430 "unpacked id input in layer 0; id",
432 m_neuroHWInputT_Layer0 =
new TH1F(
"NeuroHWInputT_Layer0",
433 "unpacked time input in layer 0; time",
435 m_neuroHWInputAlpha_Layer0 =
new TH1F(
"NeuroHWInputAlpha_Layer0",
436 "unpacked alpha input in layer 0; alpha",
438 m_neuroHWInputID_Layer1 =
new TH1F(
"NeuroHWInputID_Layer1",
439 "unpacked id input in layer 1; id",
441 m_neuroHWInputT_Layer1 =
new TH1F(
"NeuroHWInputT_Layer1",
442 "unpacked time input in layer 1; time",
444 m_neuroHWInputAlpha_Layer1 =
new TH1F(
"NeuroHWInputAlpha_Layer1",
445 "unpacked alpha input in layer 1; alpha",
447 m_neuroHWInputID_Layer2 =
new TH1F(
"NeuroHWInputID_Layer2",
448 "unpacked id input in layer 2; id",
450 m_neuroHWInputT_Layer2 =
new TH1F(
"NeuroHWInputT_Layer2",
451 "unpacked time input in layer 2; time",
453 m_neuroHWInputAlpha_Layer2 =
new TH1F(
"NeuroHWInputAlpha_Layer2",
454 "unpacked alpha input in layer 2; alpha",
456 m_neuroHWInputID_Layer3 =
new TH1F(
"NeuroHWInputID_Layer3",
457 "unpacked id input in layer 3; id",
459 m_neuroHWInputT_Layer3 =
new TH1F(
"NeuroHWInputT_Layer3",
460 "unpacked time input in layer 3; time",
462 m_neuroHWInputAlpha_Layer3 =
new TH1F(
"NeuroHWInputAlpha_Layer3",
463 "unpacked alpha input in layer 3; alpha",
465 m_neuroHWInputID_Layer4 =
new TH1F(
"NeuroHWInputID_Layer4",
466 "unpacked id input in layer 4; id",
468 m_neuroHWInputT_Layer4 =
new TH1F(
"NeuroHWInputT_Layer4",
469 "unpacked time input in layer 4; time",
471 m_neuroHWInputAlpha_Layer4 =
new TH1F(
"NeuroHWInputAlpha_Layer4",
472 "unpacked alpha input in layer 4; alpha",
474 m_neuroHWInputID_Layer5 =
new TH1F(
"NeuroHWInputID_Layer5",
475 "unpacked id input in layer 5; id",
477 m_neuroHWInputT_Layer5 =
new TH1F(
"NeuroHWInputT_Layer5",
478 "unpacked time input in layer 5; time",
480 m_neuroHWInputAlpha_Layer5 =
new TH1F(
"NeuroHWInputAlpha_Layer5",
481 "unpacked alpha input in layer 5; alpha",
483 m_neuroHWInputID_Layer6 =
new TH1F(
"NeuroHWInputID_Layer6",
484 "unpacked id input in layer 6; id",
486 m_neuroHWInputT_Layer6 =
new TH1F(
"NeuroHWInputT_Layer6",
487 "unpacked time input in layer 6; time",
489 m_neuroHWInputAlpha_Layer6 =
new TH1F(
"NeuroHWInputAlpha_Layer6",
490 "unpacked alpha input in layer 6; alpha",
492 m_neuroHWInputID_Layer7 =
new TH1F(
"NeuroHWInputID_Layer7",
493 "unpacked id input in layer 7; id",
495 m_neuroHWInputT_Layer7 =
new TH1F(
"NeuroHWInputT_Layer7",
496 "unpacked time input in layer 7; time",
498 m_neuroHWInputAlpha_Layer7 =
new TH1F(
"NeuroHWInputAlpha_Layer7",
499 "unpacked alpha input in layer 7; alpha",
501 m_neuroHWInputID_Layer8 =
new TH1F(
"NeuroHWInputID_Layer8",
502 "unpacked id input in layer 8; id",
504 m_neuroHWInputT_Layer8 =
new TH1F(
"NeuroHWInputT_Layer8",
505 "unpacked time input in layer 8; time",
507 m_neuroHWInputAlpha_Layer8 =
new TH1F(
"NeuroHWInputAlpha_Layer8",
508 "unpacked alpha input in layer 8; alpha",
511 if (m_unpacked2DTracksName !=
"") {
512 m_2DHWOutInvPt =
new TH1F(
"2DHWOutInvPt",
513 "Inverse Pt of 2dtracks; p_{T}^{-1} [GeV^{-1}]",
515 m_2DHWOutPhi0 =
new TH1F(
"2DHWOutPhi0",
"Phi0 of 2dtracks; #phi [#circ]",
517 m_2DHWOutm_time =
new TH1F(
"2DHWOutM_time",
"m_time of 2dtracks; clock cycle",
519 m_2DHWOutTrackCount =
new TH1F(
"2DHWOutTrackCount",
"number of 2dtracks per event", 20, 0, 20);
520 m_neuroHWInVs2DOutTrackCount =
new TH1F(
"NeuroHWInVs2DOutTrackCount",
"neuro in tracks - 2d out tracks",
524 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
525 m_neuroSWOutZ =
new TH1F(
"NeuroSWOutZ",
526 "z distribution from simulation, hw TS hw 2D; z [cm]",
528 m_neuroSWOutCosTheta =
new TH1F(
"NeuroSWOutCosTheta",
529 "cos theta distribution from simulation, hw TS hw 2D; cos(#theta) ",
531 m_neuroSWOutInvPt =
new TH1F(
"NeuroSWOutInvPt",
532 "Inverse Pt distribution from simulation, hw TS hw 2D; p_{T}^{-1} [GeV^{-1}]",
534 m_neuroSWOutPhi0 =
new TH1F(
"NeuroSWOutPhi0",
535 "phi distribution from simulation, hw TS hw 2D; #phi [#circ]",
537 m_neuroSWOutHitPattern =
new TH1F(
"NeuroSWOutHitPattern",
538 "stereo hit pattern of simulated neuro tracks, hw TS hw 2D; pattern",
540 m_neuroSWOutTrackCount =
new TH1F(
"NeuroSWOutTrackCount",
541 "number of neuro tracks per event from simulation, hw TS hw 2D",
543 m_neuroSWSector =
new TH1F(
"NeuroSWSector",
544 "sector of simulated neuro tracks, hw TS hw 2D; sector",
547 m_neuroSWSelTSID =
new TH1F(
"NeuroSWSelTSID",
"ID of selected track segments",
549 m_neuroSWSelTSCount =
new TH1F(
"NeuroSWSelTSCount",
"number of selected TS per SL; sl", 9, 0, 9);
550 m_neuroSWSelTSPrioT_Layer0 =
new TH1F(
"NeuroSWSelTSPrioT_Layer0",
"Priority time of track segments in layer 0",
552 m_neuroSWSelTSPrioT_Layer1 =
new TH1F(
"NeuroSWSelTSPrioT_Layer1",
"Priority time of track segments in layer 1",
554 m_neuroSWSelTSPrioT_Layer2 =
new TH1F(
"NeuroSWSelTSPrioT_Layer2",
"Priority time of track segments in layer 2",
556 m_neuroSWSelTSPrioT_Layer3 =
new TH1F(
"NeuroSWSelTSPrioT_Layer3",
"Priority time of track segments in layer 3",
558 m_neuroSWSelTSPrioT_Layer4 =
new TH1F(
"NeuroSWSelTSPrioT_Layer4",
"Priority time of track segments in layer 4",
560 m_neuroSWSelTSPrioT_Layer5 =
new TH1F(
"NeuroSWSelTSPrioT_Layer5",
"Priority time of track segments in layer 5",
562 m_neuroSWSelTSPrioT_Layer6 =
new TH1F(
"NeuroSWSelTSPrioT_Layer6",
"Priority time of track segments in layer 6",
564 m_neuroSWSelTSPrioT_Layer7 =
new TH1F(
"NeuroSWSelTSPrioT_Layer7",
"Priority time of track segments in layer 7",
566 m_neuroSWSelTSPrioT_Layer8 =
new TH1F(
"NeuroSWSelTSPrioT_Layer8",
"Priority time of track segments in layer 8",
568 m_neuroSWSelTSFoundT_Layer0 =
new TH1F(
"NeuroSWSelTSFoundT_Layer0",
569 "First found time of selected TS - found time of Neuro Track in SL 0",
571 m_neuroSWSelTSFoundT_Layer1 =
new TH1F(
"NeuroSWSelTSFoundT_Layer1",
572 "First found time of selected TS - found time of Neuro Track in SL 1",
574 m_neuroSWSelTSFoundT_Layer2 =
new TH1F(
"NeuroSWSelTSFoundT_Layer2",
575 "First found time of selected TS - found time of Neuro Track in SL 2",
577 m_neuroSWSelTSFoundT_Layer3 =
new TH1F(
"NeuroSWSelTSFoundT_Layer3",
578 "First found time of selected TS - found time of Neuro Track in SL 3",
580 m_neuroSWSelTSFoundT_Layer4 =
new TH1F(
"NeuroSWSelTSFoundT_Layer4",
581 "First found time of selected TS - found time of Neuro Track in SL 4",
583 m_neuroSWSelTSFoundT_Layer5 =
new TH1F(
"NeuroSWSelTSFoundT_Layer5",
584 "First found time of selected TS - found time of Neuro Track in SL 5",
586 m_neuroSWSelTSFoundT_Layer6 =
new TH1F(
"NeuroSWSelTSFoundT_Layer6",
587 "First found time of selected TS - found time of Neuro Track in SL 6",
589 m_neuroSWSelTSFoundT_Layer7 =
new TH1F(
"NeuroSWSelTSFoundT_Layer7",
590 "First found time of selected TS - found time of Neuro Track in SL 7",
592 m_neuroSWSelTSFoundT_Layer8 =
new TH1F(
"NeuroSWSelTSFoundT_Layer8",
593 "First found time of selected TS - found time of Neuro Track in SL 8",
597 m_neuroSWSelTSPrioB_Layer0 =
new TH1F(
"NeuroSWSelTSPrioB_Layer0",
"Priority bits of track segments in layer 0",
599 m_neuroSWSelTSPrioB_Layer1 =
new TH1F(
"NeuroSWSelTSPrioB_Layer1",
"Priority bits of track segments in layer 1",
601 m_neuroSWSelTSPrioB_Layer2 =
new TH1F(
"NeuroSWSelTSPrioB_Layer2",
"Priority bits of track segments in layer 2",
603 m_neuroSWSelTSPrioB_Layer3 =
new TH1F(
"NeuroSWSelTSPrioB_Layer3",
"Priority bits of track segments in layer 3",
605 m_neuroSWSelTSPrioB_Layer4 =
new TH1F(
"NeuroSWSelTSPrioB_Layer4",
"Priority bits of track segments in layer 4",
607 m_neuroSWSelTSPrioB_Layer5 =
new TH1F(
"NeuroSWSelTSPrioB_Layer5",
"Priority bits of track segments in layer 5",
609 m_neuroSWSelTSPrioB_Layer6 =
new TH1F(
"NeuroSWSelTSPrioB_Layer6",
"Priority bits of track segments in layer 6",
611 m_neuroSWSelTSPrioB_Layer7 =
new TH1F(
"NeuroSWSelTSPrioB_Layer7",
"Priority bits of track segments in layer 7",
613 m_neuroSWSelTSPrioB_Layer8 =
new TH1F(
"NeuroSWSelTSPrioB_Layer8",
"Priority bits of track segments in layer 8",
617 m_neuroSWSelTSLR_Layer0 =
new TH1F(
"NeuroSWSelTSLR_Layer0",
"Left/Right of track segments in layer 0",
619 m_neuroSWSelTSLR_Layer1 =
new TH1F(
"NeuroSWSelTSLR_Layer1",
"Left/Right of track segments in layer 1",
621 m_neuroSWSelTSLR_Layer2 =
new TH1F(
"NeuroSWSelTSLR_Layer2",
"Left/Right of track segments in layer 2",
623 m_neuroSWSelTSLR_Layer3 =
new TH1F(
"NeuroSWSelTSLR_Layer3",
"Left/Right of track segments in layer 3",
625 m_neuroSWSelTSLR_Layer4 =
new TH1F(
"NeuroSWSelTSLR_Layer4",
"Left/Right of track segments in layer 4",
627 m_neuroSWSelTSLR_Layer5 =
new TH1F(
"NeuroSWSelTSLR_Layer5",
"Left/Right of track segments in layer 5",
629 m_neuroSWSelTSLR_Layer6 =
new TH1F(
"NeuroSWSelTSLR_Layer6",
"Left/Right of track segments in layer 6",
631 m_neuroSWSelTSLR_Layer7 =
new TH1F(
"NeuroSWSelTSLR_Layer7",
"Left/Right of track segments in layer 7",
633 m_neuroSWSelTSLR_Layer8 =
new TH1F(
"NeuroSWSelTSLR_Layer8",
"Left/Right of track segments in layer 8",
636 m_neuroSWInputID_Layer0 =
new TH1F(
"NeuroSWInputID_Layer0",
637 "simulated id input in layer 0; id",
639 m_neuroSWInputT_Layer0 =
new TH1F(
"NeuroSWInputT_Layer0",
640 "simulated time input in layer 0; time",
642 m_neuroSWInputAlpha_Layer0 =
new TH1F(
"NeuroSWInputAlpha_Layer0",
643 "simulated alpha input in layer 0; alpha",
645 m_neuroSWInputID_Layer1 =
new TH1F(
"NeuroSWInputID_Layer1",
646 "simulated id input in layer 1; id",
648 m_neuroSWInputT_Layer1 =
new TH1F(
"NeuroSWInputT_Layer1",
649 "simulated time input in layer 1; time",
651 m_neuroSWInputAlpha_Layer1 =
new TH1F(
"NeuroSWInputAlpha_Layer1",
652 "simulated alpha input in layer 1; alpha",
654 m_neuroSWInputID_Layer2 =
new TH1F(
"NeuroSWInputID_Layer2",
655 "simulated id input in layer 2; id",
657 m_neuroSWInputT_Layer2 =
new TH1F(
"NeuroSWInputT_Layer2",
658 "simulated time input in layer 2; time",
660 m_neuroSWInputAlpha_Layer2 =
new TH1F(
"NeuroSWInputAlpha_Layer2",
661 "simulated alpha input in layer 2; alpha",
663 m_neuroSWInputID_Layer3 =
new TH1F(
"NeuroSWInputID_Layer3",
664 "simulated id input in layer 3; id",
666 m_neuroSWInputT_Layer3 =
new TH1F(
"NeuroSWInputT_Layer3",
667 "simulated time input in layer 3; time",
669 m_neuroSWInputAlpha_Layer3 =
new TH1F(
"NeuroSWInputAlpha_Layer3",
670 "simulated alpha input in layer 3; alpha",
672 m_neuroSWInputID_Layer4 =
new TH1F(
"NeuroSWInputID_Layer4",
673 "simulated id input in layer 4; id",
675 m_neuroSWInputT_Layer4 =
new TH1F(
"NeuroSWInputT_Layer4",
676 "simulated time input in layer 4; time",
678 m_neuroSWInputAlpha_Layer4 =
new TH1F(
"NeuroSWInputAlpha_Layer4",
679 "simulated alpha input in layer 4; alpha",
681 m_neuroSWInputID_Layer5 =
new TH1F(
"NeuroSWInputID_Layer5",
682 "simulated id input in layer 5; id",
684 m_neuroSWInputT_Layer5 =
new TH1F(
"NeuroSWInputT_Layer5",
685 "simulated time input in layer 5; time",
687 m_neuroSWInputAlpha_Layer5 =
new TH1F(
"NeuroSWInputAlpha_Layer5",
688 "simulated alpha input in layer 5; alpha",
690 m_neuroSWInputID_Layer6 =
new TH1F(
"NeuroSWInputID_Layer6",
691 "simulated id input in layer 6; id",
693 m_neuroSWInputT_Layer6 =
new TH1F(
"NeuroSWInputT_Layer6",
694 "simulated time input in layer 6; time",
696 m_neuroSWInputAlpha_Layer6 =
new TH1F(
"NeuroSWInputAlpha_Layer6",
697 "simulated alpha input in layer 6; alpha",
699 m_neuroSWInputID_Layer7 =
new TH1F(
"NeuroSWInputID_Layer7",
700 "simulated id input in layer 7; id",
702 m_neuroSWInputT_Layer7 =
new TH1F(
"NeuroSWInputT_Layer7",
703 "simulated time input in layer 7; time",
705 m_neuroSWInputAlpha_Layer7 =
new TH1F(
"NeuroSWInputAlpha_Layer7",
706 "simulated alpha input in layer 7; alpha",
708 m_neuroSWInputID_Layer8 =
new TH1F(
"NeuroSWInputID_Layer8",
709 "simulated id input in layer 8; id",
711 m_neuroSWInputT_Layer8 =
new TH1F(
"NeuroSWInputT_Layer8",
712 "simulated time input in layer 8; time",
714 m_neuroSWInputAlpha_Layer8 =
new TH1F(
"NeuroSWInputAlpha_Layer8",
715 "simulated alpha input in layer 8; alpha",
719 if (!m_limitedoutput && m_sim2DTracksSWTSName !=
"") {
721 m_2DSWOutInvPt =
new TH1F(
"2DSWOutInvPt",
722 "Inverse Pt of 2dtracks from simulation, sw TS sw 2D; p_{T}^{-1} [GeV^{-1}]",
724 m_2DSWOutPhi0 =
new TH1F(
"2DSWOutPhi0",
"Phi0 of 2dtracks from simulation, sw TS sw 2D; #phi [#circ]",
726 m_2DSWOutm_time =
new TH1F(
"2DSWOutM_time",
"m_time of 2dtracks from simulation, sw TS sw 2D; clock cycle",
728 m_2DSWOutTrackCount =
new TH1F(
"2DSWOutTrackCount",
"number of 2dtracks per event from simulation, sw TS sw 2D", 20, 0, 20);
731 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
733 m_neuroSWTSSW2DOutZ =
new TH1F(
"NeuroSWTSSW2DOutZ",
734 "z distribution from simulation, sw TS sw 2D; z [cm]",
736 m_neuroSWTSSW2DOutCosTheta =
new TH1F(
"NeuroSWTSSW2DOutCosTheta",
737 "cos theta distribution from simulation, sw TS sw 2D; cos(#theta) ",
739 m_neuroSWTSSW2DOutInvPt =
new TH1F(
"NeuroSWTSSW2DOutInvPt",
740 "Inverse Pt distribution from simulation, sw TS sw 2D; p_{T}^{-1} [GeV^{-1}]",
742 m_neuroSWTSSW2DOutPhi0 =
new TH1F(
"NeuroSWTSSW2DOutPhi0",
743 "phi distribution from simulation, sw TS sw 2D; #phi [#circ]",
745 m_neuroSWTSSW2DOutHitPattern =
new TH1F(
"NeuroSWTSSW2DOutHitPattern",
746 "stereo hit pattern of simulated neuro tracks, sw TS sw 2D; pattern",
748 m_neuroSWTSSW2DOutTrackCount =
new TH1F(
"NeuroSWTSSW2DOutTrackCount",
749 "number of simulated neuro tracks per event, sw TS sw 2D",
751 m_neuroSWTSSW2DSector =
new TH1F(
"NeuroSWTSSW2DSector",
752 "sector of simulated neuro tracks, sw TS sw 2D; sector",
755 m_neuroSWTSSW2DInTSID =
new TH1F(
"NeuroSWTSSW2DInTSID",
"ID of simulated track segments",
757 m_neuroSWTSSW2DInTSCount =
new TH1F(
"NeuroSWTSSW2DInTSCount",
"number of simulated TS per event", 200, 0, 800);
758 m_neuroSWTSSW2DInTSPrioT_Layer0 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer0",
"Priority time of track segments in layer 0",
760 m_neuroSWTSSW2DInTSPrioT_Layer1 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer1",
"Priority time of track segments in layer 1",
762 m_neuroSWTSSW2DInTSPrioT_Layer2 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer2",
"Priority time of track segments in layer 2",
764 m_neuroSWTSSW2DInTSPrioT_Layer3 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer3",
"Priority time of track segments in layer 3",
766 m_neuroSWTSSW2DInTSPrioT_Layer4 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer4",
"Priority time of track segments in layer 4",
768 m_neuroSWTSSW2DInTSPrioT_Layer5 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer5",
"Priority time of track segments in layer 5",
770 m_neuroSWTSSW2DInTSPrioT_Layer6 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer6",
"Priority time of track segments in layer 6",
772 m_neuroSWTSSW2DInTSPrioT_Layer7 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer7",
"Priority time of track segments in layer 7",
774 m_neuroSWTSSW2DInTSPrioT_Layer8 =
new TH1F(
"NeuroSWTSSW2DInTSPrioT_Layer8",
"Priority time of track segments in layer 8",
776 m_neuroSWTSSW2DInTSFoundT_Layer0 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer0",
777 "First found time of selected TS - found time of Neuro Track in SL 0",
779 m_neuroSWTSSW2DInTSFoundT_Layer1 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer1",
780 "First found time of selected TS - found time of Neuro Track in SL 1",
782 m_neuroSWTSSW2DInTSFoundT_Layer2 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer2",
783 "First found time of selected TS - found time of Neuro Track in SL 2",
785 m_neuroSWTSSW2DInTSFoundT_Layer3 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer3",
786 "First found time of selected TS - found time of Neuro Track in SL 3",
788 m_neuroSWTSSW2DInTSFoundT_Layer4 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer4",
789 "First found time of selected TS - found time of Neuro Track in SL 4",
791 m_neuroSWTSSW2DInTSFoundT_Layer5 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer5",
792 "First found time of selected TS - found time of Neuro Track in SL 5",
794 m_neuroSWTSSW2DInTSFoundT_Layer6 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer6",
795 "First found time of selected TS - found time of Neuro Track in SL 6",
797 m_neuroSWTSSW2DInTSFoundT_Layer7 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer7",
798 "First found time of selected TS - found time of Neuro Track in SL 7",
800 m_neuroSWTSSW2DInTSFoundT_Layer8 =
new TH1F(
"NeuroSWTSSW2DInTSFoundT_Layer8",
801 "First found time of selected TS - found time of Neuro Track in SL 8",
805 m_neuroSWTSSW2DInTSPrioB_Layer0 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer0",
"Priority bits of track segments in layer 0",
807 m_neuroSWTSSW2DInTSPrioB_Layer1 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer1",
"Priority bits of track segments in layer 1",
809 m_neuroSWTSSW2DInTSPrioB_Layer2 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer2",
"Priority bits of track segments in layer 2",
811 m_neuroSWTSSW2DInTSPrioB_Layer3 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer3",
"Priority bits of track segments in layer 3",
813 m_neuroSWTSSW2DInTSPrioB_Layer4 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer4",
"Priority bits of track segments in layer 4",
815 m_neuroSWTSSW2DInTSPrioB_Layer5 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer5",
"Priority bits of track segments in layer 5",
817 m_neuroSWTSSW2DInTSPrioB_Layer6 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer6",
"Priority bits of track segments in layer 6",
819 m_neuroSWTSSW2DInTSPrioB_Layer7 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer7",
"Priority bits of track segments in layer 7",
821 m_neuroSWTSSW2DInTSPrioB_Layer8 =
new TH1F(
"NeuroSWTSSW2DInTSPrioB_Layer8",
"Priority bits of track segments in layer 8",
825 m_neuroSWTSSW2DInTSLR_Layer0 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer0",
"Left/Right of track segments in layer 0",
827 m_neuroSWTSSW2DInTSLR_Layer1 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer1",
"Left/Right of track segments in layer 1",
829 m_neuroSWTSSW2DInTSLR_Layer2 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer2",
"Left/Right of track segments in layer 2",
831 m_neuroSWTSSW2DInTSLR_Layer3 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer3",
"Left/Right of track segments in layer 3",
833 m_neuroSWTSSW2DInTSLR_Layer4 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer4",
"Left/Right of track segments in layer 4",
835 m_neuroSWTSSW2DInTSLR_Layer5 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer5",
"Left/Right of track segments in layer 5",
837 m_neuroSWTSSW2DInTSLR_Layer6 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer6",
"Left/Right of track segments in layer 6",
839 m_neuroSWTSSW2DInTSLR_Layer7 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer7",
"Left/Right of track segments in layer 7",
841 m_neuroSWTSSW2DInTSLR_Layer8 =
new TH1F(
"NeuroSWTSSW2DInTSLR_Layer8",
"Left/Right of track segments in layer 8",
846 m_neuroSWTSSW2DSelTSID =
new TH1F(
"NeuroSWTSSW2DSelTSID",
"ID of selected track segments",
848 m_neuroSWTSSW2DSelTSCount =
new TH1F(
"NeuroSWTSSW2DSelTSCount",
"number of selected TS per SL; sl", 9, 0, 9);
849 m_neuroSWTSSW2DSelTSPrioT_Layer0 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer0",
"Priority time of track segments in layer 0",
851 m_neuroSWTSSW2DSelTSPrioT_Layer1 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer1",
"Priority time of track segments in layer 1",
853 m_neuroSWTSSW2DSelTSPrioT_Layer2 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer2",
"Priority time of track segments in layer 2",
855 m_neuroSWTSSW2DSelTSPrioT_Layer3 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer3",
"Priority time of track segments in layer 3",
857 m_neuroSWTSSW2DSelTSPrioT_Layer4 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer4",
"Priority time of track segments in layer 4",
859 m_neuroSWTSSW2DSelTSPrioT_Layer5 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer5",
"Priority time of track segments in layer 5",
861 m_neuroSWTSSW2DSelTSPrioT_Layer6 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer6",
"Priority time of track segments in layer 6",
863 m_neuroSWTSSW2DSelTSPrioT_Layer7 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer7",
"Priority time of track segments in layer 7",
865 m_neuroSWTSSW2DSelTSPrioT_Layer8 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioT_Layer8",
"Priority time of track segments in layer 8",
867 m_neuroSWTSSW2DSelTSFoundT_Layer0 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer0",
868 "First found time of selected TS - found time of Neuro Track in SL 0",
870 m_neuroSWTSSW2DSelTSFoundT_Layer1 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer1",
871 "First found time of selected TS - found time of Neuro Track in SL 1",
873 m_neuroSWTSSW2DSelTSFoundT_Layer2 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer2",
874 "First found time of selected TS - found time of Neuro Track in SL 2",
876 m_neuroSWTSSW2DSelTSFoundT_Layer3 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer3",
877 "First found time of selected TS - found time of Neuro Track in SL 3",
879 m_neuroSWTSSW2DSelTSFoundT_Layer4 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer4",
880 "First found time of selected TS - found time of Neuro Track in SL 4",
882 m_neuroSWTSSW2DSelTSFoundT_Layer5 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer5",
883 "First found time of selected TS - found time of Neuro Track in SL 5",
885 m_neuroSWTSSW2DSelTSFoundT_Layer6 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer6",
886 "First found time of selected TS - found time of Neuro Track in SL 6",
888 m_neuroSWTSSW2DSelTSFoundT_Layer7 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer7",
889 "First found time of selected TS - found time of Neuro Track in SL 7",
891 m_neuroSWTSSW2DSelTSFoundT_Layer8 =
new TH1F(
"NeuroSWTSSW2DSelTSFoundT_Layer8",
892 "First found time of selected TS - found time of Neuro Track in SL 8",
896 m_neuroSWTSSW2DSelTSPrioB_Layer0 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer0",
"Priority bits of track segments in layer 0",
898 m_neuroSWTSSW2DSelTSPrioB_Layer1 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer1",
"Priority bits of track segments in layer 1",
900 m_neuroSWTSSW2DSelTSPrioB_Layer2 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer2",
"Priority bits of track segments in layer 2",
902 m_neuroSWTSSW2DSelTSPrioB_Layer3 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer3",
"Priority bits of track segments in layer 3",
904 m_neuroSWTSSW2DSelTSPrioB_Layer4 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer4",
"Priority bits of track segments in layer 4",
906 m_neuroSWTSSW2DSelTSPrioB_Layer5 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer5",
"Priority bits of track segments in layer 5",
908 m_neuroSWTSSW2DSelTSPrioB_Layer6 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer6",
"Priority bits of track segments in layer 6",
910 m_neuroSWTSSW2DSelTSPrioB_Layer7 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer7",
"Priority bits of track segments in layer 7",
912 m_neuroSWTSSW2DSelTSPrioB_Layer8 =
new TH1F(
"NeuroSWTSSW2DSelTSPrioB_Layer8",
"Priority bits of track segments in layer 8",
916 m_neuroSWTSSW2DSelTSLR_Layer0 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer0",
"Left/Right of track segments in layer 0",
918 m_neuroSWTSSW2DSelTSLR_Layer1 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer1",
"Left/Right of track segments in layer 1",
920 m_neuroSWTSSW2DSelTSLR_Layer2 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer2",
"Left/Right of track segments in layer 2",
922 m_neuroSWTSSW2DSelTSLR_Layer3 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer3",
"Left/Right of track segments in layer 3",
924 m_neuroSWTSSW2DSelTSLR_Layer4 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer4",
"Left/Right of track segments in layer 4",
926 m_neuroSWTSSW2DSelTSLR_Layer5 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer5",
"Left/Right of track segments in layer 5",
928 m_neuroSWTSSW2DSelTSLR_Layer6 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer6",
"Left/Right of track segments in layer 6",
930 m_neuroSWTSSW2DSelTSLR_Layer7 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer7",
"Left/Right of track segments in layer 7",
932 m_neuroSWTSSW2DSelTSLR_Layer8 =
new TH1F(
"NeuroSWTSSW2DSelTSLR_Layer8",
"Left/Right of track segments in layer 8",
934 m_neuroSWTSSW2DInputID_Layer0 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer0",
935 "simulated id input in layer 0; id",
937 m_neuroSWTSSW2DInputT_Layer0 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer0",
938 "simulated time input in layer 0; time",
940 m_neuroSWTSSW2DInputAlpha_Layer0 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer0",
941 "simulated alpha input in layer 0; alpha",
943 m_neuroSWTSSW2DInputID_Layer1 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer1",
944 "simulated id input in layer 1; id",
946 m_neuroSWTSSW2DInputT_Layer1 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer1",
947 "simulated time input in layer 1; time",
949 m_neuroSWTSSW2DInputAlpha_Layer1 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer1",
950 "simulated alpha input in layer 1; alpha",
952 m_neuroSWTSSW2DInputID_Layer2 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer2",
953 "simulated id input in layer 2; id",
955 m_neuroSWTSSW2DInputT_Layer2 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer2",
956 "simulated time input in layer 2; time",
958 m_neuroSWTSSW2DInputAlpha_Layer2 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer2",
959 "simulated alpha input in layer 2; alpha",
961 m_neuroSWTSSW2DInputID_Layer3 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer3",
962 "simulated id input in layer 3; id",
964 m_neuroSWTSSW2DInputT_Layer3 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer3",
965 "simulated time input in layer 3; time",
967 m_neuroSWTSSW2DInputAlpha_Layer3 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer3",
968 "simulated alpha input in layer 3; alpha",
970 m_neuroSWTSSW2DInputID_Layer4 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer4",
971 "simulated id input in layer 4; id",
973 m_neuroSWTSSW2DInputT_Layer4 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer4",
974 "simulated time input in layer 4; time",
976 m_neuroSWTSSW2DInputAlpha_Layer4 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer4",
977 "simulated alpha input in layer 4; alpha",
979 m_neuroSWTSSW2DInputID_Layer5 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer5",
980 "simulated id input in layer 5; id",
982 m_neuroSWTSSW2DInputT_Layer5 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer5",
983 "simulated time input in layer 5; time",
985 m_neuroSWTSSW2DInputAlpha_Layer5 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer5",
986 "simulated alpha input in layer 5; alpha",
988 m_neuroSWTSSW2DInputID_Layer6 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer6",
989 "simulated id input in layer 6; id",
991 m_neuroSWTSSW2DInputT_Layer6 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer6",
992 "simulated time input in layer 6; time",
994 m_neuroSWTSSW2DInputAlpha_Layer6 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer6",
995 "simulated alpha input in layer 6; alpha",
997 m_neuroSWTSSW2DInputID_Layer7 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer7",
998 "simulated id input in layer 7; id",
1000 m_neuroSWTSSW2DInputT_Layer7 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer7",
1001 "simulated time input in layer 7; time",
1003 m_neuroSWTSSW2DInputAlpha_Layer7 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer7",
1004 "simulated alpha input in layer 7; alpha",
1006 m_neuroSWTSSW2DInputID_Layer8 =
new TH1F(
"NeuroSWTSSW2DInputID_Layer8",
1007 "simulated id input in layer 8; id",
1009 m_neuroSWTSSW2DInputT_Layer8 =
new TH1F(
"NeuroSWTSSW2DInputT_Layer8",
1010 "simulated time input in layer 8; time",
1012 m_neuroSWTSSW2DInputAlpha_Layer8 =
new TH1F(
"NeuroSWTSSW2DInputAlpha_Layer8",
1013 "simulated alpha input in layer 8; alpha",
1019 if (!m_limitedoutput && m_unpackedNeuroTracksName !=
"" && m_simNeuroTracksName !=
"") {
1020 m_neuroDeltaZ =
new TH1F(
"NeuroDeltaZ",
1021 "difference between unpacked and simulated neuro z; #Delta z [cm]",
1023 m_neuroDeltaTheta =
new TH1F(
"NeuroDeltaTheta",
1024 "difference between unpacked and simulated neuro theta; #Delta #theta [#circ]",
1026 m_neuroScatterZ =
new TH2F(
"NeuroScatterZ",
1027 "unpacked z vs TSIM; hw z [cm]; sw z [cm]",
1028 100, -150, 150, 100, -150, 150);
1029 m_neuroScatterTheta =
new TH2F(
"NeuroScatterTheta",
1030 "unpacked theta vs TSIM; hw #theta [#circ]; sw #theta [#circ]",
1031 100, 0, 270, 100, 0, 270);
1033 m_neuroDeltaInputID =
new TH1F(
"NeuroDeltaInputID",
1034 "difference between unpacked and simulated ID input; #Delta ID",
1036 m_neuroDeltaInputT =
new TH1F(
"NeuroDeltaInputT",
1037 "difference between unpacked and simulated time input; #Delta t",
1039 m_neuroDeltaInputAlpha =
new TH1F(
"NeuroDeltaInputAlpha",
1040 "difference between unpacked and simulated alpha input; #Delta alpha",
1042 m_neuroDeltaTSID =
new TH1F(
"NeuroDeltaTSID",
1043 "difference between unpacked and simulated tsid; #Delta TSID",
1045 m_neuroDeltaSector =
new TH1F(
"NeuroDeltaSector",
1046 "difference between unpacked and simulated sector; #Delta sector",
1048 m_simSameTS =
new TH1F(
"NeuroSimSameTS",
1049 "number of TS selected in both, unpacked and TSIM tracks",
1051 m_simDiffTS =
new TH1F(
"NeuroSimDiffTS",
1052 "number of TS selcted in TSIM but not in unpacker",
1056 if (m_recoTracksName !=
"") {
1058 m_RecoZ =
new TH1F(
"RecoZ",
1059 "z distribution of reconstructed tracks;z [cm]",
1061 m_RecoCosTheta =
new TH1F(
"RecoCosTheta",
1062 "cos theta distribution of reconstructed tracks; cos(#theta) ",
1064 m_RecoInvPt =
new TH1F(
"RecoInvPt",
1065 "Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1067 m_RecoPhi =
new TH1F(
"RecoPhi",
1068 "phi distribution of reconstructed tracks ; #phi [#circ]",
1070 m_RecoD0 =
new TH1F(
"RecoD0",
1071 "d0 distribution of reconstructed tracks ; d_{0} [cm]",
1073 m_RecoTrackCount =
new TH1F(
"RecoTrackCount",
1074 "number of reconstructed tracks per event",
1077 if (m_recoTracksName !=
"" && m_unpackedNeuroTracksName !=
"") {
1079 m_RecoHWZ =
new TH1F(
"RecoHWZ",
1080 "hw matched z distribution of reconstructed tracks; z [cm]",
1082 m_RecoHWCosTheta =
new TH1F(
"RecoHWCosTheta",
1083 "hw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1085 m_RecoHWInvPt =
new TH1F(
"RecoHWInvPt",
1086 "hw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1088 m_RecoHWPhi =
new TH1F(
"RecoHWPhi",
1089 "hw matched phi distribution of reconstructed tracks; #phi [#circ]",
1091 m_RecoHWD0 =
new TH1F(
"RecoHWD0",
1092 "hw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1095 m_neuroRecoHWOutZ =
new TH1F(
"NeuroRecoHWOutZ",
1096 "reco matched z distribution of unpacked neuro tracks; z [cm]",
1098 m_neuroRecoHWOutCosTheta =
new TH1F(
"NeuroRecoHWOutCosTheta",
1099 "reco matched cos theta distribution of unpacked neuro tracks; cos(#theta) ",
1101 m_neuroRecoHWOutInvPt =
new TH1F(
"NeuroRecoHWOutInvPt",
1102 "reco matched Pt distribution of unpacked neuro tracks; p_{T}^{-1} [GeV^{-1}]",
1104 m_neuroRecoHWOutPhi0 =
new TH1F(
"NeuroRecoHWOutPhi0",
1105 "reco matched phi distribution of unpacked neuro tracks; #phi [#circ]",
1107 m_neuroRecoHWOutHitPattern =
new TH1F(
"NeuroRecoUnpackedHitPattern",
1108 "reco matched stereo hit pattern of unpacked neuro tracks; pattern",
1110 m_neuroRecoHWOutTrackCount =
new TH1F(
"NeuroRecoHWOutTrackCount",
1111 "reco matched number of unpacked neuro tracks per event",
1113 m_neuroRecoHWSector =
new TH1F(
"NeuroRecoHWSector",
1114 "reco matched sector of unpacked neuro tracks; sector",
1118 m_DeltaRecoHWZ =
new TH1F(
"DeltaRecoHWZ",
1119 "difference between reconstructed and unpacked neuro z; #Delta z [cm]",
1121 m_DeltaRecoHWCosTheta =
new TH1F(
"DeltaRecoHWCosTheta",
1122 "difference between reconstructed and unpacked neuro cos(theta); #Delta cos(#theta)",
1124 m_DeltaRecoHWInvPt =
new TH1F(
"DeltaRecoHWInvPt",
1125 "difference between reconstructed and unpacked neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1127 m_DeltaRecoHWPhi =
new TH1F(
"DeltaRecoHWPhi",
1128 "difference between reconstructed and unpacked neuro phi; #Delta #phi [#circ]",
1131 if (!m_limitedoutput && m_recoTracksName !=
"" && m_unpackedNeuroTracksName !=
"") {
1132 m_RecoHWZScatter =
new TH2F(
"RecoHWZScatter",
1133 "hw matched reconstruction; reco z [cm]; hw z [cm]",
1134 100, -150, 150, 100, -150, 150);
1139 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
1141 m_RecoSWZ =
new TH1F(
"RecoSWZ",
1142 "sw matched z distribution of reconstructed tracks; z [cm]",
1144 m_RecoSWCosTheta =
new TH1F(
"RecoSWCosTheta",
1145 "sw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1147 m_RecoSWInvPt =
new TH1F(
"RecoSWInvPt",
1148 "sw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1150 m_RecoSWPhi =
new TH1F(
"RecoSWPhi",
1151 "sw matched phi distribution of reconstructed tracks ; #phi [#circ]",
1153 m_RecoSWD0 =
new TH1F(
"RecoSWD0",
1154 "sw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1156 m_RecoSWZScatter =
new TH2F(
"RecoSWZScatter",
1157 "sw matched reconstruction; reco z [cm]; sw z [cm]",
1158 100, -150, 150, 100, -150, 150);
1162 m_neuroRecoSWOutZ =
new TH1F(
"NeuroRecoSWOutZ",
1163 "reco matched z distribution from simulation; z [cm]",
1165 m_neuroRecoSWOutCosTheta =
new TH1F(
"NeuroRecoSWOutCosTheta",
1166 "reco matched cos theta distribution from simulation; cos(#theta) ",
1168 m_neuroRecoSWOutInvPt =
new TH1F(
"NeuroRecoSWOutInvPt",
1169 "reco matched Pt distribution from simulation; p_{T}^{-1} [GeV^{-1}]",
1171 m_neuroRecoSWOutPhi0 =
new TH1F(
"NeuroRecoSWOutPhi0",
1172 "reco matched phi distribution from simulation; #phi [#circ]",
1174 m_neuroRecoSWOutHitPattern =
new TH1F(
"NeuroRecoSWHitPattern",
1175 "reco matched stereo hit pattern from simulation; pattern",
1177 m_neuroRecoSWOutTrackCount =
new TH1F(
"NeuroRecoSWOutTrackCount",
1178 "reco matched number of SW neuro tracks per event",
1180 m_neuroRecoSWSector =
new TH1F(
"NeuroRecoSWSector",
1181 "reco matched sector from simulation; sector",
1185 m_DeltaRecoSWZ =
new TH1F(
"DeltaRecoSWZ",
1186 "difference between reconstructed and simulated neuro z; #Delta z [cm]",
1188 m_DeltaRecoSWCosTheta =
new TH1F(
"DeltaRecoSWCosTheta",
1189 "difference between reconstructed and simulated neuro cos(theta); #Delta cos(#theta)",
1191 m_DeltaRecoSWInvPt =
new TH1F(
"DeltaRecoSWInvPt",
1192 "difference between reconstructed and simulated neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1194 m_DeltaRecoSWPhi =
new TH1F(
"DeltaRecoSWPhi",
1195 "difference between reconstructed and simulated neuro phi; #Delta #phi [#circ]",
1200 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
1202 m_RecoSWTSSW2DZ =
new TH1F(
"RecoSWTSSW2DZ",
1203 "sw matched z distribution of reconstructed tracks; z [cm]",
1205 m_RecoSWTSSW2DCosTheta =
new TH1F(
"RecoSWTSSW2DCosTheta",
1206 "sw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1208 m_RecoSWTSSW2DInvPt =
new TH1F(
"RecoSWTSSW2DInvPt",
1209 "sw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1211 m_RecoSWTSSW2DPhi =
new TH1F(
"RecoSWTSSW2DPhi",
1212 "sw matched phi distribution of reconstructed tracks ; #phi [#circ]",
1214 m_RecoSWTSSW2DD0 =
new TH1F(
"RecoSWTSSW2DD0",
1215 "sw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1217 m_RecoSWTSSW2DZScatter =
new TH2F(
"RecoSWTSSW2DZScatter",
1218 "sw matched reconstruction; reco z [cm]; sw z [cm]",
1219 100, -150, 150, 100, -150, 150);
1223 m_neuroRecoSWTSSW2DOutZ =
new TH1F(
"NeuroRecoSWTSSW2DOutZ",
1224 "reco matched z distribution from simulation; z [cm]",
1226 m_neuroRecoSWTSSW2DOutCosTheta =
new TH1F(
"NeuroRecoSWTSSW2DOutCosTheta",
1227 "reco matched cos theta distribution from simulation; cos(#theta) ",
1229 m_neuroRecoSWTSSW2DOutInvPt =
new TH1F(
"NeuroRecoSWTSSW2DOutInvPt",
1230 "reco matched Pt distribution from simulation; p_{T}^{-1} [GeV^{-1}]",
1232 m_neuroRecoSWTSSW2DOutPhi0 =
new TH1F(
"NeuroRecoSWTSSW2DOutPhi0",
1233 "reco matched phi distribution from simulation; #phi [#circ]",
1235 m_neuroRecoSWTSSW2DOutHitPattern =
new TH1F(
"NeuroRecoSWTSSW2DHitPattern",
1236 "reco matched stereo hit pattern from simulation; pattern",
1238 m_neuroRecoSWTSSW2DOutTrackCount =
new TH1F(
"NeuroRecoSWTSSW2DOutTrackCount",
1239 "reco matched number of SW neuro tracks per event",
1241 m_neuroRecoSWTSSW2DSector =
new TH1F(
"NeuroRecoSWTSSW2DSector",
1242 "reco matched sector from simulation; sector",
1246 m_DeltaRecoSWTSSW2DZ =
new TH1F(
"DeltaRecoSWTSSW2DZ",
1247 "difference between reconstructed and simulated neuro z; #Delta z [cm]",
1249 m_DeltaRecoSWTSSW2DCosTheta =
new TH1F(
"DeltaRecoSWTSSW2DCosTheta",
1250 "difference between reconstructed and simulated neuro cos(theta); #Delta cos(#theta)",
1252 m_DeltaRecoSWTSSW2DInvPt =
new TH1F(
"DeltaRecoSWTSSW2DInvPt",
1253 "difference between reconstructed and simulated neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1255 m_DeltaRecoSWTSSW2DPhi =
new TH1F(
"DeltaRecoSWTSSW2DPhi",
1256 "difference between reconstructed and simulated neuro phi;#Delta #phi [#circ]",
1265 void CDCTriggerNeuroDQMModule::initialize()
1269 if (m_showRecoTracks && m_recoTracksName ==
"") {
1270 m_recoTracksName =
"RecoTracks";
1272 if (m_unpackedSegmentHitsName !=
"") {
1273 m_unpackedSegmentHits.isRequired(m_unpackedSegmentHitsName);
1275 if (m_unpacked2DTracksName !=
"") {
1276 m_unpacked2DTracks.isRequired(m_unpacked2DTracksName);
1278 if (m_unpackedNeuroTracksName !=
"") {
1279 m_unpackedNeuroTracks.isRequired(m_unpackedNeuroTracksName);
1280 m_unpackedNeuroInput2DTracks.isRequired(m_unpackedNeuroInput2DTracksName);
1281 m_unpackedNeuroInputSegments.isRequired(m_unpackedNeuroInputSegmentsName);
1282 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputSegments);
1283 m_unpackedNeuroInput2DTracks.requireRelationTo(m_unpackedNeuroTracks);
1284 m_unpackedNeuroInputVectorName = m_unpackedNeuroTracksName +
"Input";
1285 m_unpackedNeuroInputVector.isRequired(m_unpackedNeuroInputVectorName);
1286 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputVector);
1289 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
1290 m_simNeuroInputVectorName = m_simNeuroTracksName +
"Input";
1291 m_simNeuroTracks.isRequired(m_simNeuroTracksName);
1292 m_simNeuroInputVector.isRequired(m_simNeuroInputVectorName);
1293 m_unpackedNeuroInput2DTracks.requireRelationTo(m_simNeuroTracks);
1294 m_simNeuroTracks.requireRelationTo(m_simNeuroInputVector);
1295 m_simNeuroTracks.requireRelationTo(m_unpackedNeuroInputSegments);
1297 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
1298 m_simSegmentHits.isRequired(m_simSegmentHitsName);
1299 m_sim2DTracksSWTS.isRequired(m_sim2DTracksSWTSName);
1300 m_simNeuroInputVectorSWTSSW2DName = m_simNeuroTracksSWTSSW2DName +
"Input";
1301 m_simNeuroTracksSWTSSW2D.isRequired(m_simNeuroTracksSWTSSW2DName);
1302 m_simNeuroInputVectorSWTSSW2D.isRequired(m_simNeuroInputVectorSWTSSW2DName);
1303 m_simNeuroTracksSWTSSW2D.requireRelationTo(m_simNeuroInputVectorSWTSSW2D);
1304 m_simNeuroTracksSWTSSW2D.requireRelationTo(m_simSegmentHits);
1305 m_sim2DTracksSWTS.requireRelationTo(m_simNeuroTracksSWTSSW2D);
1307 if (m_recoTracksName !=
"") {
1308 m_RecoTracks.isRequired(
"RecoTracks");
1309 m_RecoTracks.requireRelationTo(m_unpackedNeuroTracks);
1311 if (!m_limitedoutput && m_recoTracksName !=
"" && m_simNeuroTracksName !=
"") {
1312 m_RecoTracks.requireRelationTo(m_simNeuroTracks);
1314 if (!m_limitedoutput && m_recoTracksName !=
"" && m_simNeuroTracksSWTSSW2DName !=
"") {
1315 m_RecoTracks.requireRelationTo(m_simNeuroTracksSWTSSW2D);
1319 void CDCTriggerNeuroDQMModule::beginRun()
1322 if (m_unpackedNeuroTracksName !=
"") {
1323 m_neuroHWOutZ->Reset();
1324 m_neuroHWOutCosTheta->Reset();
1325 m_neuroHWOutInvPt->Reset();
1326 m_neuroHWOutPt->Reset();
1327 m_neuroHWOutPhi0->Reset();
1328 m_neuroHWOutHitPattern->Reset();
1329 m_neuroHWOutm_time->Reset();
1330 m_neuroHWOutTrackCount->Reset();
1331 m_neuroHWOutVsInTrackCount->Reset();
1332 m_neuroHWSector->Reset();
1334 m_neuroHWInInvPt->Reset();
1335 m_neuroHWInPhi0->Reset();
1336 m_neuroHWInm_time->Reset();
1337 m_neuroHWInTrackCount->Reset();
1339 m_neuroHWInTSID->Reset();
1340 m_neuroHWInTSCount->Reset();
1342 m_neuroHWSelTSID->Reset();
1343 m_neuroHWSelTSCount->Reset();
1345 if (m_unpacked2DTracksName !=
"") {
1346 m_2DHWOutInvPt->Reset();
1347 m_2DHWOutPhi0->Reset();
1348 m_2DHWOutm_time->Reset();
1349 m_2DHWOutTrackCount->Reset();
1352 if (m_unpacked2DTracksName !=
"" && m_unpackedNeuroTracksName !=
"") {
1353 m_neuroHWInVs2DOutTrackCount->Reset();
1355 if (!m_limitedoutput && m_unpackedNeuroTracksName !=
"") {
1356 m_neuroHWOutQuad5Z->Reset();
1357 m_neuroHWOutQuad5CosTheta->Reset();
1358 m_neuroHWOutQuad5InvPt->Reset();
1359 m_neuroHWOutQuad5Phi0->Reset();
1360 m_neuroHWOutQuad0Z->Reset();
1361 m_neuroHWOutQuad0CosTheta->Reset();
1362 m_neuroHWOutQuad0InvPt->Reset();
1363 m_neuroHWOutQuad0Phi0->Reset();
1364 m_neuroHWOutQuad1Z->Reset();
1365 m_neuroHWOutQuad1CosTheta->Reset();
1366 m_neuroHWOutQuad1InvPt->Reset();
1367 m_neuroHWOutQuad1Phi0->Reset();
1368 m_neuroHWOutQuad2Z->Reset();
1369 m_neuroHWOutQuad2CosTheta->Reset();
1370 m_neuroHWOutQuad2InvPt->Reset();
1371 m_neuroHWOutQuad2Phi0->Reset();
1372 m_neuroHWOutQuad3Z->Reset();
1373 m_neuroHWOutQuad3CosTheta->Reset();
1374 m_neuroHWOutQuad3InvPt->Reset();
1375 m_neuroHWOutQuad3Phi0->Reset();
1377 m_neuroHWInTSPrioT_Layer0->Reset();
1378 m_neuroHWInTSPrioT_Layer1->Reset();
1379 m_neuroHWInTSPrioT_Layer2->Reset();
1380 m_neuroHWInTSPrioT_Layer3->Reset();
1381 m_neuroHWInTSPrioT_Layer4->Reset();
1382 m_neuroHWInTSPrioT_Layer5->Reset();
1383 m_neuroHWInTSPrioT_Layer6->Reset();
1384 m_neuroHWInTSPrioT_Layer7->Reset();
1385 m_neuroHWInTSPrioT_Layer8->Reset();
1386 m_neuroHWInTSFoundT_Layer0->Reset();
1387 m_neuroHWInTSFoundT_Layer1->Reset();
1388 m_neuroHWInTSFoundT_Layer2->Reset();
1389 m_neuroHWInTSFoundT_Layer3->Reset();
1390 m_neuroHWInTSFoundT_Layer4->Reset();
1391 m_neuroHWInTSFoundT_Layer5->Reset();
1392 m_neuroHWInTSFoundT_Layer6->Reset();
1393 m_neuroHWInTSFoundT_Layer7->Reset();
1394 m_neuroHWInTSFoundT_Layer8->Reset();
1396 m_neuroHWInTSPrioB_Layer0->Reset();
1397 m_neuroHWInTSPrioB_Layer1->Reset();
1398 m_neuroHWInTSPrioB_Layer2->Reset();
1399 m_neuroHWInTSPrioB_Layer3->Reset();
1400 m_neuroHWInTSPrioB_Layer4->Reset();
1401 m_neuroHWInTSPrioB_Layer5->Reset();
1402 m_neuroHWInTSPrioB_Layer6->Reset();
1403 m_neuroHWInTSPrioB_Layer7->Reset();
1404 m_neuroHWInTSPrioB_Layer8->Reset();
1405 m_neuroHWInTSLR_Layer0->Reset();
1406 m_neuroHWInTSLR_Layer1->Reset();
1407 m_neuroHWInTSLR_Layer2->Reset();
1408 m_neuroHWInTSLR_Layer3->Reset();
1409 m_neuroHWInTSLR_Layer4->Reset();
1410 m_neuroHWInTSLR_Layer5->Reset();
1411 m_neuroHWInTSLR_Layer6->Reset();
1412 m_neuroHWInTSLR_Layer7->Reset();
1413 m_neuroHWInTSLR_Layer8->Reset();
1415 m_neuroHWSelTSPrioT_Layer0->Reset();
1416 m_neuroHWSelTSPrioT_Layer1->Reset();
1417 m_neuroHWSelTSPrioT_Layer2->Reset();
1418 m_neuroHWSelTSPrioT_Layer3->Reset();
1419 m_neuroHWSelTSPrioT_Layer4->Reset();
1420 m_neuroHWSelTSPrioT_Layer5->Reset();
1421 m_neuroHWSelTSPrioT_Layer6->Reset();
1422 m_neuroHWSelTSPrioT_Layer7->Reset();
1423 m_neuroHWSelTSPrioT_Layer8->Reset();
1424 m_neuroHWSelTSFoundT_Layer0->Reset();
1425 m_neuroHWSelTSFoundT_Layer1->Reset();
1426 m_neuroHWSelTSFoundT_Layer2->Reset();
1427 m_neuroHWSelTSFoundT_Layer3->Reset();
1428 m_neuroHWSelTSFoundT_Layer4->Reset();
1429 m_neuroHWSelTSFoundT_Layer5->Reset();
1430 m_neuroHWSelTSFoundT_Layer6->Reset();
1431 m_neuroHWSelTSFoundT_Layer7->Reset();
1432 m_neuroHWSelTSFoundT_Layer8->Reset();
1434 m_neuroHWSelTSPrioB_Layer0->Reset();
1435 m_neuroHWSelTSPrioB_Layer1->Reset();
1436 m_neuroHWSelTSPrioB_Layer2->Reset();
1437 m_neuroHWSelTSPrioB_Layer3->Reset();
1438 m_neuroHWSelTSPrioB_Layer4->Reset();
1439 m_neuroHWSelTSPrioB_Layer5->Reset();
1440 m_neuroHWSelTSPrioB_Layer6->Reset();
1441 m_neuroHWSelTSPrioB_Layer7->Reset();
1442 m_neuroHWSelTSPrioB_Layer8->Reset();
1443 m_neuroHWSelTSLR_Layer0->Reset();
1444 m_neuroHWSelTSLR_Layer1->Reset();
1445 m_neuroHWSelTSLR_Layer2->Reset();
1446 m_neuroHWSelTSLR_Layer3->Reset();
1447 m_neuroHWSelTSLR_Layer4->Reset();
1448 m_neuroHWSelTSLR_Layer5->Reset();
1449 m_neuroHWSelTSLR_Layer6->Reset();
1450 m_neuroHWSelTSLR_Layer7->Reset();
1451 m_neuroHWSelTSLR_Layer8->Reset();
1453 m_neuroHWInputID_Layer0->Reset();
1454 m_neuroHWInputT_Layer0->Reset();
1455 m_neuroHWInputAlpha_Layer0->Reset();
1456 m_neuroHWInputID_Layer1->Reset();
1457 m_neuroHWInputT_Layer1->Reset();
1458 m_neuroHWInputAlpha_Layer1->Reset();
1459 m_neuroHWInputID_Layer2->Reset();
1460 m_neuroHWInputT_Layer2->Reset();
1461 m_neuroHWInputAlpha_Layer2->Reset();
1462 m_neuroHWInputID_Layer3->Reset();
1463 m_neuroHWInputT_Layer3->Reset();
1464 m_neuroHWInputAlpha_Layer3->Reset();
1465 m_neuroHWInputID_Layer4->Reset();
1466 m_neuroHWInputT_Layer4->Reset();
1467 m_neuroHWInputAlpha_Layer4->Reset();
1468 m_neuroHWInputID_Layer5->Reset();
1469 m_neuroHWInputT_Layer5->Reset();
1470 m_neuroHWInputAlpha_Layer5->Reset();
1471 m_neuroHWInputID_Layer6->Reset();
1472 m_neuroHWInputT_Layer6->Reset();
1473 m_neuroHWInputAlpha_Layer6->Reset();
1474 m_neuroHWInputID_Layer7->Reset();
1475 m_neuroHWInputT_Layer7->Reset();
1476 m_neuroHWInputAlpha_Layer7->Reset();
1477 m_neuroHWInputID_Layer8->Reset();
1478 m_neuroHWInputT_Layer8->Reset();
1479 m_neuroHWInputAlpha_Layer8->Reset();
1481 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
1482 m_neuroSWOutZ->Reset();
1483 m_neuroSWOutCosTheta->Reset();
1484 m_neuroSWOutPhi0->Reset();
1485 m_neuroSWOutInvPt->Reset();
1486 m_neuroSWOutHitPattern->Reset();
1487 m_neuroSWOutTrackCount->Reset();
1488 m_neuroSWSector->Reset();
1490 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
1491 m_2DSWOutInvPt->Reset();
1492 m_2DSWOutPhi0->Reset();
1493 m_2DSWOutm_time->Reset();
1494 m_2DSWOutTrackCount->Reset();
1496 m_neuroSWTSSW2DOutZ->Reset();
1497 m_neuroSWTSSW2DOutCosTheta->Reset();
1498 m_neuroSWTSSW2DOutInvPt->Reset();
1499 m_neuroSWTSSW2DOutPhi0->Reset();
1500 m_neuroSWTSSW2DOutHitPattern->Reset();
1501 m_neuroSWTSSW2DOutTrackCount->Reset();
1502 m_neuroSWTSSW2DSector->Reset();
1504 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
1505 m_neuroDeltaZ->Reset();
1506 m_neuroDeltaTheta->Reset();
1507 m_neuroScatterZ->Reset();
1508 m_neuroScatterTheta->Reset();
1510 m_neuroDeltaInputID->Reset();
1511 m_neuroDeltaInputT->Reset();
1512 m_neuroDeltaInputAlpha->Reset();
1513 m_neuroDeltaTSID->Reset();
1514 m_neuroDeltaSector->Reset();
1515 m_simSameTS->Reset();
1516 m_simDiffTS->Reset();
1518 if (!m_limitedoutput && m_unpacked2DTracksName !=
"") {
1519 m_2DHWInTSPrioT_Layer0->Reset();
1520 m_2DHWInTSPrioT_Layer2->Reset();
1521 m_2DHWInTSPrioT_Layer4->Reset();
1522 m_2DHWInTSPrioT_Layer6->Reset();
1523 m_2DHWInTSPrioT_Layer8->Reset();
1524 m_2DHWInTSFoundT_Layer0->Reset();
1525 m_2DHWInTSFoundT_Layer2->Reset();
1526 m_2DHWInTSFoundT_Layer4->Reset();
1527 m_2DHWInTSFoundT_Layer6->Reset();
1528 m_2DHWInTSFoundT_Layer8->Reset();
1530 m_2DHWInTSPrioB_Layer0->Reset();
1531 m_2DHWInTSPrioB_Layer2->Reset();
1532 m_2DHWInTSPrioB_Layer4->Reset();
1533 m_2DHWInTSPrioB_Layer6->Reset();
1534 m_2DHWInTSPrioB_Layer8->Reset();
1535 m_2DHWInTSLR_Layer0->Reset();
1536 m_2DHWInTSLR_Layer2->Reset();
1537 m_2DHWInTSLR_Layer4->Reset();
1538 m_2DHWInTSLR_Layer6->Reset();
1539 m_2DHWInTSLR_Layer8->Reset();
1541 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
1542 m_neuroSWSelTSID->Reset();
1543 m_neuroSWSelTSCount->Reset();
1544 m_neuroSWSelTSPrioT_Layer0->Reset();
1545 m_neuroSWSelTSPrioT_Layer1->Reset();
1546 m_neuroSWSelTSPrioT_Layer2->Reset();
1547 m_neuroSWSelTSPrioT_Layer3->Reset();
1548 m_neuroSWSelTSPrioT_Layer4->Reset();
1549 m_neuroSWSelTSPrioT_Layer5->Reset();
1550 m_neuroSWSelTSPrioT_Layer6->Reset();
1551 m_neuroSWSelTSPrioT_Layer7->Reset();
1552 m_neuroSWSelTSPrioT_Layer8->Reset();
1553 m_neuroSWSelTSFoundT_Layer0->Reset();
1554 m_neuroSWSelTSFoundT_Layer1->Reset();
1555 m_neuroSWSelTSFoundT_Layer2->Reset();
1556 m_neuroSWSelTSFoundT_Layer3->Reset();
1557 m_neuroSWSelTSFoundT_Layer4->Reset();
1558 m_neuroSWSelTSFoundT_Layer5->Reset();
1559 m_neuroSWSelTSFoundT_Layer6->Reset();
1560 m_neuroSWSelTSFoundT_Layer7->Reset();
1561 m_neuroSWSelTSFoundT_Layer8->Reset();
1563 m_neuroSWSelTSPrioB_Layer0->Reset();
1564 m_neuroSWSelTSPrioB_Layer1->Reset();
1565 m_neuroSWSelTSPrioB_Layer2->Reset();
1566 m_neuroSWSelTSPrioB_Layer3->Reset();
1567 m_neuroSWSelTSPrioB_Layer4->Reset();
1568 m_neuroSWSelTSPrioB_Layer5->Reset();
1569 m_neuroSWSelTSPrioB_Layer6->Reset();
1570 m_neuroSWSelTSPrioB_Layer7->Reset();
1571 m_neuroSWSelTSPrioB_Layer8->Reset();
1573 m_neuroSWSelTSLR_Layer0->Reset();
1574 m_neuroSWSelTSLR_Layer1->Reset();
1575 m_neuroSWSelTSLR_Layer2->Reset();
1576 m_neuroSWSelTSLR_Layer3->Reset();
1577 m_neuroSWSelTSLR_Layer4->Reset();
1578 m_neuroSWSelTSLR_Layer5->Reset();
1579 m_neuroSWSelTSLR_Layer6->Reset();
1580 m_neuroSWSelTSLR_Layer7->Reset();
1581 m_neuroSWSelTSLR_Layer8->Reset();
1583 m_neuroSWInputID_Layer0->Reset();
1584 m_neuroSWInputT_Layer0->Reset();
1585 m_neuroSWInputAlpha_Layer0->Reset();
1586 m_neuroSWInputID_Layer1->Reset();
1587 m_neuroSWInputT_Layer1->Reset();
1588 m_neuroSWInputAlpha_Layer1->Reset();
1589 m_neuroSWInputID_Layer2->Reset();
1590 m_neuroSWInputT_Layer2->Reset();
1591 m_neuroSWInputAlpha_Layer2->Reset();
1592 m_neuroSWInputID_Layer3->Reset();
1593 m_neuroSWInputT_Layer3->Reset();
1594 m_neuroSWInputAlpha_Layer3->Reset();
1595 m_neuroSWInputID_Layer4->Reset();
1596 m_neuroSWInputT_Layer4->Reset();
1597 m_neuroSWInputAlpha_Layer4->Reset();
1598 m_neuroSWInputID_Layer5->Reset();
1599 m_neuroSWInputT_Layer5->Reset();
1600 m_neuroSWInputAlpha_Layer5->Reset();
1601 m_neuroSWInputID_Layer6->Reset();
1602 m_neuroSWInputT_Layer6->Reset();
1603 m_neuroSWInputAlpha_Layer6->Reset();
1604 m_neuroSWInputID_Layer7->Reset();
1605 m_neuroSWInputT_Layer7->Reset();
1606 m_neuroSWInputAlpha_Layer7->Reset();
1607 m_neuroSWInputID_Layer8->Reset();
1608 m_neuroSWInputT_Layer8->Reset();
1609 m_neuroSWInputAlpha_Layer8->Reset();
1612 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
1613 m_neuroSWTSSW2DInTSID->Reset();
1614 m_neuroSWTSSW2DInTSCount->Reset();
1615 m_neuroSWTSSW2DInTSPrioT_Layer0->Reset();
1616 m_neuroSWTSSW2DInTSPrioT_Layer1->Reset();
1617 m_neuroSWTSSW2DInTSPrioT_Layer2->Reset();
1618 m_neuroSWTSSW2DInTSPrioT_Layer3->Reset();
1619 m_neuroSWTSSW2DInTSPrioT_Layer4->Reset();
1620 m_neuroSWTSSW2DInTSPrioT_Layer5->Reset();
1621 m_neuroSWTSSW2DInTSPrioT_Layer6->Reset();
1622 m_neuroSWTSSW2DInTSPrioT_Layer7->Reset();
1623 m_neuroSWTSSW2DInTSPrioT_Layer8->Reset();
1624 m_neuroSWTSSW2DInTSFoundT_Layer0->Reset();
1625 m_neuroSWTSSW2DInTSFoundT_Layer1->Reset();
1626 m_neuroSWTSSW2DInTSFoundT_Layer2->Reset();
1627 m_neuroSWTSSW2DInTSFoundT_Layer3->Reset();
1628 m_neuroSWTSSW2DInTSFoundT_Layer4->Reset();
1629 m_neuroSWTSSW2DInTSFoundT_Layer5->Reset();
1630 m_neuroSWTSSW2DInTSFoundT_Layer6->Reset();
1631 m_neuroSWTSSW2DInTSFoundT_Layer7->Reset();
1632 m_neuroSWTSSW2DInTSFoundT_Layer8->Reset();
1633 m_neuroSWTSSW2DInTSPrioB_Layer0->Reset();
1634 m_neuroSWTSSW2DInTSPrioB_Layer1->Reset();
1635 m_neuroSWTSSW2DInTSPrioB_Layer2->Reset();
1636 m_neuroSWTSSW2DInTSPrioB_Layer3->Reset();
1637 m_neuroSWTSSW2DInTSPrioB_Layer4->Reset();
1638 m_neuroSWTSSW2DInTSPrioB_Layer5->Reset();
1639 m_neuroSWTSSW2DInTSPrioB_Layer6->Reset();
1640 m_neuroSWTSSW2DInTSPrioB_Layer7->Reset();
1641 m_neuroSWTSSW2DInTSPrioB_Layer8->Reset();
1642 m_neuroSWTSSW2DInTSLR_Layer0->Reset();
1643 m_neuroSWTSSW2DInTSLR_Layer1->Reset();
1644 m_neuroSWTSSW2DInTSLR_Layer2->Reset();
1645 m_neuroSWTSSW2DInTSLR_Layer3->Reset();
1646 m_neuroSWTSSW2DInTSLR_Layer4->Reset();
1647 m_neuroSWTSSW2DInTSLR_Layer5->Reset();
1648 m_neuroSWTSSW2DInTSLR_Layer6->Reset();
1649 m_neuroSWTSSW2DInTSLR_Layer7->Reset();
1650 m_neuroSWTSSW2DInTSLR_Layer8->Reset();
1652 m_neuroSWTSSW2DSelTSID->Reset();
1653 m_neuroSWTSSW2DSelTSCount->Reset();
1654 m_neuroSWTSSW2DSelTSPrioT_Layer0->Reset();
1655 m_neuroSWTSSW2DSelTSPrioT_Layer1->Reset();
1656 m_neuroSWTSSW2DSelTSPrioT_Layer2->Reset();
1657 m_neuroSWTSSW2DSelTSPrioT_Layer3->Reset();
1658 m_neuroSWTSSW2DSelTSPrioT_Layer4->Reset();
1659 m_neuroSWTSSW2DSelTSPrioT_Layer5->Reset();
1660 m_neuroSWTSSW2DSelTSPrioT_Layer6->Reset();
1661 m_neuroSWTSSW2DSelTSPrioT_Layer7->Reset();
1662 m_neuroSWTSSW2DSelTSPrioT_Layer8->Reset();
1663 m_neuroSWTSSW2DSelTSFoundT_Layer0->Reset();
1664 m_neuroSWTSSW2DSelTSFoundT_Layer1->Reset();
1665 m_neuroSWTSSW2DSelTSFoundT_Layer2->Reset();
1666 m_neuroSWTSSW2DSelTSFoundT_Layer3->Reset();
1667 m_neuroSWTSSW2DSelTSFoundT_Layer4->Reset();
1668 m_neuroSWTSSW2DSelTSFoundT_Layer5->Reset();
1669 m_neuroSWTSSW2DSelTSFoundT_Layer6->Reset();
1670 m_neuroSWTSSW2DSelTSFoundT_Layer7->Reset();
1671 m_neuroSWTSSW2DSelTSFoundT_Layer8->Reset();
1672 m_neuroSWTSSW2DSelTSPrioB_Layer0->Reset();
1673 m_neuroSWTSSW2DSelTSPrioB_Layer1->Reset();
1674 m_neuroSWTSSW2DSelTSPrioB_Layer2->Reset();
1675 m_neuroSWTSSW2DSelTSPrioB_Layer3->Reset();
1676 m_neuroSWTSSW2DSelTSPrioB_Layer4->Reset();
1677 m_neuroSWTSSW2DSelTSPrioB_Layer5->Reset();
1678 m_neuroSWTSSW2DSelTSPrioB_Layer6->Reset();
1679 m_neuroSWTSSW2DSelTSPrioB_Layer7->Reset();
1680 m_neuroSWTSSW2DSelTSPrioB_Layer8->Reset();
1681 m_neuroSWTSSW2DSelTSLR_Layer0->Reset();
1682 m_neuroSWTSSW2DSelTSLR_Layer1->Reset();
1683 m_neuroSWTSSW2DSelTSLR_Layer2->Reset();
1684 m_neuroSWTSSW2DSelTSLR_Layer3->Reset();
1685 m_neuroSWTSSW2DSelTSLR_Layer4->Reset();
1686 m_neuroSWTSSW2DSelTSLR_Layer5->Reset();
1687 m_neuroSWTSSW2DSelTSLR_Layer6->Reset();
1688 m_neuroSWTSSW2DSelTSLR_Layer7->Reset();
1689 m_neuroSWTSSW2DSelTSLR_Layer8->Reset();
1691 m_neuroSWTSSW2DInputID_Layer0->Reset();
1692 m_neuroSWTSSW2DInputT_Layer0->Reset();
1693 m_neuroSWTSSW2DInputAlpha_Layer0->Reset();
1694 m_neuroSWTSSW2DInputID_Layer1->Reset();
1695 m_neuroSWTSSW2DInputT_Layer1->Reset();
1696 m_neuroSWTSSW2DInputAlpha_Layer1->Reset();
1697 m_neuroSWTSSW2DInputID_Layer2->Reset();
1698 m_neuroSWTSSW2DInputT_Layer2->Reset();
1699 m_neuroSWTSSW2DInputAlpha_Layer2->Reset();
1700 m_neuroSWTSSW2DInputID_Layer3->Reset();
1701 m_neuroSWTSSW2DInputT_Layer3->Reset();
1702 m_neuroSWTSSW2DInputAlpha_Layer3->Reset();
1703 m_neuroSWTSSW2DInputID_Layer4->Reset();
1704 m_neuroSWTSSW2DInputT_Layer4->Reset();
1705 m_neuroSWTSSW2DInputAlpha_Layer4->Reset();
1706 m_neuroSWTSSW2DInputID_Layer5->Reset();
1707 m_neuroSWTSSW2DInputT_Layer5->Reset();
1708 m_neuroSWTSSW2DInputAlpha_Layer5->Reset();
1709 m_neuroSWTSSW2DInputID_Layer6->Reset();
1710 m_neuroSWTSSW2DInputT_Layer6->Reset();
1711 m_neuroSWTSSW2DInputAlpha_Layer6->Reset();
1712 m_neuroSWTSSW2DInputID_Layer7->Reset();
1713 m_neuroSWTSSW2DInputT_Layer7->Reset();
1714 m_neuroSWTSSW2DInputAlpha_Layer7->Reset();
1715 m_neuroSWTSSW2DInputID_Layer8->Reset();
1716 m_neuroSWTSSW2DInputT_Layer8->Reset();
1717 m_neuroSWTSSW2DInputAlpha_Layer8->Reset();
1719 if (m_recoTracksName !=
"") {
1721 m_RecoCosTheta->Reset();
1722 m_RecoInvPt->Reset();
1725 m_RecoTrackCount->Reset();
1728 m_RecoHWCosTheta->Reset();
1729 m_RecoHWInvPt->Reset();
1730 m_RecoHWPhi->Reset();
1731 m_RecoHWD0->Reset();
1733 if (!m_limitedoutput && m_recoTracksName !=
"") {
1734 m_RecoHWZScatter->Reset();
1736 if (m_unpackedNeuroTracksName !=
"" && m_recoTracksName !=
"") {
1737 m_neuroRecoHWOutZ->Reset();
1738 m_neuroRecoHWOutCosTheta->Reset();
1739 m_neuroRecoHWOutInvPt->Reset();
1740 m_neuroRecoHWOutPhi0->Reset();
1741 m_neuroRecoHWOutHitPattern->Reset();
1742 m_neuroRecoHWOutTrackCount->Reset();
1743 m_neuroRecoHWSector->Reset();
1745 m_DeltaRecoHWZ->Reset();
1746 m_DeltaRecoHWCosTheta->Reset();
1747 m_DeltaRecoHWInvPt->Reset();
1748 m_DeltaRecoHWPhi->Reset();
1750 if (!m_limitedoutput && m_simNeuroTracksName !=
"" && m_recoTracksName !=
"") {
1752 m_RecoSWCosTheta->Reset();
1753 m_RecoSWInvPt->Reset();
1754 m_RecoSWPhi->Reset();
1755 m_RecoSWD0->Reset();
1756 m_RecoSWZScatter->Reset();
1758 m_neuroRecoSWOutZ->Reset();
1759 m_neuroRecoSWOutCosTheta->Reset();
1760 m_neuroRecoSWOutInvPt->Reset();
1761 m_neuroRecoSWOutPhi0->Reset();
1762 m_neuroRecoSWOutHitPattern->Reset();
1763 m_neuroRecoSWOutTrackCount->Reset();
1764 m_neuroRecoSWSector->Reset();
1766 m_DeltaRecoSWZ->Reset();
1767 m_DeltaRecoSWCosTheta->Reset();
1768 m_DeltaRecoSWInvPt->Reset();
1769 m_DeltaRecoSWPhi->Reset();
1771 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"" && m_recoTracksName !=
"") {
1772 m_RecoSWTSSW2DZ->Reset();
1773 m_RecoSWTSSW2DCosTheta->Reset();
1774 m_RecoSWTSSW2DInvPt->Reset();
1775 m_RecoSWTSSW2DPhi->Reset();
1776 m_RecoSWTSSW2DD0->Reset();
1777 m_RecoSWTSSW2DZScatter->Reset();
1779 m_neuroRecoSWTSSW2DOutZ->Reset();
1780 m_neuroRecoSWTSSW2DOutCosTheta->Reset();
1781 m_neuroRecoSWTSSW2DOutInvPt->Reset();
1782 m_neuroRecoSWTSSW2DOutPhi0->Reset();
1783 m_neuroRecoSWTSSW2DOutHitPattern->Reset();
1784 m_neuroRecoSWTSSW2DOutTrackCount->Reset();
1785 m_neuroRecoSWTSSW2DSector->Reset();
1787 m_DeltaRecoSWTSSW2DZ->Reset();
1788 m_DeltaRecoSWTSSW2DCosTheta->Reset();
1789 m_DeltaRecoSWTSSW2DInvPt->Reset();
1790 m_DeltaRecoSWTSSW2DPhi->Reset();
1794 void CDCTriggerNeuroDQMModule::event()
1797 if (m_skipWithoutHWTS and m_unpackedNeuroInputSegments.getEntries() == 0) {
1799 B2DEBUG(150,
"No unpacked TS found, skipping event.");
1802 if (m_recoTrackMultiplicity != -1 and m_RecoTracks.getEntries() != m_recoTrackMultiplicity) {
1803 B2DEBUG(150,
"Wrong track multiplicity " << m_RecoTracks.getEntries() <<
", skipping event.");
1809 if (m_recoTracksName !=
"") {
1812 m_RecoTrackCount->Fill(m_RecoTracks.getEntries());
1813 bool foundValidRep =
false;
1815 for (
RecoTrack& recoTrack : m_RecoTracks) {
1818 int nswtssw2dmatched = 0;
1819 double phi0Target = 0;
1820 double invptTarget = 0;
1821 double cosThetaTarget = 0;
1823 double d0Target = 0;
1825 if (!recoTrack.wasFitSuccessful(rep))
1831 recoTrack.getMeasuredStateOnPlaneClosestTo(TVector3(0, 0, 0), rep);
1832 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
1841 phi0Target = state.getMom().Phi() * 180. / M_PI ;
1842 if (phi0Target < 0.) {phi0Target = phi0Target + 360. ;}
1843 invptTarget = state.getCharge() * state.getMom().Pt();
1844 cosThetaTarget = state.getMom().CosTheta();
1845 zTarget = state.getPos().Z();
1846 d0Target = state.getPos().Perp();
1851 foundValidRep =
true;
1854 if (!foundValidRep) {
1855 B2DEBUG(150,
"No valid representation found for RecoTrack, skipping.");
1858 if (m_maxRecoZDist != -1.0 and abs(zTarget) > m_maxRecoZDist) {
1859 B2DEBUG(150,
"RecoTrack not close to IP (maxRecoZDist), zReco = " << zTarget);
1862 if (m_maxRecoD0Dist != -1.0 and abs(d0Target) > m_maxRecoD0Dist) {
1863 B2DEBUG(150,
"RecoTrack not close to the z axis (maxRecoD0Dist), d0Reco = " << d0Target);
1866 m_RecoZ->Fill(zTarget);
1867 m_RecoCosTheta->Fill(cosThetaTarget);
1868 m_RecoPhi->Fill(phi0Target);
1869 m_RecoD0->Fill(d0Target);
1870 m_RecoInvPt->Fill(invptTarget);
1871 if (m_unpackedNeuroTracksName !=
"") {
1873 double neuroHWZ, neuroHWcosTh, neuroHWPhi0, neuroHWPt ;
1874 double neuroSWZ, neuroSWcosTh, neuroSWPhi0, neuroSWPt ;
1877 bool valtrack =
false;
1881 B2WARNING(
"HWTrack doesn't have 'valid bit', get it from relations now... ");
1882 unsigned checkpattern = getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentsName);
1883 valtrack = isValidPattern(checkpattern);
1889 m_RecoHWZ->Fill(zTarget);
1890 m_RecoHWCosTheta->Fill(cosThetaTarget);
1891 m_RecoHWPhi->Fill(phi0Target);
1892 m_RecoHWD0->Fill(d0Target);
1893 m_RecoHWInvPt->Fill(invptTarget);
1895 neuroHWZ = neuroHWTrack->getZ0() ;
1896 m_neuroRecoHWOutZ->Fill(neuroHWZ);
1897 double cotTh = neuroHWTrack->getCotTheta() ;
1898 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
1899 neuroHWcosTh = cosTh ;
1900 m_neuroRecoHWOutCosTheta->Fill(neuroHWcosTh);
1901 neuroHWPt = neuroHWTrack->
getPt() ;
1902 m_neuroRecoHWOutInvPt->Fill(neuroHWPt);
1903 phinorm = neuroHWTrack->getPhi0() * 180 / M_PI ;
1904 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1905 neuroHWPhi0 = phinorm;
1906 m_neuroRecoHWOutPhi0->Fill(neuroHWPhi0);
1907 m_neuroRecoHWOutHitPattern->Fill(getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentsName));
1909 unsigned hwMatchedSector =
1910 neuroHWTrack->getRelatedTo<
CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getSector();
1911 m_neuroRecoHWSector->Fill(hwMatchedSector);
1913 m_DeltaRecoHWZ->Fill(zTarget - neuroHWZ);
1914 m_DeltaRecoHWCosTheta->Fill(cosThetaTarget - neuroHWcosTh);
1915 m_DeltaRecoHWPhi->Fill(phi0Target - neuroHWPhi0);
1916 m_DeltaRecoHWInvPt->Fill(invptTarget - neuroHWPt);
1917 if (!m_limitedoutput) {
1918 m_RecoHWZScatter->Fill(zTarget, neuroHWZ);
1921 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
1924 bool valtrack =
false;
1928 B2INFO(
"SWTrack doesn't have 'valid bit', get it from relations now... ");
1929 unsigned checkpattern = getPattern(neuroSWTrack, m_unpackedNeuroInputSegmentsName);
1930 valtrack = isValidPattern(checkpattern);
1936 m_RecoSWZ->Fill(zTarget);
1937 m_RecoSWCosTheta->Fill(cosThetaTarget);
1938 m_RecoSWPhi->Fill(phi0Target);
1939 m_RecoSWD0->Fill(d0Target);
1940 m_RecoSWInvPt->Fill(invptTarget);
1942 neuroSWZ = neuroSWTrack->getZ0() ;
1943 m_neuroRecoSWOutZ->Fill(neuroSWZ);
1944 double cotTh = neuroSWTrack->getCotTheta() ;
1945 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
1946 neuroSWcosTh = cosTh ;
1947 m_neuroRecoSWOutCosTheta->Fill(neuroSWcosTh);
1948 neuroSWPt = neuroSWTrack->
getPt() ;
1949 m_neuroRecoSWOutInvPt->Fill(neuroSWPt);
1950 phinorm = neuroSWTrack->getPhi0() * 180 / M_PI ;
1951 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1952 neuroSWPhi0 = phinorm ;
1953 m_neuroRecoSWOutPhi0->Fill(neuroSWPhi0);
1954 m_neuroRecoSWOutHitPattern->Fill(getPattern(neuroSWTrack, m_unpackedNeuroInputSegmentsName));
1956 unsigned swMatchedSector =
1957 neuroSWTrack->getRelatedTo<
CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getSector();
1958 m_neuroRecoSWSector->Fill(swMatchedSector);
1960 m_DeltaRecoSWZ->Fill(zTarget - neuroSWZ);
1961 m_DeltaRecoSWCosTheta->Fill(cosThetaTarget - neuroSWcosTh);
1962 m_DeltaRecoSWPhi->Fill(phi0Target - neuroSWPhi0);
1963 m_DeltaRecoSWInvPt->Fill(invptTarget - neuroSWPt);
1964 m_RecoSWZScatter->Fill(zTarget, neuroSWZ);
1967 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
1969 if (neuroSWTSSW2DTrack) {
1970 m_RecoSWTSSW2DZ->Fill(zTarget);
1971 m_RecoSWTSSW2DCosTheta->Fill(cosThetaTarget);
1972 m_RecoSWTSSW2DPhi->Fill(phi0Target);
1973 m_RecoSWTSSW2DD0->Fill(d0Target);
1974 m_RecoSWTSSW2DInvPt->Fill(invptTarget);
1976 m_neuroRecoSWTSSW2DOutZ->Fill(neuroSWTSSW2DTrack->getZ0());
1978 double cotTh = neuroSWTSSW2DTrack->getCotTheta();
1979 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
1980 m_neuroRecoSWTSSW2DOutCosTheta->Fill(cosTh);
1981 phinorm = neuroSWTSSW2DTrack->getPhi0() * 180 / M_PI;
1982 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1983 double phiNeuro = phinorm ;
1984 double invptNeuro = neuroSWTSSW2DTrack->
getPt() ;
1985 m_neuroRecoSWTSSW2DOutInvPt->Fill(invptNeuro);
1986 m_neuroRecoSWTSSW2DOutPhi0->Fill(phiNeuro);
1987 m_neuroRecoSWTSSW2DOutHitPattern->Fill(getPattern(neuroSWTSSW2DTrack, m_simSegmentHitsName));
1989 unsigned swtssw2dMatchedSector =
1990 neuroSWTSSW2DTrack->getRelatedTo<
CDCTriggerMLPInput>(m_simNeuroInputVectorSWTSSW2DName)->getSector();
1991 m_neuroRecoSWTSSW2DSector->Fill(swtssw2dMatchedSector);
1993 m_DeltaRecoSWTSSW2DZ->Fill(zTarget - neuroSWTSSW2DTrack->getZ0());
1996 m_DeltaRecoSWTSSW2DCosTheta->Fill(cosThetaTarget - cosTh);
1997 phinorm = neuroSWTSSW2DTrack->getPhi0() * 180. / M_PI ;
1998 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1999 m_DeltaRecoSWTSSW2DPhi->Fill(phi0Target - phinorm);
2000 m_DeltaRecoSWTSSW2DInvPt->Fill(invptTarget - neuroSWTSSW2DTrack->
getPt());
2001 m_RecoSWTSSW2DZScatter->Fill(zTarget, neuroSWTSSW2DTrack->getZ0());
2006 if (m_unpackedNeuroTracksName !=
"") {
2007 m_neuroRecoHWOutTrackCount->Fill(nhwmatched);
2008 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
2009 m_neuroRecoSWOutTrackCount->Fill(nswmatched);
2011 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
2012 m_neuroRecoSWTSSW2DOutTrackCount->Fill(nswtssw2dmatched);
2018 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
2019 m_neuroSWTSSW2DOutTrackCount->Fill(m_simNeuroTracksSWTSSW2D.getEntries());
2021 m_neuroSWTSSW2DOutZ->Fill(neuroswTrack.getZ0());
2022 double cotThSW = neuroswTrack.getCotTheta();
2023 double cosThSW = copysign(1.0, cotThSW) / sqrt(1. / (cotThSW * cotThSW) + 1);
2024 m_neuroSWTSSW2DOutCosTheta->Fill(cosThSW);
2025 phinorm = neuroswTrack.getPhi0() * 180. / M_PI ;
2027 phinorm = phinorm + 360. ;
2029 m_neuroSWTSSW2DOutPhi0->Fill(phinorm);
2030 m_neuroSWTSSW2DOutInvPt->Fill(neuroswTrack.getPt());
2031 unsigned simSWTSSW2DSector =
2032 neuroswTrack.getRelatedTo<
CDCTriggerMLPInput>(m_simNeuroInputVectorSWTSSW2DName)->getSector();
2033 m_neuroSWTSSW2DSector->Fill(simSWTSSW2DSector);
2036 unsigned pattern = 0;
2039 m_neuroSWTSSW2DSelTSID->Fill(hit.getSegmentID());
2040 unsigned int sl = hit.getISuperLayer();
2041 m_neuroSWTSSW2DSelTSCount->Fill(sl);
2042 float neuroTime = neuroswTrack.getTime();
2047 if (compare.getISuperLayer() == hit.getISuperLayer() &&
2048 compare.getIWireCenter() == hit.getIWireCenter() &&
2049 compare.getPriorityPosition() == hit.getPriorityPosition() &&
2050 compare.getLeftRight() == hit.getLeftRight() &&
2051 compare.priorityTime() == hit.priorityTime() &&
2052 compare.foundTime() < firstHit.
foundTime()) {
2058 case 0: m_neuroSWTSSW2DSelTSPrioT_Layer0->Fill(hit.priorityTime());
2059 m_neuroSWTSSW2DSelTSFoundT_Layer0->Fill(firstHit.
foundTime() - neuroTime);
2060 m_neuroSWTSSW2DSelTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2061 m_neuroSWTSSW2DSelTSLR_Layer0->Fill(hit.getLeftRight());
2063 case 1: m_neuroSWTSSW2DSelTSPrioT_Layer1->Fill(hit.priorityTime());
2064 m_neuroSWTSSW2DSelTSFoundT_Layer1->Fill(firstHit.
foundTime() - neuroTime);
2065 m_neuroSWTSSW2DSelTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2066 m_neuroSWTSSW2DSelTSLR_Layer1->Fill(hit.getLeftRight());
2068 case 2: m_neuroSWTSSW2DSelTSPrioT_Layer2->Fill(hit.priorityTime());
2069 m_neuroSWTSSW2DSelTSFoundT_Layer2->Fill(firstHit.
foundTime() - neuroTime);
2070 m_neuroSWTSSW2DSelTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2071 m_neuroSWTSSW2DSelTSLR_Layer2->Fill(hit.getLeftRight());
2073 case 3: m_neuroSWTSSW2DSelTSPrioT_Layer3->Fill(hit.priorityTime());
2074 m_neuroSWTSSW2DSelTSFoundT_Layer3->Fill(firstHit.
foundTime() - neuroTime);
2075 m_neuroSWTSSW2DSelTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2076 m_neuroSWTSSW2DSelTSLR_Layer3->Fill(hit.getLeftRight());
2078 case 4: m_neuroSWTSSW2DSelTSPrioT_Layer4->Fill(hit.priorityTime());
2079 m_neuroSWTSSW2DSelTSFoundT_Layer4->Fill(firstHit.
foundTime() - neuroTime);
2080 m_neuroSWTSSW2DSelTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2081 m_neuroSWTSSW2DSelTSLR_Layer4->Fill(hit.getLeftRight());
2083 case 5: m_neuroSWTSSW2DSelTSPrioT_Layer5->Fill(hit.priorityTime());
2084 m_neuroSWTSSW2DSelTSFoundT_Layer5->Fill(firstHit.
foundTime() - neuroTime);
2085 m_neuroSWTSSW2DSelTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2086 m_neuroSWTSSW2DSelTSLR_Layer5->Fill(hit.getLeftRight());
2088 case 6: m_neuroSWTSSW2DSelTSPrioT_Layer6->Fill(hit.priorityTime());
2089 m_neuroSWTSSW2DSelTSFoundT_Layer6->Fill(firstHit.
foundTime() - neuroTime);
2090 m_neuroSWTSSW2DSelTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2091 m_neuroSWTSSW2DSelTSLR_Layer6->Fill(hit.getLeftRight());
2093 case 7: m_neuroSWTSSW2DSelTSPrioT_Layer7->Fill(hit.priorityTime());
2094 m_neuroSWTSSW2DSelTSFoundT_Layer7->Fill(firstHit.
foundTime() - neuroTime);
2095 m_neuroSWTSSW2DSelTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2096 m_neuroSWTSSW2DSelTSLR_Layer7->Fill(hit.getLeftRight());
2098 case 8: m_neuroSWTSSW2DSelTSPrioT_Layer8->Fill(hit.priorityTime());
2099 m_neuroSWTSSW2DSelTSFoundT_Layer8->Fill(firstHit.
foundTime() - neuroTime);
2100 m_neuroSWTSSW2DSelTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2101 m_neuroSWTSSW2DSelTSLR_Layer8->Fill(hit.getLeftRight());
2104 if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
2106 m_neuroSWTSSW2DOutHitPattern->Fill(pattern);
2109 vector<float> nnInput =
2111 condFill(m_neuroSWTSSW2DInputID_Layer0 , nnInput[0]);
2112 condFill(m_neuroSWTSSW2DInputT_Layer0 , nnInput[1]);
2113 condFill(m_neuroSWTSSW2DInputAlpha_Layer0 , nnInput[2]);
2114 condFill(m_neuroSWTSSW2DInputID_Layer1 , nnInput[3]);
2115 condFill(m_neuroSWTSSW2DInputT_Layer1 , nnInput[4]);
2116 condFill(m_neuroSWTSSW2DInputAlpha_Layer1 , nnInput[5]);
2117 condFill(m_neuroSWTSSW2DInputID_Layer2 , nnInput[6]);
2118 condFill(m_neuroSWTSSW2DInputT_Layer2 , nnInput[7]);
2119 condFill(m_neuroSWTSSW2DInputAlpha_Layer2 , nnInput[8]);
2120 condFill(m_neuroSWTSSW2DInputID_Layer3 , nnInput[9]);
2121 condFill(m_neuroSWTSSW2DInputT_Layer3 , nnInput[10]);
2122 condFill(m_neuroSWTSSW2DInputAlpha_Layer3 , nnInput[11]);
2123 condFill(m_neuroSWTSSW2DInputID_Layer4 , nnInput[12]);
2124 condFill(m_neuroSWTSSW2DInputT_Layer4 , nnInput[13]);
2125 condFill(m_neuroSWTSSW2DInputAlpha_Layer4 , nnInput[14]);
2126 condFill(m_neuroSWTSSW2DInputID_Layer5 , nnInput[15]);
2127 condFill(m_neuroSWTSSW2DInputT_Layer5 , nnInput[16]);
2128 condFill(m_neuroSWTSSW2DInputAlpha_Layer5 , nnInput[17]);
2129 condFill(m_neuroSWTSSW2DInputID_Layer6 , nnInput[18]);
2130 condFill(m_neuroSWTSSW2DInputT_Layer6 , nnInput[19]);
2131 condFill(m_neuroSWTSSW2DInputAlpha_Layer6 , nnInput[20]);
2132 condFill(m_neuroSWTSSW2DInputID_Layer7 , nnInput[21]);
2133 condFill(m_neuroSWTSSW2DInputT_Layer7 , nnInput[22]);
2134 condFill(m_neuroSWTSSW2DInputAlpha_Layer7 , nnInput[23]);
2135 condFill(m_neuroSWTSSW2DInputID_Layer8 , nnInput[24]);
2136 condFill(m_neuroSWTSSW2DInputT_Layer8 , nnInput[25]);
2137 condFill(m_neuroSWTSSW2DInputAlpha_Layer8 , nnInput[26]);
2140 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
2141 m_neuroSWOutTrackCount->Fill(m_simNeuroTracks.getEntries());
2143 bool valtrack =
false;
2145 valtrack = neuroswTrack.getValidStereoBit();
2147 B2INFO(
"HWTrack doesn't have 'valid bit', get it from relations now... ");
2148 unsigned checkpattern = getPattern(&neuroswTrack, m_unpackedNeuroInputSegmentsName);
2149 valtrack = isValidPattern(checkpattern);
2155 m_neuroSWOutZ->Fill(neuroswTrack.getZ0());
2156 double cotThSW = neuroswTrack.getCotTheta();
2157 double cosThSW = copysign(1.0, cotThSW) / sqrt(1. / (cotThSW * cotThSW) + 1);
2158 m_neuroSWOutCosTheta->Fill(cosThSW);
2159 phinorm = neuroswTrack.getPhi0() * 180. / M_PI ;
2160 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
2161 m_neuroSWOutPhi0->Fill(phinorm);
2162 m_neuroSWOutInvPt->Fill(neuroswTrack.getPt());
2164 unsigned simSector =
2165 neuroswTrack.getRelatedTo<
CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getSector();
2166 m_neuroSWSector->Fill(simSector);
2169 unsigned pattern = 0;
2172 m_neuroSWSelTSID->Fill(hit.getSegmentID());
2173 unsigned int sl = hit.getISuperLayer();
2174 m_neuroSWSelTSCount->Fill(sl);
2175 float neuroTime = neuroswTrack.getTime();
2180 if (compare.getISuperLayer() == hit.getISuperLayer() &&
2181 compare.getIWireCenter() == hit.getIWireCenter() &&
2182 compare.getPriorityPosition() == hit.getPriorityPosition() &&
2183 compare.getLeftRight() == hit.getLeftRight() &&
2184 compare.priorityTime() == hit.priorityTime() &&
2185 compare.foundTime() < firstHit.
foundTime()) {
2191 case 0: m_neuroSWSelTSPrioT_Layer0->Fill(hit.priorityTime());
2192 m_neuroSWSelTSFoundT_Layer0->Fill(firstHit.
foundTime() - neuroTime);
2193 m_neuroSWSelTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2194 m_neuroSWSelTSLR_Layer0->Fill(hit.getLeftRight());
2196 case 1: m_neuroSWSelTSPrioT_Layer1->Fill(hit.priorityTime());
2197 m_neuroSWSelTSFoundT_Layer1->Fill(firstHit.
foundTime() - neuroTime);
2198 m_neuroSWSelTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2199 m_neuroSWSelTSLR_Layer1->Fill(hit.getLeftRight());
2201 case 2: m_neuroSWSelTSPrioT_Layer2->Fill(hit.priorityTime());
2202 m_neuroSWSelTSFoundT_Layer2->Fill(firstHit.
foundTime() - neuroTime);
2203 m_neuroSWSelTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2204 m_neuroSWSelTSLR_Layer2->Fill(hit.getLeftRight());
2206 case 3: m_neuroSWSelTSPrioT_Layer3->Fill(hit.priorityTime());
2207 m_neuroSWSelTSFoundT_Layer3->Fill(firstHit.
foundTime() - neuroTime);
2208 m_neuroSWSelTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2209 m_neuroSWSelTSLR_Layer3->Fill(hit.getLeftRight());
2211 case 4: m_neuroSWSelTSPrioT_Layer4->Fill(hit.priorityTime());
2212 m_neuroSWSelTSFoundT_Layer4->Fill(firstHit.
foundTime() - neuroTime);
2213 m_neuroSWSelTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2214 m_neuroSWSelTSLR_Layer4->Fill(hit.getLeftRight());
2216 case 5: m_neuroSWSelTSPrioT_Layer5->Fill(hit.priorityTime());
2217 m_neuroSWSelTSFoundT_Layer5->Fill(firstHit.
foundTime() - neuroTime);
2218 m_neuroSWSelTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2219 m_neuroSWSelTSLR_Layer5->Fill(hit.getLeftRight());
2221 case 6: m_neuroSWSelTSPrioT_Layer6->Fill(hit.priorityTime());
2222 m_neuroSWSelTSFoundT_Layer6->Fill(firstHit.
foundTime() - neuroTime);
2223 m_neuroSWSelTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2224 m_neuroSWSelTSLR_Layer6->Fill(hit.getLeftRight());
2226 case 7: m_neuroSWSelTSPrioT_Layer7->Fill(hit.priorityTime());
2227 m_neuroSWSelTSFoundT_Layer7->Fill(firstHit.
foundTime() - neuroTime);
2228 m_neuroSWSelTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2229 m_neuroSWSelTSLR_Layer7->Fill(hit.getLeftRight());
2231 case 8: m_neuroSWSelTSPrioT_Layer8->Fill(hit.priorityTime());
2232 m_neuroSWSelTSFoundT_Layer8->Fill(firstHit.
foundTime() - neuroTime);
2233 m_neuroSWSelTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2234 m_neuroSWSelTSLR_Layer8->Fill(hit.getLeftRight());
2237 if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
2239 m_neuroSWOutHitPattern->Fill(pattern);
2243 vector<float> nnInput =
2245 condFill(m_neuroSWInputID_Layer0 , nnInput[0]);
2246 condFill(m_neuroSWInputT_Layer0 , nnInput[1]);
2247 condFill(m_neuroSWInputAlpha_Layer0 , nnInput[2]);
2248 condFill(m_neuroSWInputID_Layer1 , nnInput[3]);
2249 condFill(m_neuroSWInputT_Layer1 , nnInput[4]);
2250 condFill(m_neuroSWInputAlpha_Layer1 , nnInput[5]);
2251 condFill(m_neuroSWInputID_Layer2 , nnInput[6]);
2252 condFill(m_neuroSWInputT_Layer2 , nnInput[7]);
2253 condFill(m_neuroSWInputAlpha_Layer2 , nnInput[8]);
2254 condFill(m_neuroSWInputID_Layer3 , nnInput[9]);
2255 condFill(m_neuroSWInputT_Layer3 , nnInput[10]);
2256 condFill(m_neuroSWInputAlpha_Layer3 , nnInput[11]);
2257 condFill(m_neuroSWInputID_Layer4 , nnInput[12]);
2258 condFill(m_neuroSWInputT_Layer4 , nnInput[13]);
2259 condFill(m_neuroSWInputAlpha_Layer4 , nnInput[14]);
2260 condFill(m_neuroSWInputID_Layer5 , nnInput[15]);
2261 condFill(m_neuroSWInputT_Layer5 , nnInput[16]);
2262 condFill(m_neuroSWInputAlpha_Layer5 , nnInput[17]);
2263 condFill(m_neuroSWInputID_Layer6 , nnInput[18]);
2264 condFill(m_neuroSWInputT_Layer6 , nnInput[19]);
2265 condFill(m_neuroSWInputAlpha_Layer6 , nnInput[20]);
2266 condFill(m_neuroSWInputID_Layer7 , nnInput[21]);
2267 condFill(m_neuroSWInputT_Layer7 , nnInput[22]);
2268 condFill(m_neuroSWInputAlpha_Layer7 , nnInput[23]);
2269 condFill(m_neuroSWInputID_Layer8 , nnInput[24]);
2270 condFill(m_neuroSWInputT_Layer8 , nnInput[25]);
2271 condFill(m_neuroSWInputAlpha_Layer8 , nnInput[26]);
2275 int nofouttracks = 0;
2276 int nofintracks = 0;
2277 int nofinsegments = 0;
2278 int nof2douttracks = 0;
2279 int nof2dinsegments = 0;
2280 if (m_unpackedNeuroTracksName !=
"") {
2283 bool valtrack =
false;
2285 valtrack = neuroTrack.getValidStereoBit();
2287 B2WARNING(
"NeuroTrack doesn't have 'valid bit', get it from relations now... ");
2288 unsigned checkpattern = getPattern(&neuroTrack, m_unpackedNeuroInputSegmentsName);
2289 valtrack = isValidPattern(checkpattern);
2297 m_neuroHWOutZ->Fill(neuroTrack.getZ0());
2298 double cotTh = neuroTrack.getCotTheta();
2299 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
2300 m_neuroHWOutCosTheta->Fill(cosTh);
2301 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2302 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
2303 m_neuroHWOutPhi0->Fill(phinorm);
2304 m_neuroHWOutInvPt->Fill(neuroTrack.getPt());
2305 m_neuroHWOutPt->Fill(neuroTrack.getPt());
2306 m_neuroHWOutm_time->Fill(neuroTrack.getTime());
2309 neuroTrack.getRelatedTo<
CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getSector();
2310 m_neuroHWSector->Fill(hwSector);
2313 if (!m_limitedoutput) {
2314 switch (neuroTrack.getQuadrant()) {
2316 m_neuroHWOutQuad5Z->Fill(neuroTrack.getZ0());
2317 m_neuroHWOutQuad5CosTheta->Fill(cosTh);
2318 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2319 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2320 m_neuroHWOutQuad5Phi0->Fill(phinorm);
2321 m_neuroHWOutQuad5InvPt->Fill(neuroTrack.getPt());
2324 m_neuroHWOutQuad0Z->Fill(neuroTrack.getZ0());
2325 m_neuroHWOutQuad0CosTheta->Fill(cosTh);
2326 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2327 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2328 m_neuroHWOutQuad0Phi0->Fill(phinorm);
2329 m_neuroHWOutQuad0InvPt->Fill(neuroTrack.getPt());
2332 m_neuroHWOutQuad1Z->Fill(neuroTrack.getZ0());
2333 m_neuroHWOutQuad1CosTheta->Fill(cosTh);
2334 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2335 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2336 m_neuroHWOutQuad1Phi0->Fill(phinorm);
2337 m_neuroHWOutQuad1InvPt->Fill(neuroTrack.getPt());
2340 m_neuroHWOutQuad2Z->Fill(neuroTrack.getZ0());
2341 m_neuroHWOutQuad2CosTheta->Fill(cosTh);
2342 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2343 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2344 m_neuroHWOutQuad2Phi0->Fill(phinorm);
2345 m_neuroHWOutQuad2InvPt->Fill(neuroTrack.getPt());
2348 m_neuroHWOutQuad3Z->Fill(neuroTrack.getZ0());
2349 m_neuroHWOutQuad3CosTheta->Fill(cosTh);
2350 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2351 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2352 m_neuroHWOutQuad3Phi0->Fill(phinorm);
2353 m_neuroHWOutQuad3InvPt->Fill(neuroTrack.getPt());
2359 unsigned pattern = 0;
2362 m_neuroHWSelTSID->Fill(hit.getSegmentID());
2363 unsigned int sl = hit.getISuperLayer();
2364 m_neuroHWSelTSCount->Fill(sl);
2365 float neuroTime = neuroTrack.getTime();
2369 if (compare.getISuperLayer() == hit.getISuperLayer() &&
2370 compare.getIWireCenter() == hit.getIWireCenter() &&
2371 compare.getPriorityPosition() == hit.getPriorityPosition() &&
2372 compare.getLeftRight() == hit.getLeftRight() &&
2373 compare.priorityTime() == hit.priorityTime() &&
2374 compare.foundTime() < firstHit.
foundTime()) {
2379 if (!m_limitedoutput) {
2381 case 0: m_neuroHWSelTSPrioT_Layer0->Fill(hit.priorityTime());
2382 m_neuroHWSelTSFoundT_Layer0->Fill(firstHit.
foundTime() - neuroTime);
2383 m_neuroHWSelTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2384 m_neuroHWSelTSLR_Layer0->Fill(hit.getLeftRight());
2386 case 1: m_neuroHWSelTSPrioT_Layer1->Fill(hit.priorityTime());
2387 m_neuroHWSelTSFoundT_Layer1->Fill(firstHit.
foundTime() - neuroTime);
2388 m_neuroHWSelTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2389 m_neuroHWSelTSLR_Layer1->Fill(hit.getLeftRight());
2391 case 2: m_neuroHWSelTSPrioT_Layer2->Fill(hit.priorityTime());
2392 m_neuroHWSelTSFoundT_Layer2->Fill(firstHit.
foundTime() - neuroTime);
2393 m_neuroHWSelTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2394 m_neuroHWSelTSLR_Layer2->Fill(hit.getLeftRight());
2396 case 3: m_neuroHWSelTSPrioT_Layer3->Fill(hit.priorityTime());
2397 m_neuroHWSelTSFoundT_Layer3->Fill(firstHit.
foundTime() - neuroTime);
2398 m_neuroHWSelTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2399 m_neuroHWSelTSLR_Layer3->Fill(hit.getLeftRight());
2401 case 4: m_neuroHWSelTSPrioT_Layer4->Fill(hit.priorityTime());
2402 m_neuroHWSelTSFoundT_Layer4->Fill(firstHit.
foundTime() - neuroTime);
2403 m_neuroHWSelTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2404 m_neuroHWSelTSLR_Layer4->Fill(hit.getLeftRight());
2406 case 5: m_neuroHWSelTSPrioT_Layer5->Fill(hit.priorityTime());
2407 m_neuroHWSelTSFoundT_Layer5->Fill(firstHit.
foundTime() - neuroTime);
2408 m_neuroHWSelTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2409 m_neuroHWSelTSLR_Layer5->Fill(hit.getLeftRight());
2411 case 6: m_neuroHWSelTSPrioT_Layer6->Fill(hit.priorityTime());
2412 m_neuroHWSelTSFoundT_Layer6->Fill(firstHit.
foundTime() - neuroTime);
2413 m_neuroHWSelTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2414 m_neuroHWSelTSLR_Layer6->Fill(hit.getLeftRight());
2416 case 7: m_neuroHWSelTSPrioT_Layer7->Fill(hit.priorityTime());
2417 m_neuroHWSelTSFoundT_Layer7->Fill(firstHit.
foundTime() - neuroTime);
2418 m_neuroHWSelTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2419 m_neuroHWSelTSLR_Layer7->Fill(hit.getLeftRight());
2421 case 8: m_neuroHWSelTSPrioT_Layer8->Fill(hit.priorityTime());
2422 m_neuroHWSelTSFoundT_Layer8->Fill(firstHit.
foundTime() - neuroTime);
2423 m_neuroHWSelTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2424 m_neuroHWSelTSLR_Layer8->Fill(hit.getLeftRight());
2428 if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
2430 m_neuroHWOutHitPattern->Fill(pattern);
2433 if (!m_limitedoutput) {
2434 vector<float> nnInput =
2436 condFill(m_neuroHWInputID_Layer0 , nnInput[0]);
2437 condFill(m_neuroHWInputT_Layer0 , nnInput[1]);
2438 condFill(m_neuroHWInputAlpha_Layer0 , nnInput[2]);
2439 condFill(m_neuroHWInputID_Layer1 , nnInput[3]);
2440 condFill(m_neuroHWInputT_Layer1 , nnInput[4]);
2441 condFill(m_neuroHWInputAlpha_Layer1 , nnInput[5]);
2442 condFill(m_neuroHWInputID_Layer2 , nnInput[6]);
2443 condFill(m_neuroHWInputT_Layer2 , nnInput[7]);
2444 condFill(m_neuroHWInputAlpha_Layer2 , nnInput[8]);
2445 condFill(m_neuroHWInputID_Layer3 , nnInput[9]);
2446 condFill(m_neuroHWInputT_Layer3 , nnInput[10]);
2447 condFill(m_neuroHWInputAlpha_Layer3 , nnInput[11]);
2448 condFill(m_neuroHWInputID_Layer4 , nnInput[12]);
2449 condFill(m_neuroHWInputT_Layer4 , nnInput[13]);
2450 condFill(m_neuroHWInputAlpha_Layer4 , nnInput[14]);
2451 condFill(m_neuroHWInputID_Layer5 , nnInput[15]);
2452 condFill(m_neuroHWInputT_Layer5 , nnInput[16]);
2453 condFill(m_neuroHWInputAlpha_Layer5 , nnInput[17]);
2454 condFill(m_neuroHWInputID_Layer6 , nnInput[18]);
2455 condFill(m_neuroHWInputT_Layer6 , nnInput[19]);
2456 condFill(m_neuroHWInputAlpha_Layer6 , nnInput[20]);
2457 condFill(m_neuroHWInputID_Layer7 , nnInput[21]);
2458 condFill(m_neuroHWInputT_Layer7 , nnInput[22]);
2459 condFill(m_neuroHWInputAlpha_Layer7 , nnInput[23]);
2460 condFill(m_neuroHWInputID_Layer8 , nnInput[24]);
2461 condFill(m_neuroHWInputT_Layer8 , nnInput[25]);
2462 condFill(m_neuroHWInputAlpha_Layer8 , nnInput[26]);
2465 if (!m_limitedoutput) {
2466 if (m_simNeuroTracksName !=
"") {
2469 neuroTrack.getRelatedFrom<
CDCTriggerTrack>(m_unpackedNeuroInput2DTracksName);
2473 if (neuroSimTrack) {
2479 unsigned int simsl = simhit.getISuperLayer();
2482 unsigned int sl = hit.getISuperLayer();
2484 m_neuroDeltaTSID->Fill(hit.getSegmentID() - simhit.getSegmentID());
2485 if (simhit.getSegmentID() == hit.getSegmentID() &&
2486 simhit.getPriorityPosition() == hit.getPriorityPosition() &&
2487 simhit.getLeftRight() == hit.getLeftRight() &&
2488 simhit.priorityTime() == hit.priorityTime()
2497 m_simSameTS->Fill(nsameTS);
2498 m_simDiffTS->Fill(ndiffTS);
2502 if (nsameTS >= m_nsamets) {
2503 m_neuroDeltaZ->Fill(neuroTrack.getZ0() - neuroSimTrack->getZ0());
2504 double nnHWtheta = neuroTrack.getDirection().Theta() * 180. / M_PI;
2505 double nnSWtheta = neuroSimTrack->getDirection().Theta() * 180. / M_PI;
2506 m_neuroDeltaTheta->Fill(nnHWtheta - nnSWtheta);
2507 m_neuroScatterZ->Fill(neuroTrack.getZ0(), neuroSimTrack->getZ0());
2508 m_neuroScatterTheta->Fill(nnHWtheta, nnSWtheta);
2509 vector<float> unpackedInput =
2510 neuroTrack.getRelatedTo<
CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
2511 vector<float> simInput =
2512 neuroSimTrack->getRelatedTo<
CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getInput();
2513 unsigned unpackedSector =
2514 neuroTrack.getRelatedTo<
CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getSector();
2515 unsigned simSector =
2516 neuroSimTrack->getRelatedTo<
CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getSector();
2517 m_neuroDeltaSector->Fill(unpackedSector - simSector);
2519 for (
unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
2520 m_neuroDeltaInputID->Fill(unpackedInput[ii] - simInput[ii]);
2521 m_neuroDeltaInputT->Fill(unpackedInput[ii + 1] - simInput[ii + 1]);
2522 m_neuroDeltaInputAlpha->Fill(unpackedInput[ii + 2] - simInput[ii + 2]);
2530 for (
CDCTriggerTrack& neuroinput2dtrack : m_unpackedNeuroInput2DTracks) {
2532 phinorm = neuroinput2dtrack.getPhi0() * 180. / M_PI ;
2533 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2534 m_neuroHWInPhi0->Fill(phinorm);
2535 m_neuroHWInm_time->Fill(neuroinput2dtrack.getTime());
2536 m_neuroHWInInvPt->Fill(neuroinput2dtrack.getPt());
2538 if (nofintracks > 0 || nofouttracks > 0) {
2539 m_neuroHWInTrackCount->Fill(nofintracks);
2540 m_neuroHWOutTrackCount->Fill(nofouttracks);
2541 m_neuroHWOutVsInTrackCount->Fill((nofouttracks - nofintracks));
2545 m_neuroHWInTSID->Fill(neuroinputsegment.getSegmentID());
2546 if (!m_limitedoutput) {
2547 unsigned int sl = neuroinputsegment.getISuperLayer();
2549 case 0: m_neuroHWInTSPrioT_Layer0->Fill(neuroinputsegment.priorityTime());
2550 m_neuroHWInTSFoundT_Layer0->Fill(neuroinputsegment.foundTime());
2551 m_neuroHWInTSPrioB_Layer0->Fill(neuroinputsegment.getPriorityPosition());
2552 m_neuroHWInTSLR_Layer0->Fill(neuroinputsegment.getLeftRight());
2554 case 1: m_neuroHWInTSPrioT_Layer1->Fill(neuroinputsegment.priorityTime());
2555 m_neuroHWInTSFoundT_Layer1->Fill(neuroinputsegment.foundTime());
2556 m_neuroHWInTSPrioB_Layer1->Fill(neuroinputsegment.getPriorityPosition());
2557 m_neuroHWInTSLR_Layer1->Fill(neuroinputsegment.getLeftRight());
2559 case 2: m_neuroHWInTSPrioT_Layer2->Fill(neuroinputsegment.priorityTime());
2560 m_neuroHWInTSFoundT_Layer2->Fill(neuroinputsegment.foundTime());
2561 m_neuroHWInTSPrioB_Layer2->Fill(neuroinputsegment.getPriorityPosition());
2562 m_neuroHWInTSLR_Layer2->Fill(neuroinputsegment.getLeftRight());
2564 case 3: m_neuroHWInTSPrioT_Layer3->Fill(neuroinputsegment.priorityTime());
2565 m_neuroHWInTSFoundT_Layer3->Fill(neuroinputsegment.foundTime());
2566 m_neuroHWInTSPrioB_Layer3->Fill(neuroinputsegment.getPriorityPosition());
2567 m_neuroHWInTSLR_Layer3->Fill(neuroinputsegment.getLeftRight());
2569 case 4: m_neuroHWInTSPrioT_Layer4->Fill(neuroinputsegment.priorityTime());
2570 m_neuroHWInTSFoundT_Layer4->Fill(neuroinputsegment.foundTime());
2571 m_neuroHWInTSPrioB_Layer4->Fill(neuroinputsegment.getPriorityPosition());
2572 m_neuroHWInTSLR_Layer4->Fill(neuroinputsegment.getLeftRight());
2574 case 5: m_neuroHWInTSPrioT_Layer5->Fill(neuroinputsegment.priorityTime());
2575 m_neuroHWInTSFoundT_Layer5->Fill(neuroinputsegment.foundTime());
2576 m_neuroHWInTSPrioB_Layer5->Fill(neuroinputsegment.getPriorityPosition());
2577 m_neuroHWInTSLR_Layer5->Fill(neuroinputsegment.getLeftRight());
2579 case 6: m_neuroHWInTSPrioT_Layer6->Fill(neuroinputsegment.priorityTime());
2580 m_neuroHWInTSFoundT_Layer6->Fill(neuroinputsegment.foundTime());
2581 m_neuroHWInTSPrioB_Layer6->Fill(neuroinputsegment.getPriorityPosition());
2582 m_neuroHWInTSLR_Layer6->Fill(neuroinputsegment.getLeftRight());
2584 case 7: m_neuroHWInTSPrioT_Layer7->Fill(neuroinputsegment.priorityTime());
2585 m_neuroHWInTSFoundT_Layer7->Fill(neuroinputsegment.foundTime());
2586 m_neuroHWInTSPrioB_Layer7->Fill(neuroinputsegment.getPriorityPosition());
2587 m_neuroHWInTSLR_Layer7->Fill(neuroinputsegment.getLeftRight());
2589 case 8: m_neuroHWInTSPrioT_Layer8->Fill(neuroinputsegment.priorityTime());
2590 m_neuroHWInTSFoundT_Layer8->Fill(neuroinputsegment.foundTime());
2591 m_neuroHWInTSPrioB_Layer8->Fill(neuroinputsegment.getPriorityPosition());
2592 m_neuroHWInTSLR_Layer8->Fill(neuroinputsegment.getLeftRight());
2597 if (nofinsegments > 0) {
2598 m_neuroHWInTSCount->Fill(nofinsegments);
2601 if (!m_limitedoutput && m_simSegmentHitsName !=
"" && m_sim2DTracksSWTSName !=
"") {
2602 m_2DSWOutTrackCount->Fill(m_sim2DTracksSWTS.getEntries());
2604 phinorm = sim2dtrack.getPhi0() * 180. / M_PI ;
2605 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2606 m_2DSWOutPhi0->Fill(phinorm);
2607 m_2DSWOutm_time->Fill(sim2dtrack.getTime());
2608 m_2DSWOutInvPt->Fill(sim2dtrack.getPt());
2611 if (m_unpacked2DTracksName !=
"") {
2614 phinorm = finder2dtrack.getPhi0() * 180. / M_PI ;
2615 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
2616 m_2DHWOutPhi0->Fill(phinorm);
2617 m_2DHWOutm_time->Fill(finder2dtrack.getTime());
2618 m_2DHWOutInvPt->Fill(finder2dtrack.getPt());
2620 if (nof2douttracks > 0) {
2621 m_2DHWOutTrackCount->Fill(nof2douttracks);
2622 if (m_unpackedNeuroTracksName !=
"") {
2623 m_neuroHWInVs2DOutTrackCount->Fill((nofintracks - nof2douttracks));
2630 if (!m_limitedoutput) {
2631 unsigned int sl = hit.getISuperLayer();
2633 case 0: m_2DHWInTSPrioT_Layer0->Fill(hit.priorityTime());
2634 m_2DHWInTSFoundT_Layer0->Fill(hit.foundTime());
2635 m_2DHWInTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2636 m_2DHWInTSLR_Layer0->Fill(hit.getLeftRight());
2638 case 2: m_2DHWInTSPrioT_Layer2->Fill(hit.priorityTime());
2639 m_2DHWInTSFoundT_Layer2->Fill(hit.foundTime());
2640 m_2DHWInTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2641 m_2DHWInTSLR_Layer2->Fill(hit.getLeftRight());
2643 case 4: m_2DHWInTSPrioT_Layer4->Fill(hit.priorityTime());
2644 m_2DHWInTSFoundT_Layer4->Fill(hit.foundTime());
2645 m_2DHWInTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2646 m_2DHWInTSLR_Layer4->Fill(hit.getLeftRight());
2648 case 6: m_2DHWInTSPrioT_Layer6->Fill(hit.priorityTime());
2649 m_2DHWInTSFoundT_Layer6->Fill(hit.foundTime());
2650 m_2DHWInTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2651 m_2DHWInTSLR_Layer6->Fill(hit.getLeftRight());
2653 case 8: m_2DHWInTSPrioT_Layer8->Fill(hit.priorityTime());
2654 m_2DHWInTSFoundT_Layer8->Fill(hit.foundTime());
2655 m_2DHWInTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2656 m_2DHWInTSLR_Layer8->Fill(hit.getLeftRight());
2661 if (nof2dinsegments > 0) {
2667 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName !=
"") {
2668 m_neuroSWTSSW2DInTSCount->Fill(m_simSegmentHits.getEntries());
2670 m_neuroSWTSSW2DInTSID->Fill(hit.getSegmentID());
2671 unsigned int sl = hit.getISuperLayer();
2673 case 0: m_neuroSWTSSW2DInTSPrioT_Layer0->Fill(hit.priorityTime());
2674 m_neuroSWTSSW2DInTSFoundT_Layer0->Fill(hit.foundTime());
2675 m_neuroSWTSSW2DInTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2676 m_neuroSWTSSW2DInTSLR_Layer0->Fill(hit.getLeftRight());
2678 case 1: m_neuroSWTSSW2DInTSPrioT_Layer1->Fill(hit.priorityTime());
2679 m_neuroSWTSSW2DInTSFoundT_Layer1->Fill(hit.foundTime());
2680 m_neuroSWTSSW2DInTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2681 m_neuroSWTSSW2DInTSLR_Layer1->Fill(hit.getLeftRight());
2683 case 2: m_neuroSWTSSW2DInTSPrioT_Layer2->Fill(hit.priorityTime());
2684 m_neuroSWTSSW2DInTSFoundT_Layer2->Fill(hit.foundTime());
2685 m_neuroSWTSSW2DInTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2686 m_neuroSWTSSW2DInTSLR_Layer2->Fill(hit.getLeftRight());
2688 case 3: m_neuroSWTSSW2DInTSPrioT_Layer3->Fill(hit.priorityTime());
2689 m_neuroSWTSSW2DInTSFoundT_Layer3->Fill(hit.foundTime());
2690 m_neuroSWTSSW2DInTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2691 m_neuroSWTSSW2DInTSLR_Layer3->Fill(hit.getLeftRight());
2693 case 4: m_neuroSWTSSW2DInTSPrioT_Layer4->Fill(hit.priorityTime());
2694 m_neuroSWTSSW2DInTSFoundT_Layer4->Fill(hit.foundTime());
2695 m_neuroSWTSSW2DInTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2696 m_neuroSWTSSW2DInTSLR_Layer4->Fill(hit.getLeftRight());
2698 case 5: m_neuroSWTSSW2DInTSPrioT_Layer5->Fill(hit.priorityTime());
2699 m_neuroSWTSSW2DInTSFoundT_Layer5->Fill(hit.foundTime());
2700 m_neuroSWTSSW2DInTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2701 m_neuroSWTSSW2DInTSLR_Layer5->Fill(hit.getLeftRight());
2703 case 6: m_neuroSWTSSW2DInTSPrioT_Layer6->Fill(hit.priorityTime());
2704 m_neuroSWTSSW2DInTSFoundT_Layer6->Fill(hit.foundTime());
2705 m_neuroSWTSSW2DInTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2706 m_neuroSWTSSW2DInTSLR_Layer6->Fill(hit.getLeftRight());
2708 case 7: m_neuroSWTSSW2DInTSPrioT_Layer7->Fill(hit.priorityTime());
2709 m_neuroSWTSSW2DInTSFoundT_Layer7->Fill(hit.foundTime());
2710 m_neuroSWTSSW2DInTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2711 m_neuroSWTSSW2DInTSLR_Layer7->Fill(hit.getLeftRight());
2713 case 8: m_neuroSWTSSW2DInTSPrioT_Layer8->Fill(hit.priorityTime());
2714 m_neuroSWTSSW2DInTSFoundT_Layer8->Fill(hit.foundTime());
2715 m_neuroSWTSSW2DInTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2716 m_neuroSWTSSW2DInTSLR_Layer8->Fill(hit.getLeftRight());
2722 static constexpr std::array<int, 9> nWiresInSuperLayer = {
2723 160, 160, 192, 224, 256, 288, 320, 352, 384
2725 unsigned axhwts = 0;
2726 unsigned sthwts = 0;
2727 unsigned axswts = 0;
2728 unsigned stswts = 0;
2730 std::vector<TSLine> hwtsoutput;
2731 std::vector<TSLine> swtsoutput;
2732 if (m_unpackedSegmentHitsName !=
"") {
2734 if (xhit.getISuperLayer() % 2 == 0) {
2739 int iSL = xhit.getISuperLayer();
2740 int iTS = xhit.getIWire();
2741 int nwires = nWiresInSuperLayer[ iSL ];
2748 int tsIDInTracker = iTS - nwires * xhit.getQuadrant() / 4;
2749 if (tsIDInTracker < 0) {
2750 tsIDInTracker += nwires;
2754 + padto(std::to_string(xhit.getISuperLayer()), 2) +
", "
2755 + padto(std::to_string(xhit.getQuadrant()), 1) +
", "
2756 + padto(std::to_string(xhit.getSegmentID()), 4) +
", "
2757 + padto(std::to_string(xhit.getIWire()), 5) +
", "
2758 + padto(std::to_string(xhit.getPriorityPosition()), 2) +
", "
2759 + padto(std::to_string(xhit.getLeftRight()), 2) +
", "
2760 + padto(std::to_string(xhit.priorityTime()), 4) +
", "
2761 + padto(std::to_string(xhit.foundTime()), 3) +
", "
2762 + padto(std::to_string(tsIDInTracker), 4) +
") | ";
2763 unsigned count2d = 0;
2764 if (m_unpackedNeuroTracksName !=
"") {
2767 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentsName)) {
2768 l.strline += std::to_string(count2d);
2774 unsigned counthwn = 0;
2777 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentsName)) {
2778 if (track.getValidStereoBit()) {
2779 l.strline += std::to_string(counthwn);
2789 if (m_simNeuroTracksName !=
"") {
2790 unsigned countswn = 0;
2793 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentsName)) {
2794 l.strline += std::to_string(countswn);
2801 if (m_recoTracksName !=
"") {
2802 unsigned countreco = 0;
2803 for (
const auto& track : m_RecoTracks) {
2805 bool related =
false;
2807 if (&ts == &xhit) {related =
true;}
2810 l.strline += std::to_string(countreco);
2817 if (m_unpackedNeuroTracksName !=
"") {
2818 sorted_insert(hwtsoutput, l, m_unpackedNeuroInputSegmentsName, m_unpackedNeuroInput2DTracksName, m_unpackedNeuroTracksName);
2820 hwtsoutput.push_back(l);
2824 std::string axhw = std::to_string(axhwts) +
" / " + std::to_string(sthwts);
2825 if (!m_limitedoutput && m_simSegmentHitsName !=
"") {
2827 if (xhit.getISuperLayer() % 2 == 0) {
2832 int iSL = xhit.getISuperLayer();
2833 int iTS = xhit.getIWire();
2834 int nwires = nWiresInSuperLayer[ iSL ];
2841 int tsIDInTracker = iTS - nwires * xhit.getQuadrant() / 4;
2842 if (tsIDInTracker < 0) {
2843 tsIDInTracker += nwires;
2847 + padto(std::to_string(xhit.getISuperLayer()), 2) +
", "
2848 + padto(std::to_string(xhit.getSegmentID()), 4) +
", "
2849 + padto(std::to_string(xhit.getIWire()), 5) +
", "
2850 + padto(std::to_string(xhit.getPriorityPosition()), 2) +
", "
2851 + padto(std::to_string(xhit.getLeftRight()), 2) +
", "
2852 + padto(std::to_string(xhit.priorityTime()), 4) +
", "
2853 + padto(std::to_string(xhit.foundTime()), 3) +
", "
2854 + padto(std::to_string(tsIDInTracker), 4) +
") ";
2855 unsigned count2d = 0;
2856 if (m_sim2DTracksSWTSName !=
"") {
2859 if (have_relation(track, xhit, m_simSegmentHitsName)) {
2860 l.strline += std::to_string(count2d);
2867 unsigned countswn = 0;
2868 if (m_simNeuroTracksSWTSSW2DName !=
"") {
2871 if (have_relation(track, xhit, m_simSegmentHitsName)) {
2872 l.strline += std::to_string(countswn);
2879 if (m_recoTracksName !=
"") {
2880 unsigned countreco = 0;
2881 for (
const auto& track : m_RecoTracks) {
2883 bool related =
false;
2885 if (&ts == &xhit) {related =
true;}
2888 l.strline += std::to_string(countreco);
2895 if (m_simNeuroTracksSWTSSW2DName !=
"") {
2896 sorted_insert(swtsoutput, l, m_simSegmentHitsName, m_sim2DTracksSWTSName, m_simNeuroTracksSWTSSW2DName);
2898 swtsoutput.push_back(l);
2902 std::string hwtsstring =
"(SL, Q, SID , WID , PP, LR, pT , fT , TSID) | HWNNIn2D | HWNeuro | SWNeuro | ";
2903 std::string swtsstring =
"(SL, Q, SID , WID , PP, LR, pT , fT , TSID) | SW2D | SWNeuro | ";
2904 if (m_recoTracksName !=
"") {
2905 hwtsstring +=
"Reco | ";
2906 swtsstring +=
"Reco | ";
2908 B2DEBUG(10, padright(
" ", 100));
2909 B2DEBUG(10,
"----------------------------------------------------------------------------------------------------");
2910 B2DEBUG(10, padright(
" ", 100));
2911 std::string experimentstring =
"Experiment " + std::to_string(eventMetaData->getExperiment()) +
" Run " +
2912 std::to_string(eventMetaData->getRun()) +
" Event " + std::to_string(eventMetaData->getEvent());
2913 B2DEBUG(10, padright(experimentstring, 100));
2914 B2DEBUG(10, padright(
" ", 100));
2915 B2DEBUG(10, padright(
" ", 100));
2916 if (m_unpackedNeuroTracksName !=
"" && m_unpacked2DTracksName !=
"") {
2917 B2DEBUG(10, padright(
"Number of NN HW TS (Axial/Stereo): ", 40) << padright(axhw, 60));
2918 B2DEBUG(10, padright(
"Number of HW 2DFinderTracks: ", 40) << padright(std::to_string(m_unpacked2DTracks.getEntries()),
2920 unsigned f2dtrn = 0;
2923 std::stringstream strpt;
2924 std::stringstream stromega;
2925 std::stringstream strphi;
2926 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
2927 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
2928 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
2929 std::string trs =
" HW2DFinderTrack Nr. " + std::to_string(f2dtrn) +
" (pt, omega, phi) = ";
2930 trs += padto(strpt.str(), 6) +
", " + padto(stromega.str(), 6) +
", " + padto(strphi.str(), 6) +
")";
2931 B2DEBUG(15, padright(trs, 100));
2933 B2DEBUG(10, padright(
"Number of HW NNInput2DFinderTracks: ",
2934 40) << padright(std::to_string(m_unpackedNeuroInput2DTracks.getEntries()), 60));
2935 unsigned n2dtrn = 0;
2938 std::stringstream strpt;
2939 std::stringstream stromega;
2940 std::stringstream strphi;
2941 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
2942 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
2943 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
2944 std::string trs =
" HWNeuroInput2DTrack Nr. " + std::to_string(n2dtrn) +
" (pt, omega, phi) = ";
2945 trs += padto(strpt.str(), 6) +
", " + padto(stromega.str(), 6) +
", " + padto(strphi.str(), 6) +
", " +
")";
2946 B2DEBUG(15, padright(trs, 100));
2948 B2DEBUG(10, padright(
"Number of HW NeuroTracks: ",
2949 40) << padright(std::to_string(m_unpackedNeuroTracks.getEntries()), 60));
2950 unsigned hwntrn = 0;
2953 std::stringstream strpt;
2954 std::stringstream stromega;
2955 std::stringstream strphi;
2956 std::stringstream strtheta;
2957 std::stringstream strz;
2958 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
2959 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
2960 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
2961 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
2962 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
2963 std::string trs =
" HWNeuroTrack Nr. " + std::to_string(hwntrn) +
" (pt, omega, phi, theta, z) = ";
2964 trs += padto(strpt.str(), 6) +
", " + padto(stromega.str(), 6) +
", " + padto(strphi.str(), 6) +
", " + padto(strtheta.str(),
2965 6) +
", " + padto(strz.str(), 6) +
")";
2966 B2DEBUG(15, padright(trs, 100));
2967 std::string infostr =
" Found old track: ( ";
2968 for (
bool x : ltrack.getFoundOldTrack()) {
2969 infostr += std::to_string(x) +
" ";
2972 infostr = padright(infostr, 50);
2973 infostr +=
"Drift threshold: ( ";
2974 for (
bool x : ltrack.getDriftThreshold()) {
2975 infostr += std::to_string(x) +
" ";
2978 infostr += (ltrack.getValidStereoBit()) ?
" valid" :
" NOT valid";
2979 B2DEBUG(15, padright(infostr, 100));
2980 std::string info2str =
" Expert Network Number: " + std::to_string(ltrack.getExpert());
2981 info2str +=
", TSVector: (";
2982 for (
bool x : ltrack.getTSVector()) {
2983 info2str += std::to_string(x) +
" ";
2986 B2DEBUG(15, padright(info2str, 100));
2990 vector<float> unpackedInput =
2993 vector<float> simInput =
2995 B2DEBUG(20, padright(
" Input Vector unpacked (id, t, alpha), sim (id, t, alpha), delta (id, t, alpha):", 100));
2996 for (
unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
2997 std::string lla =
" " + std::to_string(ii / 3) +
")";
2998 std::string llb =
" " + std::to_string(ii / 3) +
")";
2999 lla +=
"(" + padright(std::to_string(unpackedInput[ii]), 8) +
" " + padright(std::to_string(unpackedInput[ii + 1]),
3000 8) +
" " + padright(std::to_string(unpackedInput[ii + 2]), 8) +
"),(" + padright(std::to_string(simInput[ii]),
3001 8) +
" " + padright(std::to_string(simInput[ii + 1]), 8) +
" " + padright(std::to_string(simInput[ii + 2]),
3002 8) +
"),(" + padright(std::to_string(unpackedInput[ii] - simInput[ii]),
3003 8) +
" " + padright(std::to_string(unpackedInput[ii + 1] - simInput[ii + 1]),
3004 8) +
" " + padright(std::to_string(unpackedInput[ii + 2] - simInput[ii + 2]), 8) +
")";
3005 llb +=
" (" + padright(std::to_string(
int(unpackedInput[ii] * 4096)),
3006 8) +
" " + padright(std::to_string(
int(unpackedInput[ii + 1] * 4096)),
3007 8) +
" " + padright(std::to_string(
int(unpackedInput[ii + 2] * 4096)),
3008 8) +
"),(" + padright(std::to_string(
int(simInput[ii] * 4096)), 8) +
" " + padright(std::to_string(
int(simInput[ii + 1] * 4096)),
3009 8) +
" " + padright(std::to_string(
int(simInput[ii + 2] * 4096)),
3010 8) +
"),(" + padright(std::to_string(
int(unpackedInput[ii] * 4096 - simInput[ii] * 4096)),
3011 8) +
" " + padright(std::to_string(
int(unpackedInput[ii + 1] * 4096 - simInput[ii + 1] * 4096)),
3012 8) +
" " + padright(std::to_string(
int(unpackedInput[ii + 2] * 4096 - simInput[ii + 2] * 4096)), 8) +
")";
3027 B2DEBUG(30, padright(lla, 100));
3028 B2DEBUG(20, padright(llb, 100));
3035 if (!m_limitedoutput && m_simNeuroTracksName !=
"") {
3036 B2DEBUG(10, padright(
"Number of SW NeuroTracks: ", 40) << padright(std::to_string(m_simNeuroTracks.getEntries()), 60));
3037 unsigned swntrn = 0;
3040 std::stringstream strpt;
3041 std::stringstream stromega;
3042 std::stringstream strphi;
3043 std::stringstream strtheta;
3044 std::stringstream strz;
3045 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
3046 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
3047 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
3048 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
3049 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
3050 std::string trs =
" SWNeuroTrack Nr. " + std::to_string(swntrn) +
" (pt, omega, phi, theta, z) = ";
3051 trs += padto(strpt.str(), 6) +
", " + padto(stromega.str(), 6) +
", " + padto(strphi.str(), 6) +
", " + padto(strtheta.str(),
3052 6) +
", " + padto(strz.str(), 6) +
")";
3053 B2DEBUG(15, padright(trs, 100));
3056 if (!m_limitedoutput && m_simSegmentHitsName !=
"") {
3057 std::string axsw = std::to_string(axswts) +
" / " + std::to_string(stswts);
3058 B2DEBUG(10, padright(
"Number of AllSW TS (Axial/Stereo): ", 40) << padright(axsw, 60));
3059 if (m_sim2DTracksSWTSName !=
"" && m_simNeuroTracksSWTSSW2DName !=
"") {
3060 B2DEBUG(10, padright(
"Number of SW 2DFinderSWTSTracks: ", 40) << padright(std::to_string(m_sim2DTracksSWTS.getEntries()),
3062 unsigned sf2dtrn = 0;
3065 std::stringstream strpt;
3066 std::stringstream stromega;
3067 std::stringstream strphi;
3068 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
3069 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
3070 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
3071 std::string trs =
" SW2DFinderSWTSTrack Nr. " + std::to_string(sf2dtrn) +
" (pt, omega, phi) = ";
3072 trs += padto(strpt.str(), 6) +
", " + padto(stromega.str(), 6) +
", " + padto(strphi.str(), 6) +
")";
3073 B2DEBUG(15, padright(trs, 100));
3075 B2DEBUG(10, padright(
"Number of SW NeuroSWTSSW2DTracks: ",
3076 40) << padright(std::to_string(m_simNeuroTracksSWTSSW2D.getEntries()), 60));
3077 unsigned aswntrn = 0;
3080 std::stringstream strpt;
3081 std::stringstream stromega;
3082 std::stringstream strphi;
3083 std::stringstream strtheta;
3084 std::stringstream strz;
3085 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
3086 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
3087 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
3088 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
3089 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
3090 std::string trs =
" SWNeuroSWTSSW2DTrack Nr. " + std::to_string(aswntrn) +
" (pt, omega, phi, theta, z) = ";
3091 trs += padto(strpt.str(), 6) +
", " + padto(stromega.str(), 6) +
", " + padto(strphi.str(), 6) +
", " + padto(strtheta.str(),
3092 6) +
", " + padto(strz.str(), 6) +
")";
3093 B2DEBUG(15, padright(trs, 100));
3097 if (m_recoTracksName !=
"") {
3098 B2DEBUG(10, padright(
"Number of RecoTracks: ", 40) << padright(std::to_string(m_RecoTracks.getEntries()), 60));
3099 unsigned recotrn = 0;
3100 for (
RecoTrack& ltrack : m_RecoTracks) {
3101 double phi0Target = 0;
3102 double invptTarget = 0;
3103 double thetaTarget = 0;
3105 double d0Target = 0;
3106 bool foundValidRep =
false;
3108 if (!ltrack.wasFitSuccessful(rep))
3114 ltrack.getMeasuredStateOnPlaneClosestTo(TVector3(0, 0, 0), rep);
3115 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
3124 phi0Target = state.getMom().Phi() * 180. / M_PI ;
3125 if (phi0Target < 0.) {phi0Target = phi0Target + 360. ;}
3126 invptTarget = state.getCharge() * state.getMom().Pt();
3127 thetaTarget = acos(state.getMom().CosTheta()) * 180 / M_PI;
3128 zTarget = state.getPos().Z();
3129 d0Target = state.getPos().Perp();
3134 foundValidRep =
true;
3137 if (!foundValidRep) {
3138 B2DEBUG(150,
"No valid representation found for RecoTrack, skipping.");
3141 if (m_maxRecoZDist != -1.0 and abs(zTarget) > m_maxRecoZDist) {
3142 B2DEBUG(150,
"RecoTrack not close to IP (maxRecoZDist), zReco = " << zTarget);
3145 if (m_maxRecoD0Dist != -1.0 and abs(d0Target) > m_maxRecoD0Dist) {
3146 B2DEBUG(150,
"RecoTrack not close to the z axis (maxRecoD0Dist), d0Reco = " << d0Target);
3151 std::stringstream strpt;
3152 std::stringstream stromega;
3153 std::stringstream strphi;
3154 std::stringstream strtheta;
3155 std::stringstream strz;
3156 strpt << std::fixed << std::setprecision(2) << invptTarget;
3157 stromega << std::fixed << std::setprecision(2) << d0Target;
3158 strphi << std::fixed << std::setprecision(2) << phi0Target;
3159 strtheta << std::fixed << std::setprecision(2) << thetaTarget;
3160 strz << std::fixed << std::setprecision(2) << zTarget;
3161 std::string trs =
" RecoTrack Nr. " + std::to_string(recotrn) +
" (invpt, d0, phi, theta, z) = ";
3162 trs += padto(strpt.str(), 6) +
", " + padto(stromega.str(), 6) +
", " + padto(strphi.str(), 6) +
", " + padto(strtheta.str(),
3163 6) +
", " + padto(strz.str(), 6) +
")";
3164 B2DEBUG(15, padright(trs, 100));
3167 B2DEBUG(10, padright(
" ", 100));
3168 B2DEBUG(10, padright(
" ", 100));
3169 if (m_unpackedSegmentHitsName !=
"") {
3170 B2DEBUG(15, padright(
"Detailed information about HW TS ", 100));
3171 B2DEBUG(15, padright(
" ", 100));
3172 B2DEBUG(15, padright(hwtsstring, 100));
3173 for (
auto x : hwtsoutput) {
3174 B2DEBUG(15, padright(x.strline, 100));
3176 B2DEBUG(15, padright(
" ", 100));
3178 if (!m_limitedoutput && m_simSegmentHitsName !=
"") {
3179 B2DEBUG(15, padright(
" ", 100));
3180 B2DEBUG(15, padright(
"Detailed information about SW TS ", 100));
3181 B2DEBUG(15, padright(
" ", 100));
3182 B2DEBUG(15, padright(swtsstring, 100));
3183 for (
auto x : swtsoutput) {
3184 B2DEBUG(15, padright(x.strline, 100));
3190 void CDCTriggerNeuroDQMModule::endRun()
3195 void CDCTriggerNeuroDQMModule::terminate()