Belle II Software development
CDCTriggerNeuroDQMModule.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include "trg/cdc/modules/dqmneuro/CDCTriggerNeuroDQMModule.h"
10
11#include <framework/dataobjects/EventMetaData.h>
12
13#include "TDirectory.h"
14#include <tracking/dataobjects/RecoTrack.h>
15
16using namespace std;
17using namespace Belle2;
18
19//-----------------------------------------------------------------
20// Register the Module
21//-----------------------------------------------------------------
22REG_MODULE(CDCTriggerNeuroDQM);
23
24
25//-----------------------------------------------------------------
26// Implementation
27//-----------------------------------------------------------------
28
29CDCTriggerNeuroDQMModule::CDCTriggerNeuroDQMModule() : HistoModule()
30{
31 //Set module properties
32 setDescription("CDC Trigger DQM module");
33 setPropertyFlags(c_ParallelProcessingCertified); // specify this flag if you need parallel processing
34 addParam("limitedoutput", m_limitedoutput,
35 "Switch to supress output for online dqm purposes. ",
36 true);
37 addParam("unpackedSegmentHitsName", m_unpackedSegmentHitsName,
38 "The name of the StoreArray of the unpacked CDCTriggerSegmentHits",
39 string("CDCTriggerSegmentHits"));
40 addParam("unpacked2DTracksName", m_unpacked2DTracksName,
41 "The name of the StoreArray of the unpacked 2D finder tracks",
42 string("CDCTrigger2DFinderTracks"));
43 addParam("unpackedNeuroTracksName", m_unpackedNeuroTracksName,
44 "The name of the StoreArray of the unpacked neurotrigger tracks",
45 string("CDCTriggerNeuroTracks"));
46 addParam("unpackedNeuroInput2dTracksName", m_unpackedNeuroInput2DTracksName,
47 "The name of the StoreArray of the neurotrigger input 2d tracks",
48 string("CDCTriggerNNInput2DFinderTracks"));
49 addParam("unpackedNeuroInputSegmentHits", m_unpackedNeuroInputSegmentsName,
50 "The name of the StoreArray of the neurotrigger input segment hits",
51 string("CDCTriggerNNInputSegmentHits"));
52 addParam("simNeuroTracksName", m_simNeuroTracksName,
53 "The name of the StoreArray of the neurotrigger tracks from TSIM",
54 string(""));
55 addParam("histogramDirectoryName", m_histogramDirectoryName,
56 "Name of the directory where histograms will be placed",
57 string("TRGCDCTNN"));
58 addParam("simSegmentHitsName", m_simSegmentHitsName,
59 "StoreArray name for simulated TS hits", string(""));
60 addParam("sim2DTracksSWTSName", m_sim2DTracksSWTSName,
61 "StoreArray name for simulated 2D finder tracks using simulated TS", string(""));
62 addParam("simNeuroTracksSWTSSW2DName", m_simNeuroTracksSWTSSW2DName,
63 "StoreArray name for neuro tracks using simulated TS and simulated 2D", string(""));
64 addParam("showRecoTracks", m_showRecoTracks,
65 "switch to turn on a comparison with the reconstruction, DEPRECATED! Use RecoTracks='RecoTracks' (='') instead!",
66 false);
67 addParam("RecoTracks", m_recoTracksName,
68 "Name of the RecoTrack StoreArray. Leave empty for skipping them.",
69 string(""));
70 addParam("recoTrackMultiplicity", m_recoTrackMultiplicity,
71 "Select events with a specific RecoTrack track multiplicity. -1 for all events",
72 -1);
73 addParam("skipWithoutHWTS", m_skipWithoutHWTS,
74 "Switch to skip events without unpacked TS",
75 true);
76 addParam("maxRecoZDist", m_maxRecoZDist,
77 "Select only RecoTracks with a maximum z distance to the IP. -1.0 for all tracks",
78 (double)(- 1.0));
79 addParam("maxRecoD0Dist", m_maxRecoD0Dist,
80 "Select only RecoTracks with a maximum d0 distance to the z axis. -1.0 for all tracks",
81 (double)(- 1.0));
82 addParam("nSameTS", m_nsamets,
83 "Number of identical track segments to be required for matching between HW and SW Neurotrigger",
84 (int)(0));
85}
86
87
88CDCTriggerNeuroDQMModule::~CDCTriggerNeuroDQMModule()
89{
90}
91
92//------------------------------------------------------------------
93// Function to define histograms
94//-----------------------------------------------------------------
95
96void CDCTriggerNeuroDQMModule::defineHisto()
97{
98 // Create a separate histogram directory and cd into it.
99 TDirectory* oldDir = gDirectory;
100 if (m_histogramDirectoryName != "") {
101 oldDir->mkdir(m_histogramDirectoryName.c_str());
102 oldDir->cd(m_histogramDirectoryName.c_str());
103 }
104 //----------------------------------------------------------------
105
106 // define neurotrigger histograms
107 if (m_unpackedNeuroTracksName != "") {
108 m_neuroHWOutZ = new TH1F("NeuroHWOutZ",
109 "z distribution of unpacked neuro tracks; z [cm]",
110 100, -100, 100);
111 m_neuroHWOutCosTheta = new TH1F("NeuroHWOutCosTheta",
112 "cos theta distribution of unpacked neuro tracks; cos(#theta) ",
113 100, -1, 1);
114 m_neuroHWOutPhi0 = new TH1F("NeuroHWOutPhi0",
115 "phi distribution of unpacked neuro tracks; #phi [#circ]",
116 80, 0, 360); // shift to reduce the binning error
117 m_neuroHWOutInvPt = new TH1F("NeuroHWOutInvPt",
118 "Inverse Pt distribution of unpacked neuro tracks; p_{T}^{-1} [GeV^{-1}]",
119 50, 0, 5);
120 m_neuroHWOutPt = new TH1F("NeuroHWOutPt",
121 "Pt distribution of unpacked neuro tracks; p_{T} [GeV]",
122 340, 0, 11);
123 m_neuroHWOutHitPattern = new TH1F("NeuroUnpackedHitPattern",
124 "stereo hit pattern of unpacked neuro tracks; pattern",
125 16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
126 m_neuroHWOutm_time = new TH1F("NeuroHWOutM_time", "m_time distribution of unpacked neuro tracks; clock cycle",
127 48, 0, 48);
128 m_neuroHWOutTrackCount = new TH1F("NeuroHWOutTrackCount",
129 "number of unpacked neuro tracks per event",
130 20, 0, 20);
131 m_neuroHWSector = new TH1F("NeuroHWSector",
132 "sector of unpacked neuro tracks; sector",
133 10, 0, 10);
134
135
136 m_neuroHWInInvPt = new TH1F("NeuroHWInInvPt",
137 "Inverse Pt distribution from incoming 2dtrack; p_{T}^{-1} [GeV^{-1}]",
138 50, 0, 5);
139 m_neuroHWInPhi0 = new TH1F("NeuroHWInPhi0", "Phi0 of incoming 2dtrack; #phi [#circ]",
140 80, 0, 360);
141 m_neuroHWInm_time = new TH1F("NeuroHWInM_time", "m_time distribution from incoming 2dtracks; clock cycle",
142 48, 0, 48);
143 m_neuroHWInTrackCount = new TH1F("NeuroHWInTrackCount", "number of neuro input 2dtracks per event",
144 20, 0, 20);
145 m_neuroHWOutVsInTrackCount = new TH1F("NeuroHWOutVsInTrackCount",
146 "number of neuroHWOutTracks - number of 2dinTracks",
147 20, -10, 10);
148 m_neuroHWInTSID = new TH1F("NeuroHWInTSID", "ID of incoming track segments",
149 2336, 0, 2335);
150 m_neuroHWInTSCount = new TH1F("NeuroHWInTSCount", " number of TS per event",
151 200, 0, 200);
152 m_neuroHWSelTSID = new TH1F("NeuroHWSelTSID", "ID of selected track segments",
153 2336, 0, 2335);
154 m_neuroHWSelTSCount = new TH1F("NeuroHWSelTSCount", "number of selected TS per SL; sl", 9, 0, 9);
155 }
156 if (!m_limitedoutput && m_unpacked2DTracksName != "") {
157 m_2DHWInTSPrioT_Layer0 = new TH1F("2DHWInTSPrioT_Layer0", "Priority time of track segments in layer 0",
158 512, 0, 511);
159 m_2DHWInTSPrioT_Layer2 = new TH1F("2DHWInTSPrioT_Layer2", "Priority time of track segments in layer 2",
160 512, 0, 511);
161 m_2DHWInTSPrioT_Layer4 = new TH1F("2DHWInTSPrioT_Layer4", "Priority time of track segments in layer 4",
162 512, 0, 511);
163 m_2DHWInTSPrioT_Layer6 = new TH1F("2DHWInTSPrioT_Layer6", "Priority time of track segments in layer 6",
164 512, 0, 511);
165 m_2DHWInTSPrioT_Layer8 = new TH1F("2DHWInTSPrioT_Layer8", "Priority time of track segments in layer 8",
166 512, 0, 511);
167 m_2DHWInTSFoundT_Layer0 = new TH1F("2DHWInTSFoundT_Layer0", "Found time of track segments in layer 0",
168 96, -48, 48);
169 m_2DHWInTSFoundT_Layer2 = new TH1F("2DHWInTSFoundT_Layer2", "Found time of track segments in layer 2",
170 96, -48, 48);
171 m_2DHWInTSFoundT_Layer4 = new TH1F("2DHWInTSFoundT_Layer4", "Found time of track segments in layer 4",
172 96, -48, 48);
173 m_2DHWInTSFoundT_Layer6 = new TH1F("2DHWInTSFoundT_Layer6", "Found time of track segments in layer 6",
174 96, -48, 48);
175 m_2DHWInTSFoundT_Layer8 = new TH1F("2DHWInTSFoundT_Layer8", "Found time of track segments in layer 8",
176 96, -48, 48);
177
178
179 m_2DHWInTSPrioB_Layer0 = new TH1F("2DHWInTSPrioB_Layer0", "Priority bits of track segments in layer 0",
180 4, 0, 4);
181 m_2DHWInTSPrioB_Layer2 = new TH1F("2DHWInTSPrioB_Layer2", "Priority bits of track segments in layer 2",
182 4, 0, 4);
183 m_2DHWInTSPrioB_Layer4 = new TH1F("2DHWInTSPrioB_Layer4", "Priority bits of track segments in layer 4",
184 4, 0, 4);
185 m_2DHWInTSPrioB_Layer6 = new TH1F("2DHWInTSPrioB_Layer6", "Priority bits of track segments in layer 6",
186 4, 0, 4);
187 m_2DHWInTSPrioB_Layer8 = new TH1F("2DHWInTSPrioB_Layer8", "Priority bits of track segments in layer 8",
188 4, 0, 4);
189 m_2DHWInTSLR_Layer0 = new TH1F("2DHWInTSLR_Layer0", "Left/Right of track segments in layer 0",
190 4, 0, 4);
191 m_2DHWInTSLR_Layer2 = new TH1F("2DHWInTSLR_Layer2", "Left/Right of track segments in layer 2",
192 4, 0, 4);
193 m_2DHWInTSLR_Layer4 = new TH1F("2DHWInTSLR_Layer4", "Left/Right of track segments in layer 4",
194 4, 0, 4);
195 m_2DHWInTSLR_Layer6 = new TH1F("2DHWInTSLR_Layer6", "Left/Right of track segments in layer 6",
196 4, 0, 4);
197 m_2DHWInTSLR_Layer8 = new TH1F("2DHWInTSLR_Layer8", "Left/Right of track segments in layer 8",
198 4, 0, 4);
199 }
200 if (!m_limitedoutput && m_unpackedNeuroTracksName != "") {
201
202 m_neuroHWOutQuad5Z = new TH1F("NeuroHWOutQuad5Z",
203 "z distribution of neuro tracks; z [cm]",
204 100, -100, 100);
205 m_neuroHWOutQuad5CosTheta = new TH1F("NeuroHWOutQuad5CosTheta",
206 "cos theta distribution of neuro tracks; cos(#theta) ",
207 100, -1, 1);
208 m_neuroHWOutQuad5InvPt = new TH1F("NeuroHWOutQuad5InvPt",
209 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
210 50, 0, 5);
211 m_neuroHWOutQuad5Phi0 = new TH1F("NeuroHWOutQuad5Phi0",
212 "phi distribution from unpacker; #phi [#circ]",
213 80, 0, 360);
214
215 m_neuroHWOutQuad0Z = new TH1F("NeuroHWOutQuad0Z",
216 "z distribution of neuro tracks; z [cm]",
217 100, -100, 100);
218 m_neuroHWOutQuad0CosTheta = new TH1F("NeuroHWOutQuad0CosTheta",
219 "cos theta distribution of neuro tracks; cos(#theta) ",
220 100, -1, 1);
221 m_neuroHWOutQuad0InvPt = new TH1F("NeuroHWOutQuad0InvPt",
222 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
223 50, 0, 5);
224 m_neuroHWOutQuad0Phi0 = new TH1F("NeuroHWOutQuad0Phi0",
225 "phi distribution from unpacker; #phi [#circ]",
226 80, 0, 360);
227
228 m_neuroHWOutQuad1Z = new TH1F("NeuroHWOutQuad1Z",
229 "z distribution of neuro tracks; z [cm]",
230 100, -100, 100);
231 m_neuroHWOutQuad1CosTheta = new TH1F("NeuroHWOutQuad1CosTheta",
232 "cos theta distribution of neuro tracks; cos(#theta) ",
233 100, -1, 1);
234 m_neuroHWOutQuad1Phi0 = new TH1F("NeuroHWOutQuad1Phi0",
235 "phi distribution from unpacker; #phi [#circ]",
236 80, 0, 360);
237 m_neuroHWOutQuad1InvPt = new TH1F("NeuroHWOutQuad1InvPt",
238 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
239 50, 0, 5);
240
241 m_neuroHWOutQuad2Z = new TH1F("NeuroHWOutQuad2Z",
242 "z distribution of neuro tracks; z [cm]",
243 100, -100, 100);
244 m_neuroHWOutQuad2CosTheta = new TH1F("NeuroHWOutQuad2CosTheta",
245 "cos theta distribution of neuro tracks; cos(#theta) ",
246 100, -1, 1);
247 m_neuroHWOutQuad2Phi0 = new TH1F("NeuroHWOutQuad2Phi0",
248 "phi distribution from unpacker; #phi [#circ]",
249 80, 0, 360);
250 m_neuroHWOutQuad2InvPt = new TH1F("NeuroHWOutQuad2InvPt",
251 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
252 50, 0, 5);
253
254 m_neuroHWOutQuad3Z = new TH1F("NeuroHWOutQuad3Z",
255 "z distribution of neuro tracks; z [cm]",
256 100, -100, 100);
257 m_neuroHWOutQuad3CosTheta = new TH1F("NeuroHWOutQuad3CosTheta",
258 "cos theta distribution of neuro tracks; cos(#theta) ",
259 100, -1, 1);
260 m_neuroHWOutQuad3Phi0 = new TH1F("NeuroHWOutQuad3Phi0",
261 "phi distribution from unpacker; #phi [#circ]",
262 80, 0, 360);
263 m_neuroHWOutQuad3InvPt = new TH1F("NeuroHWOutQuad3InvPt",
264 "Pt distribution from unpacker; p_{T}^{-1} [GeV^{-1}]",
265 50, 0, 5);
266 m_neuroHWInTSPrioT_Layer0 = new TH1F("NeuroHWInTSPrioT_Layer0", "Priority time of track segments in layer 0",
267 512, 0, 511);
268 m_neuroHWInTSPrioT_Layer1 = new TH1F("NeuroHWInTSPrioT_Layer1", "Priority time of track segments in layer 1",
269 512, 0, 511);
270 m_neuroHWInTSPrioT_Layer2 = new TH1F("NeuroHWInTSPrioT_Layer2", "Priority time of track segments in layer 2",
271 512, 0, 511);
272 m_neuroHWInTSPrioT_Layer3 = new TH1F("NeuroHWInTSPrioT_Layer3", "Priority time of track segments in layer 3",
273 512, 0, 511);
274 m_neuroHWInTSPrioT_Layer4 = new TH1F("NeuroHWInTSPrioT_Layer4", "Priority time of track segments in layer 4",
275 512, 0, 511);
276 m_neuroHWInTSPrioT_Layer5 = new TH1F("NeuroHWInTSPrioT_Layer5", "Priority time of track segments in layer 5",
277 512, 0, 511);
278 m_neuroHWInTSPrioT_Layer6 = new TH1F("NeuroHWInTSPrioT_Layer6", "Priority time of track segments in layer 6",
279 512, 0, 511);
280 m_neuroHWInTSPrioT_Layer7 = new TH1F("NeuroHWInTSPrioT_Layer7", "Priority time of track segments in layer 7",
281 512, 0, 511);
282 m_neuroHWInTSPrioT_Layer8 = new TH1F("NeuroHWInTSPrioT_Layer8", "Priority time of track segments in layer 8",
283 512, 0, 511);
284 m_neuroHWInTSFoundT_Layer0 = new TH1F("NeuroHWInTSFoundT_Layer0", "Found time of track segments in layer 0",
285 48, 0, 48);
286 m_neuroHWInTSFoundT_Layer1 = new TH1F("NeuroHWInTSFoundT_Layer1", "Found time of track segments in layer 1",
287 48, 0, 48);
288 m_neuroHWInTSFoundT_Layer2 = new TH1F("NeuroHWInTSFoundT_Layer2", "Found time of track segments in layer 2",
289 48, 0, 48);
290 m_neuroHWInTSFoundT_Layer3 = new TH1F("NeuroHWInTSFoundT_Layer3", "Found time of track segments in layer 3",
291 48, 0, 48);
292 m_neuroHWInTSFoundT_Layer4 = new TH1F("NeuroHWInTSFoundT_Layer4", "Found time of track segments in layer 4",
293 48, 0, 48);
294 m_neuroHWInTSFoundT_Layer5 = new TH1F("NeuroHWInTSFoundT_Layer5", "Found time of track segments in layer 5",
295 48, 0, 48);
296 m_neuroHWInTSFoundT_Layer6 = new TH1F("NeuroHWInTSFoundT_Layer6", "Found time of track segments in layer 6",
297 48, 0, 48);
298 m_neuroHWInTSFoundT_Layer7 = new TH1F("NeuroHWInTSFoundT_Layer7", "Found time of track segments in layer 7",
299 48, 0, 48);
300 m_neuroHWInTSFoundT_Layer8 = new TH1F("NeuroHWInTSFoundT_Layer8", "Found time of track segments in layer 8",
301 48, 0, 48);
302
303
304 m_neuroHWInTSPrioB_Layer0 = new TH1F("NeuroHWInTSPrioB_Layer0", "Priority bits of track segments in layer 0",
305 4, 0, 4);
306 m_neuroHWInTSPrioB_Layer1 = new TH1F("NeuroHWInTSPrioB_Layer1", "Priority bits of track segments in layer 1",
307 4, 0, 4);
308 m_neuroHWInTSPrioB_Layer2 = new TH1F("NeuroHWInTSPrioB_Layer2", "Priority bits of track segments in layer 2",
309 4, 0, 4);
310 m_neuroHWInTSPrioB_Layer3 = new TH1F("NeuroHWInTSPrioB_Layer3", "Priority bits of track segments in layer 3",
311 4, 0, 4);
312 m_neuroHWInTSPrioB_Layer4 = new TH1F("NeuroHWInTSPrioB_Layer4", "Priority bits of track segments in layer 4",
313 4, 0, 4);
314 m_neuroHWInTSPrioB_Layer5 = new TH1F("NeuroHWInTSPrioB_Layer5", "Priority bits of track segments in layer 5",
315 4, 0, 4);
316 m_neuroHWInTSPrioB_Layer6 = new TH1F("NeuroHWInTSPrioB_Layer6", "Priority bits of track segments in layer 6",
317 4, 0, 4);
318 m_neuroHWInTSPrioB_Layer7 = new TH1F("NeuroHWInTSPrioB_Layer7", "Priority bits of track segments in layer 7",
319 4, 0, 4);
320 m_neuroHWInTSPrioB_Layer8 = new TH1F("NeuroHWInTSPrioB_Layer8", "Priority bits of track segments in layer 8",
321 4, 0, 4);
322
323
324 m_neuroHWInTSLR_Layer0 = new TH1F("NeuroHWInTSLR_Layer0", "Left/Right of track segments in layer 0",
325 4, 0, 4);
326 m_neuroHWInTSLR_Layer1 = new TH1F("NeuroHWInTSLR_Layer1", "Left/Right of track segments in layer 1",
327 4, 0, 4);
328 m_neuroHWInTSLR_Layer2 = new TH1F("NeuroHWInTSLR_Layer2", "Left/Right of track segments in layer 2",
329 4, 0, 4);
330 m_neuroHWInTSLR_Layer3 = new TH1F("NeuroHWInTSLR_Layer3", "Left/Right of track segments in layer 3",
331 4, 0, 4);
332 m_neuroHWInTSLR_Layer4 = new TH1F("NeuroHWInTSLR_Layer4", "Left/Right of track segments in layer 4",
333 4, 0, 4);
334 m_neuroHWInTSLR_Layer5 = new TH1F("NeuroHWInTSLR_Layer5", "Left/Right of track segments in layer 5",
335 4, 0, 4);
336 m_neuroHWInTSLR_Layer6 = new TH1F("NeuroHWInTSLR_Layer6", "Left/Right of track segments in layer 6",
337 4, 0, 4);
338 m_neuroHWInTSLR_Layer7 = new TH1F("NeuroHWInTSLR_Layer7", "Left/Right of track segments in layer 7",
339 4, 0, 4);
340 m_neuroHWInTSLR_Layer8 = new TH1F("NeuroHWInTSLR_Layer8", "Left/Right of track segments in layer 8",
341 4, 0, 4);
342 m_neuroHWSelTSPrioT_Layer0 = new TH1F("NeuroHWSelTSPrioT_Layer0", "Priority time of track segments in layer 0",
343 512, 0, 511);
344 m_neuroHWSelTSPrioT_Layer1 = new TH1F("NeuroHWSelTSPrioT_Layer1", "Priority time of track segments in layer 1",
345 512, 0, 511);
346 m_neuroHWSelTSPrioT_Layer2 = new TH1F("NeuroHWSelTSPrioT_Layer2", "Priority time of track segments in layer 2",
347 512, 0, 511);
348 m_neuroHWSelTSPrioT_Layer3 = new TH1F("NeuroHWSelTSPrioT_Layer3", "Priority time of track segments in layer 3",
349 512, 0, 511);
350 m_neuroHWSelTSPrioT_Layer4 = new TH1F("NeuroHWSelTSPrioT_Layer4", "Priority time of track segments in layer 4",
351 512, 0, 511);
352 m_neuroHWSelTSPrioT_Layer5 = new TH1F("NeuroHWSelTSPrioT_Layer5", "Priority time of track segments in layer 5",
353 512, 0, 511);
354 m_neuroHWSelTSPrioT_Layer6 = new TH1F("NeuroHWSelTSPrioT_Layer6", "Priority time of track segments in layer 6",
355 512, 0, 511);
356 m_neuroHWSelTSPrioT_Layer7 = new TH1F("NeuroHWSelTSPrioT_Layer7", "Priority time of track segments in layer 7",
357 512, 0, 511);
358 m_neuroHWSelTSPrioT_Layer8 = new TH1F("NeuroHWSelTSPrioT_Layer8", "Priority time of track segments in layer 8",
359 512, 0, 511);
360 m_neuroHWSelTSFoundT_Layer0 = new TH1F("NeuroHWSelTSFoundT_Layer0",
361 "First found time of selected TS - found time of Neuro Track in SL 0",
362 96, -47.99, 48.01);
363 m_neuroHWSelTSFoundT_Layer1 = new TH1F("NeuroHWSelTSFoundT_Layer1",
364 "First found time of selected TS - found time of Neuro Track in SL 1",
365 96, -47.99, 48.01);
366 m_neuroHWSelTSFoundT_Layer2 = new TH1F("NeuroHWSelTSFoundT_Layer2",
367 "First found time of selected TS - found time of Neuro Track in SL 2",
368 96, -47.99, 48.01);
369 m_neuroHWSelTSFoundT_Layer3 = new TH1F("NeuroHWSelTSFoundT_Layer3",
370 "First found time of selected TS - found time of Neuro Track in SL 3",
371 96, -47.99, 48.01);
372 m_neuroHWSelTSFoundT_Layer4 = new TH1F("NeuroHWSelTSFoundT_Layer4",
373 "First found time of selected TS - found time of Neuro Track in SL 4",
374 96, -47.99, 48.01);
375 m_neuroHWSelTSFoundT_Layer5 = new TH1F("NeuroHWSelTSFoundT_Layer5",
376 "First found time of selected TS - found time of Neuro Track in SL 5",
377 96, -47.99, 48.01);
378 m_neuroHWSelTSFoundT_Layer6 = new TH1F("NeuroHWSelTSFoundT_Layer6",
379 "First found time of selected TS - found time of Neuro Track in SL 6",
380 96, -47.99, 48.01);
381 m_neuroHWSelTSFoundT_Layer7 = new TH1F("NeuroHWSelTSFoundT_Layer7",
382 "First found time of selected TS - found time of Neuro Track in SL 7",
383 96, -47.99, 48.01);
384 m_neuroHWSelTSFoundT_Layer8 = new TH1F("NeuroHWSelTSFoundT_Layer8",
385 "First found time of selected TS - found time of Neuro Track in SL 8",
386 96, -47.99, 48.01);
387
388
389 m_neuroHWSelTSPrioB_Layer0 = new TH1F("NeuroHWSelTSPrioB_Layer0", "Priority bits of track segments in layer 0",
390 4, 0, 4);
391 m_neuroHWSelTSPrioB_Layer1 = new TH1F("NeuroHWSelTSPrioB_Layer1", "Priority bits of track segments in layer 1",
392 4, 0, 4);
393 m_neuroHWSelTSPrioB_Layer2 = new TH1F("NeuroHWSelTSPrioB_Layer2", "Priority bits of track segments in layer 2",
394 4, 0, 4);
395 m_neuroHWSelTSPrioB_Layer3 = new TH1F("NeuroHWSelTSPrioB_Layer3", "Priority bits of track segments in layer 3",
396 4, 0, 4);
397 m_neuroHWSelTSPrioB_Layer4 = new TH1F("NeuroHWSelTSPrioB_Layer4", "Priority bits of track segments in layer 4",
398 4, 0, 4);
399 m_neuroHWSelTSPrioB_Layer5 = new TH1F("NeuroHWSelTSPrioB_Layer5", "Priority bits of track segments in layer 5",
400 4, 0, 4);
401 m_neuroHWSelTSPrioB_Layer6 = new TH1F("NeuroHWSelTSPrioB_Layer6", "Priority bits of track segments in layer 6",
402 4, 0, 4);
403 m_neuroHWSelTSPrioB_Layer7 = new TH1F("NeuroHWSelTSPrioB_Layer7", "Priority bits of track segments in layer 7",
404 4, 0, 4);
405 m_neuroHWSelTSPrioB_Layer8 = new TH1F("NeuroHWSelTSPrioB_Layer8", "Priority bits of track segments in layer 8",
406 4, 0, 4);
407
408
409 m_neuroHWSelTSLR_Layer0 = new TH1F("NeuroHWSelTSLR_Layer0", "Left/Right of track segments in layer 0",
410 4, 0, 4);
411 m_neuroHWSelTSLR_Layer1 = new TH1F("NeuroHWSelTSLR_Layer1", "Left/Right of track segments in layer 1",
412 4, 0, 4);
413 m_neuroHWSelTSLR_Layer2 = new TH1F("NeuroHWSelTSLR_Layer2", "Left/Right of track segments in layer 2",
414 4, 0, 4);
415 m_neuroHWSelTSLR_Layer3 = new TH1F("NeuroHWSelTSLR_Layer3", "Left/Right of track segments in layer 3",
416 4, 0, 4);
417 m_neuroHWSelTSLR_Layer4 = new TH1F("NeuroHWSelTSLR_Layer4", "Left/Right of track segments in layer 4",
418 4, 0, 4);
419 m_neuroHWSelTSLR_Layer5 = new TH1F("NeuroHWSelTSLR_Layer5", "Left/Right of track segments in layer 5",
420 4, 0, 4);
421 m_neuroHWSelTSLR_Layer6 = new TH1F("NeuroHWSelTSLR_Layer6", "Left/Right of track segments in layer 6",
422 4, 0, 4);
423 m_neuroHWSelTSLR_Layer7 = new TH1F("NeuroHWSelTSLR_Layer7", "Left/Right of track segments in layer 7",
424 4, 0, 4);
425 m_neuroHWSelTSLR_Layer8 = new TH1F("NeuroHWSelTSLR_Layer8", "Left/Right of track segments in layer 8",
426 4, 0, 4);
427 m_neuroHWInputID_Layer0 = new TH1F("NeuroHWInputID_Layer0",
428 "unpacked id input in layer 0; id",
429 100, -1, 1);
430 m_neuroHWInputT_Layer0 = new TH1F("NeuroHWInputT_Layer0",
431 "unpacked time input in layer 0; time",
432 100, -1, 1);
433 m_neuroHWInputAlpha_Layer0 = new TH1F("NeuroHWInputAlpha_Layer0",
434 "unpacked alpha input in layer 0; alpha",
435 100, -1, 1);
436 m_neuroHWInputID_Layer1 = new TH1F("NeuroHWInputID_Layer1",
437 "unpacked id input in layer 1; id",
438 100, -1, 1);
439 m_neuroHWInputT_Layer1 = new TH1F("NeuroHWInputT_Layer1",
440 "unpacked time input in layer 1; time",
441 100, -1, 1);
442 m_neuroHWInputAlpha_Layer1 = new TH1F("NeuroHWInputAlpha_Layer1",
443 "unpacked alpha input in layer 1; alpha",
444 100, -1, 1);
445 m_neuroHWInputID_Layer2 = new TH1F("NeuroHWInputID_Layer2",
446 "unpacked id input in layer 2; id",
447 100, -1, 1);
448 m_neuroHWInputT_Layer2 = new TH1F("NeuroHWInputT_Layer2",
449 "unpacked time input in layer 2; time",
450 100, -1, 1);
451 m_neuroHWInputAlpha_Layer2 = new TH1F("NeuroHWInputAlpha_Layer2",
452 "unpacked alpha input in layer 2; alpha",
453 100, -1, 1);
454 m_neuroHWInputID_Layer3 = new TH1F("NeuroHWInputID_Layer3",
455 "unpacked id input in layer 3; id",
456 100, -1, 1);
457 m_neuroHWInputT_Layer3 = new TH1F("NeuroHWInputT_Layer3",
458 "unpacked time input in layer 3; time",
459 100, -1, 1);
460 m_neuroHWInputAlpha_Layer3 = new TH1F("NeuroHWInputAlpha_Layer3",
461 "unpacked alpha input in layer 3; alpha",
462 100, -1, 1);
463 m_neuroHWInputID_Layer4 = new TH1F("NeuroHWInputID_Layer4",
464 "unpacked id input in layer 4; id",
465 100, -1, 1);
466 m_neuroHWInputT_Layer4 = new TH1F("NeuroHWInputT_Layer4",
467 "unpacked time input in layer 4; time",
468 100, -1, 1);
469 m_neuroHWInputAlpha_Layer4 = new TH1F("NeuroHWInputAlpha_Layer4",
470 "unpacked alpha input in layer 4; alpha",
471 100, -1, 1);
472 m_neuroHWInputID_Layer5 = new TH1F("NeuroHWInputID_Layer5",
473 "unpacked id input in layer 5; id",
474 100, -1, 1);
475 m_neuroHWInputT_Layer5 = new TH1F("NeuroHWInputT_Layer5",
476 "unpacked time input in layer 5; time",
477 100, -1, 1);
478 m_neuroHWInputAlpha_Layer5 = new TH1F("NeuroHWInputAlpha_Layer5",
479 "unpacked alpha input in layer 5; alpha",
480 100, -1, 1);
481 m_neuroHWInputID_Layer6 = new TH1F("NeuroHWInputID_Layer6",
482 "unpacked id input in layer 6; id",
483 100, -1, 1);
484 m_neuroHWInputT_Layer6 = new TH1F("NeuroHWInputT_Layer6",
485 "unpacked time input in layer 6; time",
486 100, -1, 1);
487 m_neuroHWInputAlpha_Layer6 = new TH1F("NeuroHWInputAlpha_Layer6",
488 "unpacked alpha input in layer 6; alpha",
489 100, -1, 1);
490 m_neuroHWInputID_Layer7 = new TH1F("NeuroHWInputID_Layer7",
491 "unpacked id input in layer 7; id",
492 100, -1, 1);
493 m_neuroHWInputT_Layer7 = new TH1F("NeuroHWInputT_Layer7",
494 "unpacked time input in layer 7; time",
495 100, -1, 1);
496 m_neuroHWInputAlpha_Layer7 = new TH1F("NeuroHWInputAlpha_Layer7",
497 "unpacked alpha input in layer 7; alpha",
498 100, -1, 1);
499 m_neuroHWInputID_Layer8 = new TH1F("NeuroHWInputID_Layer8",
500 "unpacked id input in layer 8; id",
501 100, -1, 1);
502 m_neuroHWInputT_Layer8 = new TH1F("NeuroHWInputT_Layer8",
503 "unpacked time input in layer 8; time",
504 100, -1, 1);
505 m_neuroHWInputAlpha_Layer8 = new TH1F("NeuroHWInputAlpha_Layer8",
506 "unpacked alpha input in layer 8; alpha",
507 100, -1, 1);
508 }
509 if (m_unpacked2DTracksName != "") {
510 m_2DHWOutInvPt = new TH1F("2DHWOutInvPt",
511 "Inverse Pt of 2dtracks; p_{T}^{-1} [GeV^{-1}]",
512 50, 0, 5);
513 m_2DHWOutPhi0 = new TH1F("2DHWOutPhi0", "Phi0 of 2dtracks; #phi [#circ]",
514 80, 0, 360);
515 m_2DHWOutm_time = new TH1F("2DHWOutM_time", "m_time of 2dtracks; clock cycle",
516 96, -48, 48);
517 m_2DHWOutTrackCount = new TH1F("2DHWOutTrackCount", "number of 2dtracks per event", 20, 0, 20);
518 m_neuroHWInVs2DOutTrackCount = new TH1F("NeuroHWInVs2DOutTrackCount", "neuro in tracks - 2d out tracks",
519 20, -10, 10);
520 }
521
522 if (!m_limitedoutput && m_simNeuroTracksName != "") {
523 m_neuroSWOutZ = new TH1F("NeuroSWOutZ",
524 "z distribution from simulation, hw TS hw 2D; z [cm]",
525 100, -100, 100);
526 m_neuroSWOutCosTheta = new TH1F("NeuroSWOutCosTheta",
527 "cos theta distribution from simulation, hw TS hw 2D; cos(#theta) ",
528 100, -1, 1);
529 m_neuroSWOutInvPt = new TH1F("NeuroSWOutInvPt",
530 "Inverse Pt distribution from simulation, hw TS hw 2D; p_{T}^{-1} [GeV^{-1}]",
531 50, 0, 5);
532 m_neuroSWOutPhi0 = new TH1F("NeuroSWOutPhi0",
533 "phi distribution from simulation, hw TS hw 2D; #phi [#circ]",
534 80, 0, 360); // shift to reduce the binning error
535 m_neuroSWOutHitPattern = new TH1F("NeuroSWOutHitPattern",
536 "stereo hit pattern of simulated neuro tracks, hw TS hw 2D; pattern",
537 16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
538 m_neuroSWOutTrackCount = new TH1F("NeuroSWOutTrackCount",
539 "number of neuro tracks per event from simulation, hw TS hw 2D",
540 20, 0, 20);
541 m_neuroSWSector = new TH1F("NeuroSWSector",
542 "sector of simulated neuro tracks, hw TS hw 2D; sector",
543 10, 0, 10);
544 // hw TS selected by sw NN
545 m_neuroSWSelTSID = new TH1F("NeuroSWSelTSID", "ID of selected track segments",
546 2336, 0, 2335);
547 m_neuroSWSelTSCount = new TH1F("NeuroSWSelTSCount", "number of selected TS per SL; sl", 9, 0, 9);
548 m_neuroSWSelTSPrioT_Layer0 = new TH1F("NeuroSWSelTSPrioT_Layer0", "Priority time of track segments in layer 0",
549 512, 0, 511);
550 m_neuroSWSelTSPrioT_Layer1 = new TH1F("NeuroSWSelTSPrioT_Layer1", "Priority time of track segments in layer 1",
551 512, 0, 511);
552 m_neuroSWSelTSPrioT_Layer2 = new TH1F("NeuroSWSelTSPrioT_Layer2", "Priority time of track segments in layer 2",
553 512, 0, 511);
554 m_neuroSWSelTSPrioT_Layer3 = new TH1F("NeuroSWSelTSPrioT_Layer3", "Priority time of track segments in layer 3",
555 512, 0, 511);
556 m_neuroSWSelTSPrioT_Layer4 = new TH1F("NeuroSWSelTSPrioT_Layer4", "Priority time of track segments in layer 4",
557 512, 0, 511);
558 m_neuroSWSelTSPrioT_Layer5 = new TH1F("NeuroSWSelTSPrioT_Layer5", "Priority time of track segments in layer 5",
559 512, 0, 511);
560 m_neuroSWSelTSPrioT_Layer6 = new TH1F("NeuroSWSelTSPrioT_Layer6", "Priority time of track segments in layer 6",
561 512, 0, 511);
562 m_neuroSWSelTSPrioT_Layer7 = new TH1F("NeuroSWSelTSPrioT_Layer7", "Priority time of track segments in layer 7",
563 512, 0, 511);
564 m_neuroSWSelTSPrioT_Layer8 = new TH1F("NeuroSWSelTSPrioT_Layer8", "Priority time of track segments in layer 8",
565 512, 0, 511);
566 m_neuroSWSelTSFoundT_Layer0 = new TH1F("NeuroSWSelTSFoundT_Layer0",
567 "First found time of selected TS - found time of Neuro Track in SL 0",
568 96, -47.99, 48.01);
569 m_neuroSWSelTSFoundT_Layer1 = new TH1F("NeuroSWSelTSFoundT_Layer1",
570 "First found time of selected TS - found time of Neuro Track in SL 1",
571 96, -47.99, 48.01);
572 m_neuroSWSelTSFoundT_Layer2 = new TH1F("NeuroSWSelTSFoundT_Layer2",
573 "First found time of selected TS - found time of Neuro Track in SL 2",
574 96, -47.99, 48.01);
575 m_neuroSWSelTSFoundT_Layer3 = new TH1F("NeuroSWSelTSFoundT_Layer3",
576 "First found time of selected TS - found time of Neuro Track in SL 3",
577 96, -47.99, 48.01);
578 m_neuroSWSelTSFoundT_Layer4 = new TH1F("NeuroSWSelTSFoundT_Layer4",
579 "First found time of selected TS - found time of Neuro Track in SL 4",
580 96, -47.99, 48.01);
581 m_neuroSWSelTSFoundT_Layer5 = new TH1F("NeuroSWSelTSFoundT_Layer5",
582 "First found time of selected TS - found time of Neuro Track in SL 5",
583 96, -47.99, 48.01);
584 m_neuroSWSelTSFoundT_Layer6 = new TH1F("NeuroSWSelTSFoundT_Layer6",
585 "First found time of selected TS - found time of Neuro Track in SL 6",
586 96, -47.99, 48.01);
587 m_neuroSWSelTSFoundT_Layer7 = new TH1F("NeuroSWSelTSFoundT_Layer7",
588 "First found time of selected TS - found time of Neuro Track in SL 7",
589 96, -47.99, 48.01);
590 m_neuroSWSelTSFoundT_Layer8 = new TH1F("NeuroSWSelTSFoundT_Layer8",
591 "First found time of selected TS - found time of Neuro Track in SL 8",
592 96, -47.99, 48.01);
593
594
595 m_neuroSWSelTSPrioB_Layer0 = new TH1F("NeuroSWSelTSPrioB_Layer0", "Priority bits of track segments in layer 0",
596 4, 0, 4);
597 m_neuroSWSelTSPrioB_Layer1 = new TH1F("NeuroSWSelTSPrioB_Layer1", "Priority bits of track segments in layer 1",
598 4, 0, 4);
599 m_neuroSWSelTSPrioB_Layer2 = new TH1F("NeuroSWSelTSPrioB_Layer2", "Priority bits of track segments in layer 2",
600 4, 0, 4);
601 m_neuroSWSelTSPrioB_Layer3 = new TH1F("NeuroSWSelTSPrioB_Layer3", "Priority bits of track segments in layer 3",
602 4, 0, 4);
603 m_neuroSWSelTSPrioB_Layer4 = new TH1F("NeuroSWSelTSPrioB_Layer4", "Priority bits of track segments in layer 4",
604 4, 0, 4);
605 m_neuroSWSelTSPrioB_Layer5 = new TH1F("NeuroSWSelTSPrioB_Layer5", "Priority bits of track segments in layer 5",
606 4, 0, 4);
607 m_neuroSWSelTSPrioB_Layer6 = new TH1F("NeuroSWSelTSPrioB_Layer6", "Priority bits of track segments in layer 6",
608 4, 0, 4);
609 m_neuroSWSelTSPrioB_Layer7 = new TH1F("NeuroSWSelTSPrioB_Layer7", "Priority bits of track segments in layer 7",
610 4, 0, 4);
611 m_neuroSWSelTSPrioB_Layer8 = new TH1F("NeuroSWSelTSPrioB_Layer8", "Priority bits of track segments in layer 8",
612 4, 0, 4);
613
614
615 m_neuroSWSelTSLR_Layer0 = new TH1F("NeuroSWSelTSLR_Layer0", "Left/Right of track segments in layer 0",
616 4, 0, 4);
617 m_neuroSWSelTSLR_Layer1 = new TH1F("NeuroSWSelTSLR_Layer1", "Left/Right of track segments in layer 1",
618 4, 0, 4);
619 m_neuroSWSelTSLR_Layer2 = new TH1F("NeuroSWSelTSLR_Layer2", "Left/Right of track segments in layer 2",
620 4, 0, 4);
621 m_neuroSWSelTSLR_Layer3 = new TH1F("NeuroSWSelTSLR_Layer3", "Left/Right of track segments in layer 3",
622 4, 0, 4);
623 m_neuroSWSelTSLR_Layer4 = new TH1F("NeuroSWSelTSLR_Layer4", "Left/Right of track segments in layer 4",
624 4, 0, 4);
625 m_neuroSWSelTSLR_Layer5 = new TH1F("NeuroSWSelTSLR_Layer5", "Left/Right of track segments in layer 5",
626 4, 0, 4);
627 m_neuroSWSelTSLR_Layer6 = new TH1F("NeuroSWSelTSLR_Layer6", "Left/Right of track segments in layer 6",
628 4, 0, 4);
629 m_neuroSWSelTSLR_Layer7 = new TH1F("NeuroSWSelTSLR_Layer7", "Left/Right of track segments in layer 7",
630 4, 0, 4);
631 m_neuroSWSelTSLR_Layer8 = new TH1F("NeuroSWSelTSLR_Layer8", "Left/Right of track segments in layer 8",
632 4, 0, 4);
633
634 m_neuroSWInputID_Layer0 = new TH1F("NeuroSWInputID_Layer0",
635 "simulated id input in layer 0; id",
636 100, -1, 1);
637 m_neuroSWInputT_Layer0 = new TH1F("NeuroSWInputT_Layer0",
638 "simulated time input in layer 0; time",
639 100, -1, 1);
640 m_neuroSWInputAlpha_Layer0 = new TH1F("NeuroSWInputAlpha_Layer0",
641 "simulated alpha input in layer 0; alpha",
642 100, -1, 1);
643 m_neuroSWInputID_Layer1 = new TH1F("NeuroSWInputID_Layer1",
644 "simulated id input in layer 1; id",
645 100, -1, 1);
646 m_neuroSWInputT_Layer1 = new TH1F("NeuroSWInputT_Layer1",
647 "simulated time input in layer 1; time",
648 100, -1, 1);
649 m_neuroSWInputAlpha_Layer1 = new TH1F("NeuroSWInputAlpha_Layer1",
650 "simulated alpha input in layer 1; alpha",
651 100, -1, 1);
652 m_neuroSWInputID_Layer2 = new TH1F("NeuroSWInputID_Layer2",
653 "simulated id input in layer 2; id",
654 100, -1, 1);
655 m_neuroSWInputT_Layer2 = new TH1F("NeuroSWInputT_Layer2",
656 "simulated time input in layer 2; time",
657 100, -1, 1);
658 m_neuroSWInputAlpha_Layer2 = new TH1F("NeuroSWInputAlpha_Layer2",
659 "simulated alpha input in layer 2; alpha",
660 100, -1, 1);
661 m_neuroSWInputID_Layer3 = new TH1F("NeuroSWInputID_Layer3",
662 "simulated id input in layer 3; id",
663 100, -1, 1);
664 m_neuroSWInputT_Layer3 = new TH1F("NeuroSWInputT_Layer3",
665 "simulated time input in layer 3; time",
666 100, -1, 1);
667 m_neuroSWInputAlpha_Layer3 = new TH1F("NeuroSWInputAlpha_Layer3",
668 "simulated alpha input in layer 3; alpha",
669 100, -1, 1);
670 m_neuroSWInputID_Layer4 = new TH1F("NeuroSWInputID_Layer4",
671 "simulated id input in layer 4; id",
672 100, -1, 1);
673 m_neuroSWInputT_Layer4 = new TH1F("NeuroSWInputT_Layer4",
674 "simulated time input in layer 4; time",
675 100, -1, 1);
676 m_neuroSWInputAlpha_Layer4 = new TH1F("NeuroSWInputAlpha_Layer4",
677 "simulated alpha input in layer 4; alpha",
678 100, -1, 1);
679 m_neuroSWInputID_Layer5 = new TH1F("NeuroSWInputID_Layer5",
680 "simulated id input in layer 5; id",
681 100, -1, 1);
682 m_neuroSWInputT_Layer5 = new TH1F("NeuroSWInputT_Layer5",
683 "simulated time input in layer 5; time",
684 100, -1, 1);
685 m_neuroSWInputAlpha_Layer5 = new TH1F("NeuroSWInputAlpha_Layer5",
686 "simulated alpha input in layer 5; alpha",
687 100, -1, 1);
688 m_neuroSWInputID_Layer6 = new TH1F("NeuroSWInputID_Layer6",
689 "simulated id input in layer 6; id",
690 100, -1, 1);
691 m_neuroSWInputT_Layer6 = new TH1F("NeuroSWInputT_Layer6",
692 "simulated time input in layer 6; time",
693 100, -1, 1);
694 m_neuroSWInputAlpha_Layer6 = new TH1F("NeuroSWInputAlpha_Layer6",
695 "simulated alpha input in layer 6; alpha",
696 100, -1, 1);
697 m_neuroSWInputID_Layer7 = new TH1F("NeuroSWInputID_Layer7",
698 "simulated id input in layer 7; id",
699 100, -1, 1);
700 m_neuroSWInputT_Layer7 = new TH1F("NeuroSWInputT_Layer7",
701 "simulated time input in layer 7; time",
702 100, -1, 1);
703 m_neuroSWInputAlpha_Layer7 = new TH1F("NeuroSWInputAlpha_Layer7",
704 "simulated alpha input in layer 7; alpha",
705 100, -1, 1);
706 m_neuroSWInputID_Layer8 = new TH1F("NeuroSWInputID_Layer8",
707 "simulated id input in layer 8; id",
708 100, -1, 1);
709 m_neuroSWInputT_Layer8 = new TH1F("NeuroSWInputT_Layer8",
710 "simulated time input in layer 8; time",
711 100, -1, 1);
712 m_neuroSWInputAlpha_Layer8 = new TH1F("NeuroSWInputAlpha_Layer8",
713 "simulated alpha input in layer 8; alpha",
714 100, -1, 1);
715 }
716
717 if (!m_limitedoutput && m_sim2DTracksSWTSName != "") {
718
719 m_2DSWOutInvPt = new TH1F("2DSWOutInvPt",
720 "Inverse Pt of 2dtracks from simulation, sw TS sw 2D; p_{T}^{-1} [GeV^{-1}]",
721 50, 0, 5);
722 m_2DSWOutPhi0 = new TH1F("2DSWOutPhi0", "Phi0 of 2dtracks from simulation, sw TS sw 2D; #phi [#circ]",
723 80, 0, 360);
724 m_2DSWOutm_time = new TH1F("2DSWOutM_time", "m_time of 2dtracks from simulation, sw TS sw 2D; clock cycle",
725 96, -48, 48);
726 m_2DSWOutTrackCount = new TH1F("2DSWOutTrackCount", "number of 2dtracks per event from simulation, sw TS sw 2D", 20, 0, 20);
727
728 }
729 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
730
731 m_neuroSWTSSW2DOutZ = new TH1F("NeuroSWTSSW2DOutZ",
732 "z distribution from simulation, sw TS sw 2D; z [cm]",
733 100, -100, 100);
734 m_neuroSWTSSW2DOutCosTheta = new TH1F("NeuroSWTSSW2DOutCosTheta",
735 "cos theta distribution from simulation, sw TS sw 2D; cos(#theta) ",
736 100, -1, 1);
737 m_neuroSWTSSW2DOutInvPt = new TH1F("NeuroSWTSSW2DOutInvPt",
738 "Inverse Pt distribution from simulation, sw TS sw 2D; p_{T}^{-1} [GeV^{-1}]",
739 50, 0, 5);
740 m_neuroSWTSSW2DOutPhi0 = new TH1F("NeuroSWTSSW2DOutPhi0",
741 "phi distribution from simulation, sw TS sw 2D; #phi [#circ]",
742 80, 0, 360);
743 m_neuroSWTSSW2DOutHitPattern = new TH1F("NeuroSWTSSW2DOutHitPattern",
744 "stereo hit pattern of simulated neuro tracks, sw TS sw 2D; pattern",
745 16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
746 m_neuroSWTSSW2DOutTrackCount = new TH1F("NeuroSWTSSW2DOutTrackCount",
747 "number of simulated neuro tracks per event, sw TS sw 2D",
748 20, 0, 20);
749 m_neuroSWTSSW2DSector = new TH1F("NeuroSWTSSW2DSector",
750 "sector of simulated neuro tracks, sw TS sw 2D; sector",
751 10, 0, 10);
752 // sw TS incoming
753 m_neuroSWTSSW2DInTSID = new TH1F("NeuroSWTSSW2DInTSID", "ID of simulated track segments",
754 2336, 0, 2335);
755 m_neuroSWTSSW2DInTSCount = new TH1F("NeuroSWTSSW2DInTSCount", "number of simulated TS per event", 200, 0, 800);
756 m_neuroSWTSSW2DInTSPrioT_Layer0 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer0", "Priority time of track segments in layer 0",
757 512, 0, 511);
758 m_neuroSWTSSW2DInTSPrioT_Layer1 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer1", "Priority time of track segments in layer 1",
759 512, 0, 511);
760 m_neuroSWTSSW2DInTSPrioT_Layer2 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer2", "Priority time of track segments in layer 2",
761 512, 0, 511);
762 m_neuroSWTSSW2DInTSPrioT_Layer3 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer3", "Priority time of track segments in layer 3",
763 512, 0, 511);
764 m_neuroSWTSSW2DInTSPrioT_Layer4 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer4", "Priority time of track segments in layer 4",
765 512, 0, 511);
766 m_neuroSWTSSW2DInTSPrioT_Layer5 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer5", "Priority time of track segments in layer 5",
767 512, 0, 511);
768 m_neuroSWTSSW2DInTSPrioT_Layer6 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer6", "Priority time of track segments in layer 6",
769 512, 0, 511);
770 m_neuroSWTSSW2DInTSPrioT_Layer7 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer7", "Priority time of track segments in layer 7",
771 512, 0, 511);
772 m_neuroSWTSSW2DInTSPrioT_Layer8 = new TH1F("NeuroSWTSSW2DInTSPrioT_Layer8", "Priority time of track segments in layer 8",
773 512, 0, 511);
774 m_neuroSWTSSW2DInTSFoundT_Layer0 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer0",
775 "First found time of selected TS - found time of Neuro Track in SL 0",
776 96, -47.99, 48.01);
777 m_neuroSWTSSW2DInTSFoundT_Layer1 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer1",
778 "First found time of selected TS - found time of Neuro Track in SL 1",
779 96, -47.99, 48.01);
780 m_neuroSWTSSW2DInTSFoundT_Layer2 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer2",
781 "First found time of selected TS - found time of Neuro Track in SL 2",
782 96, -47.99, 48.01);
783 m_neuroSWTSSW2DInTSFoundT_Layer3 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer3",
784 "First found time of selected TS - found time of Neuro Track in SL 3",
785 96, -47.99, 48.01);
786 m_neuroSWTSSW2DInTSFoundT_Layer4 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer4",
787 "First found time of selected TS - found time of Neuro Track in SL 4",
788 96, -47.99, 48.01);
789 m_neuroSWTSSW2DInTSFoundT_Layer5 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer5",
790 "First found time of selected TS - found time of Neuro Track in SL 5",
791 96, -47.99, 48.01);
792 m_neuroSWTSSW2DInTSFoundT_Layer6 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer6",
793 "First found time of selected TS - found time of Neuro Track in SL 6",
794 96, -47.99, 48.01);
795 m_neuroSWTSSW2DInTSFoundT_Layer7 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer7",
796 "First found time of selected TS - found time of Neuro Track in SL 7",
797 96, -47.99, 48.01);
798 m_neuroSWTSSW2DInTSFoundT_Layer8 = new TH1F("NeuroSWTSSW2DInTSFoundT_Layer8",
799 "First found time of selected TS - found time of Neuro Track in SL 8",
800 96, -47.99, 48.01);
801
802
803 m_neuroSWTSSW2DInTSPrioB_Layer0 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer0", "Priority bits of track segments in layer 0",
804 4, 0, 4);
805 m_neuroSWTSSW2DInTSPrioB_Layer1 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer1", "Priority bits of track segments in layer 1",
806 4, 0, 4);
807 m_neuroSWTSSW2DInTSPrioB_Layer2 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer2", "Priority bits of track segments in layer 2",
808 4, 0, 4);
809 m_neuroSWTSSW2DInTSPrioB_Layer3 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer3", "Priority bits of track segments in layer 3",
810 4, 0, 4);
811 m_neuroSWTSSW2DInTSPrioB_Layer4 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer4", "Priority bits of track segments in layer 4",
812 4, 0, 4);
813 m_neuroSWTSSW2DInTSPrioB_Layer5 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer5", "Priority bits of track segments in layer 5",
814 4, 0, 4);
815 m_neuroSWTSSW2DInTSPrioB_Layer6 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer6", "Priority bits of track segments in layer 6",
816 4, 0, 4);
817 m_neuroSWTSSW2DInTSPrioB_Layer7 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer7", "Priority bits of track segments in layer 7",
818 4, 0, 4);
819 m_neuroSWTSSW2DInTSPrioB_Layer8 = new TH1F("NeuroSWTSSW2DInTSPrioB_Layer8", "Priority bits of track segments in layer 8",
820 4, 0, 4);
821
822
823 m_neuroSWTSSW2DInTSLR_Layer0 = new TH1F("NeuroSWTSSW2DInTSLR_Layer0", "Left/Right of track segments in layer 0",
824 4, 0, 4);
825 m_neuroSWTSSW2DInTSLR_Layer1 = new TH1F("NeuroSWTSSW2DInTSLR_Layer1", "Left/Right of track segments in layer 1",
826 4, 0, 4);
827 m_neuroSWTSSW2DInTSLR_Layer2 = new TH1F("NeuroSWTSSW2DInTSLR_Layer2", "Left/Right of track segments in layer 2",
828 4, 0, 4);
829 m_neuroSWTSSW2DInTSLR_Layer3 = new TH1F("NeuroSWTSSW2DInTSLR_Layer3", "Left/Right of track segments in layer 3",
830 4, 0, 4);
831 m_neuroSWTSSW2DInTSLR_Layer4 = new TH1F("NeuroSWTSSW2DInTSLR_Layer4", "Left/Right of track segments in layer 4",
832 4, 0, 4);
833 m_neuroSWTSSW2DInTSLR_Layer5 = new TH1F("NeuroSWTSSW2DInTSLR_Layer5", "Left/Right of track segments in layer 5",
834 4, 0, 4);
835 m_neuroSWTSSW2DInTSLR_Layer6 = new TH1F("NeuroSWTSSW2DInTSLR_Layer6", "Left/Right of track segments in layer 6",
836 4, 0, 4);
837 m_neuroSWTSSW2DInTSLR_Layer7 = new TH1F("NeuroSWTSSW2DInTSLR_Layer7", "Left/Right of track segments in layer 7",
838 4, 0, 4);
839 m_neuroSWTSSW2DInTSLR_Layer8 = new TH1F("NeuroSWTSSW2DInTSLR_Layer8", "Left/Right of track segments in layer 8",
840 4, 0, 4);
841
842
843 // sw TS selected
844 m_neuroSWTSSW2DSelTSID = new TH1F("NeuroSWTSSW2DSelTSID", "ID of selected track segments",
845 2336, 0, 2335);
846 m_neuroSWTSSW2DSelTSCount = new TH1F("NeuroSWTSSW2DSelTSCount", "number of selected TS per SL; sl", 9, 0, 9);
847 m_neuroSWTSSW2DSelTSPrioT_Layer0 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer0", "Priority time of track segments in layer 0",
848 512, 0, 511);
849 m_neuroSWTSSW2DSelTSPrioT_Layer1 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer1", "Priority time of track segments in layer 1",
850 512, 0, 511);
851 m_neuroSWTSSW2DSelTSPrioT_Layer2 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer2", "Priority time of track segments in layer 2",
852 512, 0, 511);
853 m_neuroSWTSSW2DSelTSPrioT_Layer3 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer3", "Priority time of track segments in layer 3",
854 512, 0, 511);
855 m_neuroSWTSSW2DSelTSPrioT_Layer4 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer4", "Priority time of track segments in layer 4",
856 512, 0, 511);
857 m_neuroSWTSSW2DSelTSPrioT_Layer5 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer5", "Priority time of track segments in layer 5",
858 512, 0, 511);
859 m_neuroSWTSSW2DSelTSPrioT_Layer6 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer6", "Priority time of track segments in layer 6",
860 512, 0, 511);
861 m_neuroSWTSSW2DSelTSPrioT_Layer7 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer7", "Priority time of track segments in layer 7",
862 512, 0, 511);
863 m_neuroSWTSSW2DSelTSPrioT_Layer8 = new TH1F("NeuroSWTSSW2DSelTSPrioT_Layer8", "Priority time of track segments in layer 8",
864 512, 0, 511);
865 m_neuroSWTSSW2DSelTSFoundT_Layer0 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer0",
866 "First found time of selected TS - found time of Neuro Track in SL 0",
867 96, -47.99, 48.01);
868 m_neuroSWTSSW2DSelTSFoundT_Layer1 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer1",
869 "First found time of selected TS - found time of Neuro Track in SL 1",
870 96, -47.99, 48.01);
871 m_neuroSWTSSW2DSelTSFoundT_Layer2 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer2",
872 "First found time of selected TS - found time of Neuro Track in SL 2",
873 96, -47.99, 48.01);
874 m_neuroSWTSSW2DSelTSFoundT_Layer3 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer3",
875 "First found time of selected TS - found time of Neuro Track in SL 3",
876 96, -47.99, 48.01);
877 m_neuroSWTSSW2DSelTSFoundT_Layer4 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer4",
878 "First found time of selected TS - found time of Neuro Track in SL 4",
879 96, -47.99, 48.01);
880 m_neuroSWTSSW2DSelTSFoundT_Layer5 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer5",
881 "First found time of selected TS - found time of Neuro Track in SL 5",
882 96, -47.99, 48.01);
883 m_neuroSWTSSW2DSelTSFoundT_Layer6 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer6",
884 "First found time of selected TS - found time of Neuro Track in SL 6",
885 96, -47.99, 48.01);
886 m_neuroSWTSSW2DSelTSFoundT_Layer7 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer7",
887 "First found time of selected TS - found time of Neuro Track in SL 7",
888 96, -47.99, 48.01);
889 m_neuroSWTSSW2DSelTSFoundT_Layer8 = new TH1F("NeuroSWTSSW2DSelTSFoundT_Layer8",
890 "First found time of selected TS - found time of Neuro Track in SL 8",
891 96, -47.99, 48.01);
892
893
894 m_neuroSWTSSW2DSelTSPrioB_Layer0 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer0", "Priority bits of track segments in layer 0",
895 4, 0, 4);
896 m_neuroSWTSSW2DSelTSPrioB_Layer1 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer1", "Priority bits of track segments in layer 1",
897 4, 0, 4);
898 m_neuroSWTSSW2DSelTSPrioB_Layer2 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer2", "Priority bits of track segments in layer 2",
899 4, 0, 4);
900 m_neuroSWTSSW2DSelTSPrioB_Layer3 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer3", "Priority bits of track segments in layer 3",
901 4, 0, 4);
902 m_neuroSWTSSW2DSelTSPrioB_Layer4 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer4", "Priority bits of track segments in layer 4",
903 4, 0, 4);
904 m_neuroSWTSSW2DSelTSPrioB_Layer5 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer5", "Priority bits of track segments in layer 5",
905 4, 0, 4);
906 m_neuroSWTSSW2DSelTSPrioB_Layer6 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer6", "Priority bits of track segments in layer 6",
907 4, 0, 4);
908 m_neuroSWTSSW2DSelTSPrioB_Layer7 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer7", "Priority bits of track segments in layer 7",
909 4, 0, 4);
910 m_neuroSWTSSW2DSelTSPrioB_Layer8 = new TH1F("NeuroSWTSSW2DSelTSPrioB_Layer8", "Priority bits of track segments in layer 8",
911 4, 0, 4);
912
913
914 m_neuroSWTSSW2DSelTSLR_Layer0 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer0", "Left/Right of track segments in layer 0",
915 4, 0, 4);
916 m_neuroSWTSSW2DSelTSLR_Layer1 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer1", "Left/Right of track segments in layer 1",
917 4, 0, 4);
918 m_neuroSWTSSW2DSelTSLR_Layer2 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer2", "Left/Right of track segments in layer 2",
919 4, 0, 4);
920 m_neuroSWTSSW2DSelTSLR_Layer3 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer3", "Left/Right of track segments in layer 3",
921 4, 0, 4);
922 m_neuroSWTSSW2DSelTSLR_Layer4 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer4", "Left/Right of track segments in layer 4",
923 4, 0, 4);
924 m_neuroSWTSSW2DSelTSLR_Layer5 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer5", "Left/Right of track segments in layer 5",
925 4, 0, 4);
926 m_neuroSWTSSW2DSelTSLR_Layer6 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer6", "Left/Right of track segments in layer 6",
927 4, 0, 4);
928 m_neuroSWTSSW2DSelTSLR_Layer7 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer7", "Left/Right of track segments in layer 7",
929 4, 0, 4);
930 m_neuroSWTSSW2DSelTSLR_Layer8 = new TH1F("NeuroSWTSSW2DSelTSLR_Layer8", "Left/Right of track segments in layer 8",
931 4, 0, 4);
932 m_neuroSWTSSW2DInputID_Layer0 = new TH1F("NeuroSWTSSW2DInputID_Layer0",
933 "simulated id input in layer 0; id",
934 100, -1, 1);
935 m_neuroSWTSSW2DInputT_Layer0 = new TH1F("NeuroSWTSSW2DInputT_Layer0",
936 "simulated time input in layer 0; time",
937 100, -1, 1);
938 m_neuroSWTSSW2DInputAlpha_Layer0 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer0",
939 "simulated alpha input in layer 0; alpha",
940 100, -1, 1);
941 m_neuroSWTSSW2DInputID_Layer1 = new TH1F("NeuroSWTSSW2DInputID_Layer1",
942 "simulated id input in layer 1; id",
943 100, -1, 1);
944 m_neuroSWTSSW2DInputT_Layer1 = new TH1F("NeuroSWTSSW2DInputT_Layer1",
945 "simulated time input in layer 1; time",
946 100, -1, 1);
947 m_neuroSWTSSW2DInputAlpha_Layer1 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer1",
948 "simulated alpha input in layer 1; alpha",
949 100, -1, 1);
950 m_neuroSWTSSW2DInputID_Layer2 = new TH1F("NeuroSWTSSW2DInputID_Layer2",
951 "simulated id input in layer 2; id",
952 100, -1, 1);
953 m_neuroSWTSSW2DInputT_Layer2 = new TH1F("NeuroSWTSSW2DInputT_Layer2",
954 "simulated time input in layer 2; time",
955 100, -1, 1);
956 m_neuroSWTSSW2DInputAlpha_Layer2 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer2",
957 "simulated alpha input in layer 2; alpha",
958 100, -1, 1);
959 m_neuroSWTSSW2DInputID_Layer3 = new TH1F("NeuroSWTSSW2DInputID_Layer3",
960 "simulated id input in layer 3; id",
961 100, -1, 1);
962 m_neuroSWTSSW2DInputT_Layer3 = new TH1F("NeuroSWTSSW2DInputT_Layer3",
963 "simulated time input in layer 3; time",
964 100, -1, 1);
965 m_neuroSWTSSW2DInputAlpha_Layer3 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer3",
966 "simulated alpha input in layer 3; alpha",
967 100, -1, 1);
968 m_neuroSWTSSW2DInputID_Layer4 = new TH1F("NeuroSWTSSW2DInputID_Layer4",
969 "simulated id input in layer 4; id",
970 100, -1, 1);
971 m_neuroSWTSSW2DInputT_Layer4 = new TH1F("NeuroSWTSSW2DInputT_Layer4",
972 "simulated time input in layer 4; time",
973 100, -1, 1);
974 m_neuroSWTSSW2DInputAlpha_Layer4 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer4",
975 "simulated alpha input in layer 4; alpha",
976 100, -1, 1);
977 m_neuroSWTSSW2DInputID_Layer5 = new TH1F("NeuroSWTSSW2DInputID_Layer5",
978 "simulated id input in layer 5; id",
979 100, -1, 1);
980 m_neuroSWTSSW2DInputT_Layer5 = new TH1F("NeuroSWTSSW2DInputT_Layer5",
981 "simulated time input in layer 5; time",
982 100, -1, 1);
983 m_neuroSWTSSW2DInputAlpha_Layer5 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer5",
984 "simulated alpha input in layer 5; alpha",
985 100, -1, 1);
986 m_neuroSWTSSW2DInputID_Layer6 = new TH1F("NeuroSWTSSW2DInputID_Layer6",
987 "simulated id input in layer 6; id",
988 100, -1, 1);
989 m_neuroSWTSSW2DInputT_Layer6 = new TH1F("NeuroSWTSSW2DInputT_Layer6",
990 "simulated time input in layer 6; time",
991 100, -1, 1);
992 m_neuroSWTSSW2DInputAlpha_Layer6 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer6",
993 "simulated alpha input in layer 6; alpha",
994 100, -1, 1);
995 m_neuroSWTSSW2DInputID_Layer7 = new TH1F("NeuroSWTSSW2DInputID_Layer7",
996 "simulated id input in layer 7; id",
997 100, -1, 1);
998 m_neuroSWTSSW2DInputT_Layer7 = new TH1F("NeuroSWTSSW2DInputT_Layer7",
999 "simulated time input in layer 7; time",
1000 100, -1, 1);
1001 m_neuroSWTSSW2DInputAlpha_Layer7 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer7",
1002 "simulated alpha input in layer 7; alpha",
1003 100, -1, 1);
1004 m_neuroSWTSSW2DInputID_Layer8 = new TH1F("NeuroSWTSSW2DInputID_Layer8",
1005 "simulated id input in layer 8; id",
1006 100, -1, 1);
1007 m_neuroSWTSSW2DInputT_Layer8 = new TH1F("NeuroSWTSSW2DInputT_Layer8",
1008 "simulated time input in layer 8; time",
1009 100, -1, 1);
1010 m_neuroSWTSSW2DInputAlpha_Layer8 = new TH1F("NeuroSWTSSW2DInputAlpha_Layer8",
1011 "simulated alpha input in layer 8; alpha",
1012 100, -1, 1);
1013 }
1014
1015
1016
1017 if (!m_limitedoutput && m_unpackedNeuroTracksName != "" && m_simNeuroTracksName != "") {
1018 m_neuroDeltaZ = new TH1F("NeuroDeltaZ",
1019 "difference between unpacked and simulated neuro z; #Delta z [cm]",
1020 100, -100, 100); // should be bit-precise, so look at very small range
1021 m_neuroDeltaTheta = new TH1F("NeuroDeltaTheta",
1022 "difference between unpacked and simulated neuro theta; #Delta #theta [#circ]",
1023 100, -180, 180); // should be bit-precise, so look at very small range
1024 m_neuroScatterZ = new TH2F("NeuroScatterZ",
1025 "unpacked z vs TSIM; hw z [cm]; sw z [cm]",
1026 100, -150, 150, 100, -150, 150);
1027 m_neuroScatterTheta = new TH2F("NeuroScatterTheta",
1028 "unpacked theta vs TSIM; hw #theta [#circ]; sw #theta [#circ]",
1029 100, 0, 270, 100, 0, 270);
1030
1031 m_neuroDeltaInputID = new TH1F("NeuroDeltaInputID",
1032 "difference between unpacked and simulated ID input; #Delta ID",
1033 100, -0.5, 0.5); // should be bit-precise, so look at very small range
1034 m_neuroDeltaInputT = new TH1F("NeuroDeltaInputT",
1035 "difference between unpacked and simulated time input; #Delta t",
1036 100, -0.5, 0.5); // should be bit-precise, so look at very small range
1037 m_neuroDeltaInputAlpha = new TH1F("NeuroDeltaInputAlpha",
1038 "difference between unpacked and simulated alpha input; #Delta alpha",
1039 100, -0.1, 0.1); // should be bit-precise, so look at very small range
1040 m_neuroDeltaTSID = new TH1F("NeuroDeltaTSID",
1041 "difference between unpacked and simulated tsid; #Delta TSID",
1042 100, -50, 50);
1043 m_neuroDeltaSector = new TH1F("NeuroDeltaSector",
1044 "difference between unpacked and simulated sector; #Delta sector",
1045 20, -10, 10);
1046 m_simSameTS = new TH1F("NeuroSimSameTS",
1047 "number of TS selected in both, unpacked and TSIM tracks",
1048 20, 0, 20);
1049 m_simDiffTS = new TH1F("NeuroSimDiffTS",
1050 "number of TS selcted in TSIM but not in unpacker",
1051 20, 0, 20);
1052 }
1053
1054 if (m_recoTracksName != "") {
1055 //RecoTracks
1056 m_RecoZ = new TH1F("RecoZ",
1057 "z distribution of reconstructed tracks;z [cm]",
1058 100, -150, 150);
1059 m_RecoCosTheta = new TH1F("RecoCosTheta",
1060 "cos theta distribution of reconstructed tracks; cos(#theta) ",
1061 100, -1, 1);
1062 m_RecoInvPt = new TH1F("RecoInvPt",
1063 "Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1064 50, 0, 5);
1065 m_RecoPhi = new TH1F("RecoPhi",
1066 "phi distribution of reconstructed tracks ; #phi [#circ]",
1067 80, 0, 360);
1068 m_RecoD0 = new TH1F("RecoD0",
1069 "d0 distribution of reconstructed tracks ; d_{0} [cm]",
1070 100, 0, 10);
1071 m_RecoTrackCount = new TH1F("RecoTrackCount",
1072 "number of reconstructed tracks per event",
1073 20, 0, 20);
1074 }
1075 if (m_recoTracksName != "" && m_unpackedNeuroTracksName != "") {
1076 //RecoTracks matched to unpacked neuro tracks
1077 m_RecoHWZ = new TH1F("RecoHWZ",
1078 "hw matched z distribution of reconstructed tracks; z [cm]",
1079 100, -150, 150);
1080 m_RecoHWCosTheta = new TH1F("RecoHWCosTheta",
1081 "hw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1082 100, -1, 1);
1083 m_RecoHWInvPt = new TH1F("RecoHWInvPt",
1084 "hw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1085 50, 0, 5);
1086 m_RecoHWPhi = new TH1F("RecoHWPhi",
1087 "hw matched phi distribution of reconstructed tracks; #phi [#circ]",
1088 80, 0, 360);
1089 m_RecoHWD0 = new TH1F("RecoHWD0",
1090 "hw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1091 100, 0, 10);
1092 // hw neuro values for tracks matched to reco tracks
1093 m_neuroRecoHWOutZ = new TH1F("NeuroRecoHWOutZ",
1094 "reco matched z distribution of unpacked neuro tracks; z [cm]",
1095 100, -100, 100);
1096 m_neuroRecoHWOutCosTheta = new TH1F("NeuroRecoHWOutCosTheta",
1097 "reco matched cos theta distribution of unpacked neuro tracks; cos(#theta) ",
1098 100, -1, 1);
1099 m_neuroRecoHWOutInvPt = new TH1F("NeuroRecoHWOutInvPt",
1100 "reco matched Pt distribution of unpacked neuro tracks; p_{T}^{-1} [GeV^{-1}]",
1101 50, 0, 5);
1102 m_neuroRecoHWOutPhi0 = new TH1F("NeuroRecoHWOutPhi0",
1103 "reco matched phi distribution of unpacked neuro tracks; #phi [#circ]",
1104 80, 0, 360); // shift to reduce the binning error
1105 m_neuroRecoHWOutHitPattern = new TH1F("NeuroRecoUnpackedHitPattern",
1106 "reco matched stereo hit pattern of unpacked neuro tracks; pattern",
1107 16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
1108 m_neuroRecoHWOutTrackCount = new TH1F("NeuroRecoHWOutTrackCount",
1109 "reco matched number of unpacked neuro tracks per event",
1110 20, 0, 20);
1111 m_neuroRecoHWSector = new TH1F("NeuroRecoHWSector",
1112 "reco matched sector of unpacked neuro tracks; sector",
1113 10, 0, 10);
1114
1115
1116 m_DeltaRecoHWZ = new TH1F("DeltaRecoHWZ",
1117 "difference between reconstructed and unpacked neuro z; #Delta z [cm]",
1118 100, -100, 100);
1119 m_DeltaRecoHWCosTheta = new TH1F("DeltaRecoHWCosTheta",
1120 "difference between reconstructed and unpacked neuro cos(theta); #Delta cos(#theta)",
1121 100, -1, 1);
1122 m_DeltaRecoHWInvPt = new TH1F("DeltaRecoHWInvPt",
1123 "difference between reconstructed and unpacked neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1124 100, -10, 10);
1125 m_DeltaRecoHWPhi = new TH1F("DeltaRecoHWPhi",
1126 "difference between reconstructed and unpacked neuro phi; #Delta #phi [#circ]",
1127 80, -180, 180);
1128 }
1129 if (!m_limitedoutput && m_recoTracksName != "" && m_unpackedNeuroTracksName != "") {
1130 m_RecoHWZScatter = new TH2F("RecoHWZScatter",
1131 "hw matched reconstruction; reco z [cm]; hw z [cm]",
1132 100, -150, 150, 100, -150, 150);
1133 }
1134
1135
1136
1137 if (!m_limitedoutput && m_simNeuroTracksName != "") {
1138 //RecoTracks matched to simulated neuro tracks (hw TS hw 2D sw NN)
1139 m_RecoSWZ = new TH1F("RecoSWZ",
1140 "sw matched z distribution of reconstructed tracks; z [cm]",
1141 100, -150, 150); // 1cm bins from -50cm to 50cm
1142 m_RecoSWCosTheta = new TH1F("RecoSWCosTheta",
1143 "sw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1144 100, -1, 1);
1145 m_RecoSWInvPt = new TH1F("RecoSWInvPt",
1146 "sw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1147 50, 0, 5);
1148 m_RecoSWPhi = new TH1F("RecoSWPhi",
1149 "sw matched phi distribution of reconstructed tracks ; #phi [#circ]",
1150 80, 0, 360);
1151 m_RecoSWD0 = new TH1F("RecoSWD0",
1152 "sw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1153 100, 0, 10);
1154 m_RecoSWZScatter = new TH2F("RecoSWZScatter",
1155 "sw matched reconstruction; reco z [cm]; sw z [cm]",
1156 100, -150, 150, 100, -150, 150);
1157
1158
1159 // sw neuro values for tracks matched to reco tracks
1160 m_neuroRecoSWOutZ = new TH1F("NeuroRecoSWOutZ",
1161 "reco matched z distribution from simulation; z [cm]",
1162 100, -100, 100);
1163 m_neuroRecoSWOutCosTheta = new TH1F("NeuroRecoSWOutCosTheta",
1164 "reco matched cos theta distribution from simulation; cos(#theta) ",
1165 100, -1, 1);
1166 m_neuroRecoSWOutInvPt = new TH1F("NeuroRecoSWOutInvPt",
1167 "reco matched Pt distribution from simulation; p_{T}^{-1} [GeV^{-1}]",
1168 50, 0, 5);
1169 m_neuroRecoSWOutPhi0 = new TH1F("NeuroRecoSWOutPhi0",
1170 "reco matched phi distribution from simulation; #phi [#circ]",
1171 80, 0, 360); // shift to reduce the binning error
1172 m_neuroRecoSWOutHitPattern = new TH1F("NeuroRecoSWHitPattern",
1173 "reco matched stereo hit pattern from simulation; pattern",
1174 16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
1175 m_neuroRecoSWOutTrackCount = new TH1F("NeuroRecoSWOutTrackCount",
1176 "reco matched number of SW neuro tracks per event",
1177 20, 0, 20);
1178 m_neuroRecoSWSector = new TH1F("NeuroRecoSWSector",
1179 "reco matched sector from simulation; sector",
1180 10, 0, 10);
1181
1182
1183 m_DeltaRecoSWZ = new TH1F("DeltaRecoSWZ",
1184 "difference between reconstructed and simulated neuro z; #Delta z [cm]",
1185 100, -100, 100);
1186 m_DeltaRecoSWCosTheta = new TH1F("DeltaRecoSWCosTheta",
1187 "difference between reconstructed and simulated neuro cos(theta); #Delta cos(#theta)",
1188 100, -1, 1);
1189 m_DeltaRecoSWInvPt = new TH1F("DeltaRecoSWInvPt",
1190 "difference between reconstructed and simulated neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1191 100, -10, 10);
1192 m_DeltaRecoSWPhi = new TH1F("DeltaRecoSWPhi",
1193 "difference between reconstructed and simulated neuro phi; #Delta #phi [#circ]",
1194 80, -180, 180);
1195 }
1196
1197
1198 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
1199 //RecoTracks matched to simulated neuro tracks (sw TS sw 2D sw NN)
1200 m_RecoSWTSSW2DZ = new TH1F("RecoSWTSSW2DZ",
1201 "sw matched z distribution of reconstructed tracks; z [cm]",
1202 100, -150, 150); // 1cm bins from -50cm to 50cm
1203 m_RecoSWTSSW2DCosTheta = new TH1F("RecoSWTSSW2DCosTheta",
1204 "sw matched cos theta distribution of reconstructed tracks; cos(#theta) ",
1205 100, -1, 1);
1206 m_RecoSWTSSW2DInvPt = new TH1F("RecoSWTSSW2DInvPt",
1207 "sw matched Pt distribution of reconstructed tracks; p_{T}^{-1} [GeV^{-1}]",
1208 50, 0, 5);
1209 m_RecoSWTSSW2DPhi = new TH1F("RecoSWTSSW2DPhi",
1210 "sw matched phi distribution of reconstructed tracks ; #phi [#circ]",
1211 80, 0, 360);
1212 m_RecoSWTSSW2DD0 = new TH1F("RecoSWTSSW2DD0",
1213 "sw matched d0 distribution of reconstructed tracks ; d_{0} [cm]",
1214 100, 0, 10);
1215 m_RecoSWTSSW2DZScatter = new TH2F("RecoSWTSSW2DZScatter",
1216 "sw matched reconstruction; reco z [cm]; sw z [cm]",
1217 100, -150, 150, 100, -150, 150);
1218
1219
1220 // sw neuro values for tracks matched to reco tracks (sw TS, sw 2D)
1221 m_neuroRecoSWTSSW2DOutZ = new TH1F("NeuroRecoSWTSSW2DOutZ",
1222 "reco matched z distribution from simulation; z [cm]",
1223 100, -100, 100);
1224 m_neuroRecoSWTSSW2DOutCosTheta = new TH1F("NeuroRecoSWTSSW2DOutCosTheta",
1225 "reco matched cos theta distribution from simulation; cos(#theta) ",
1226 100, -1, 1);
1227 m_neuroRecoSWTSSW2DOutInvPt = new TH1F("NeuroRecoSWTSSW2DOutInvPt",
1228 "reco matched Pt distribution from simulation; p_{T}^{-1} [GeV^{-1}]",
1229 50, 0, 5);
1230 m_neuroRecoSWTSSW2DOutPhi0 = new TH1F("NeuroRecoSWTSSW2DOutPhi0",
1231 "reco matched phi distribution from simulation; #phi [#circ]",
1232 80, 0, 360); // shift to reduce the binning error
1233 m_neuroRecoSWTSSW2DOutHitPattern = new TH1F("NeuroRecoSWTSSW2DHitPattern",
1234 "reco matched stereo hit pattern from simulation; pattern",
1235 16, 0, 16); // 4 stereo layers -> 2**4 possible patterns
1236 m_neuroRecoSWTSSW2DOutTrackCount = new TH1F("NeuroRecoSWTSSW2DOutTrackCount",
1237 "reco matched number of SW neuro tracks per event",
1238 20, 0, 20);
1239 m_neuroRecoSWTSSW2DSector = new TH1F("NeuroRecoSWTSSW2DSector",
1240 "reco matched sector from simulation; sector",
1241 10, 0, 10);
1242
1243
1244 m_DeltaRecoSWTSSW2DZ = new TH1F("DeltaRecoSWTSSW2DZ",
1245 "difference between reconstructed and simulated neuro z; #Delta z [cm]",
1246 100, -100, 100);
1247 m_DeltaRecoSWTSSW2DCosTheta = new TH1F("DeltaRecoSWTSSW2DCosTheta",
1248 "difference between reconstructed and simulated neuro cos(theta); #Delta cos(#theta)",
1249 100, -1, 1);
1250 m_DeltaRecoSWTSSW2DInvPt = new TH1F("DeltaRecoSWTSSW2DInvPt",
1251 "difference between reconstructed and simulated neuro Pt; #Delta p_{T}^{-1} [GeV^{-1}]",
1252 100, -10, 10);
1253 m_DeltaRecoSWTSSW2DPhi = new TH1F("DeltaRecoSWTSSW2DPhi",
1254 "difference between reconstructed and simulated neuro phi;#Delta #phi [#circ]",
1255 80, -180, 180);
1256 }
1257
1258 // cd back to root directory
1259 oldDir->cd();
1260}
1261
1262
1263void CDCTriggerNeuroDQMModule::initialize()
1264{
1265 // Register histograms (calls back defineHisto)
1266 REG_HISTOGRAM
1267 m_eventTime.isRequired("CDCTriggerNeuroETFT0");
1268 if (m_showRecoTracks && m_recoTracksName == "") {
1269 m_recoTracksName = "RecoTracks";
1270 }
1271 if (m_unpackedSegmentHitsName != "") {
1272 m_unpackedSegmentHits.isRequired(m_unpackedSegmentHitsName);
1273 }
1274 if (m_unpacked2DTracksName != "") {
1275 m_unpacked2DTracks.isRequired(m_unpacked2DTracksName);
1276 }
1277 if (m_unpackedNeuroTracksName != "") {
1278 m_unpackedNeuroTracks.isRequired(m_unpackedNeuroTracksName);
1279 m_unpackedNeuroInput2DTracks.isRequired(m_unpackedNeuroInput2DTracksName);
1280 m_unpackedNeuroInputSegments.isRequired(m_unpackedNeuroInputSegmentsName);
1281 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputSegments);
1282 m_unpackedNeuroInput2DTracks.requireRelationTo(m_unpackedNeuroTracks);
1283 m_unpackedNeuroInputVectorName = m_unpackedNeuroTracksName + "Input";
1284 m_unpackedNeuroInputVector.isRequired(m_unpackedNeuroInputVectorName);
1285 m_unpackedNeuroTracks.requireRelationTo(m_unpackedNeuroInputVector);
1286 }
1287
1288 if (!m_limitedoutput && m_simNeuroTracksName != "") {
1289 m_simNeuroInputVectorName = m_simNeuroTracksName + "Input";
1290 m_simNeuroTracks.isRequired(m_simNeuroTracksName);
1291 m_simNeuroInputVector.isRequired(m_simNeuroInputVectorName);
1292 m_unpackedNeuroInput2DTracks.requireRelationTo(m_simNeuroTracks);
1293 m_simNeuroTracks.requireRelationTo(m_simNeuroInputVector);
1294 m_simNeuroTracks.requireRelationTo(m_unpackedNeuroInputSegments);
1295 }
1296 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
1297 m_simSegmentHits.isRequired(m_simSegmentHitsName);
1298 m_sim2DTracksSWTS.isRequired(m_sim2DTracksSWTSName);
1299 m_simNeuroInputVectorSWTSSW2DName = m_simNeuroTracksSWTSSW2DName + "Input";
1300 m_simNeuroTracksSWTSSW2D.isRequired(m_simNeuroTracksSWTSSW2DName);
1301 m_simNeuroInputVectorSWTSSW2D.isRequired(m_simNeuroInputVectorSWTSSW2DName);
1302 m_simNeuroTracksSWTSSW2D.requireRelationTo(m_simNeuroInputVectorSWTSSW2D);
1303 m_simNeuroTracksSWTSSW2D.requireRelationTo(m_simSegmentHits);
1304 m_sim2DTracksSWTS.requireRelationTo(m_simNeuroTracksSWTSSW2D);
1305 }
1306 if (m_recoTracksName != "") {
1307 m_RecoTracks.isRequired("RecoTracks");
1308 m_RecoTracks.requireRelationTo(m_unpackedNeuroTracks);
1309 }
1310 if (!m_limitedoutput && m_recoTracksName != "" && m_simNeuroTracksName != "") {
1311 m_RecoTracks.requireRelationTo(m_simNeuroTracks);
1312 }
1313 if (!m_limitedoutput && m_recoTracksName != "" && m_simNeuroTracksSWTSSW2DName != "") {
1314 m_RecoTracks.requireRelationTo(m_simNeuroTracksSWTSSW2D);
1315 }
1316}
1317
1318void CDCTriggerNeuroDQMModule::beginRun()
1319{
1320 // Just to make sure, reset all the histograms.
1321 if (m_unpackedNeuroTracksName != "") {
1322
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();
1333
1334 m_neuroHWInInvPt->Reset();
1335 m_neuroHWInPhi0->Reset();
1336 m_neuroHWInm_time->Reset();
1337 m_neuroHWInTrackCount->Reset();
1338
1339 m_neuroHWInTSID->Reset();
1340 m_neuroHWInTSCount->Reset();
1341
1342 m_neuroHWSelTSID->Reset();
1343 m_neuroHWSelTSCount->Reset();
1344 }
1345 if (m_unpacked2DTracksName != "") {
1346 m_2DHWOutInvPt->Reset();
1347 m_2DHWOutPhi0->Reset();
1348 m_2DHWOutm_time->Reset();
1349 m_2DHWOutTrackCount->Reset();
1350
1351 }
1352 if (m_unpacked2DTracksName != "" && m_unpackedNeuroTracksName != "") {
1353 m_neuroHWInVs2DOutTrackCount->Reset();
1354 }
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();
1376
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();
1395
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();
1414
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();
1433
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();
1452
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();
1480 }
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();
1489 }
1490 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
1491 m_2DSWOutInvPt->Reset();
1492 m_2DSWOutPhi0->Reset();
1493 m_2DSWOutm_time->Reset();
1494 m_2DSWOutTrackCount->Reset();
1495
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();
1503 }
1504 if (!m_limitedoutput && m_simNeuroTracksName != "") {
1505 m_neuroDeltaZ->Reset();
1506 m_neuroDeltaTheta->Reset();
1507 m_neuroScatterZ->Reset();
1508 m_neuroScatterTheta->Reset();
1509
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();
1517 }
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();
1529
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();
1540 }
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();
1562
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();
1572
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();
1582
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();
1610 }
1611
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();
1651
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();
1690
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();
1718 }
1719 if (m_recoTracksName != "") {
1720 m_RecoZ->Reset();
1721 m_RecoCosTheta->Reset();
1722 m_RecoInvPt->Reset();
1723 m_RecoPhi->Reset();
1724 m_RecoD0->Reset();
1725 m_RecoTrackCount->Reset();
1726
1727 m_RecoHWZ->Reset();
1728 m_RecoHWCosTheta->Reset();
1729 m_RecoHWInvPt->Reset();
1730 m_RecoHWPhi->Reset();
1731 m_RecoHWD0->Reset();
1732 }
1733 if (!m_limitedoutput && m_recoTracksName != "") {
1734 m_RecoHWZScatter->Reset();
1735 }
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();
1744
1745 m_DeltaRecoHWZ->Reset();
1746 m_DeltaRecoHWCosTheta->Reset();
1747 m_DeltaRecoHWInvPt->Reset();
1748 m_DeltaRecoHWPhi->Reset();
1749 }
1750 if (!m_limitedoutput && m_simNeuroTracksName != "" && m_recoTracksName != "") {
1751 m_RecoSWZ->Reset();
1752 m_RecoSWCosTheta->Reset();
1753 m_RecoSWInvPt->Reset();
1754 m_RecoSWPhi->Reset();
1755 m_RecoSWD0->Reset();
1756 m_RecoSWZScatter->Reset();
1757
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();
1765
1766 m_DeltaRecoSWZ->Reset();
1767 m_DeltaRecoSWCosTheta->Reset();
1768 m_DeltaRecoSWInvPt->Reset();
1769 m_DeltaRecoSWPhi->Reset();
1770 }
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();
1778
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();
1786
1787 m_DeltaRecoSWTSSW2DZ->Reset();
1788 m_DeltaRecoSWTSSW2DCosTheta->Reset();
1789 m_DeltaRecoSWTSSW2DInvPt->Reset();
1790 m_DeltaRecoSWTSSW2DPhi->Reset();
1791 }
1792
1793}
1794
1795void CDCTriggerNeuroDQMModule::event()
1796{
1797 double phinorm ; /* intermediate name for phi to transfrom zo 0->360 */
1798 if (m_skipWithoutHWTS and m_unpackedNeuroInputSegments.getEntries() == 0) {
1799 //if (m_unpackedNeuroInputSegments.getEntries() == 0) {
1800 B2DEBUG(150, "No unpacked TS found, skipping event.");
1801 return;
1802 }
1803 if (m_recoTrackMultiplicity != -1 and m_RecoTracks.getEntries() != m_recoTrackMultiplicity) {
1804 B2DEBUG(150, "Wrong track multiplicity " << m_RecoTracks.getEntries() << ", skipping event.");
1805 return;
1806 }
1807
1808 StoreObjPtr<EventMetaData> eventMetaData;
1809
1810 if (m_recoTracksName != "") {
1811 // a RecoTrack has multiple representations for different particle hypothesis
1812 // -> just take the first one that does not give errors.
1813 m_RecoTrackCount->Fill(m_RecoTracks.getEntries());
1814 bool foundValidRep = false;
1815
1816 for (RecoTrack& recoTrack : m_RecoTracks) {
1817 int nhwmatched = 0;
1818 int nswmatched = 0;
1819 int nswtssw2dmatched = 0;
1820 double phi0Target = 0;
1821 double invptTarget = 0;
1822 double cosThetaTarget = 0;
1823 double zTarget = 0;
1824 double d0Target = 0;
1825 for (genfit::AbsTrackRep* rep : recoTrack.getRepresentations()) {
1826 if (!recoTrack.wasFitSuccessful(rep))
1827 continue;
1828 // get state (position, momentum etc.) from hit closest to IP and
1829 // extrapolate to z-axis (may throw an exception -> continue to next representation)
1830 try {
1831 genfit::MeasuredStateOnPlane state =
1832 recoTrack.getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
1833 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
1834 // TODO check after matching
1835 // // flip tracks if necessary, such that trigger tracks and reco tracks
1836 // // point in the same direction
1837 // if (state.getMom().Dot(m_tracks[itrack]->getDirection()) < 0) {
1838 // state.setPosMom(state.getPos(), -state.getMom());
1839 // state.setChargeSign(-state.getCharge());
1840 // }
1841 // get track parameters
1842 phi0Target = state.getMom().Phi() * 180. / M_PI ;
1843 if (phi0Target < 0.) {phi0Target = phi0Target + 360. ;}
1844 invptTarget = state.getCharge() * state.getMom().Pt();
1845 cosThetaTarget = state.getMom().CosTheta();
1846 zTarget = state.getPos().Z();
1847 d0Target = state.getPos().Perp();
1848 } catch (...) {
1849 continue;
1850 }
1851 // break loop
1852 foundValidRep = true;
1853 break;
1854 }
1855 if (!foundValidRep) {
1856 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
1857 continue;
1858 } else {
1859 if (m_maxRecoZDist != -1.0 and abs(zTarget) > m_maxRecoZDist) {
1860 B2DEBUG(150, "RecoTrack not close to IP (maxRecoZDist), zReco = " << zTarget);
1861 continue;
1862 }
1863 if (m_maxRecoD0Dist != -1.0 and abs(d0Target) > m_maxRecoD0Dist) {
1864 B2DEBUG(150, "RecoTrack not close to the z axis (maxRecoD0Dist), d0Reco = " << d0Target);
1865 continue;
1866 }
1867 m_RecoZ->Fill(zTarget);
1868 m_RecoCosTheta->Fill(cosThetaTarget);
1869 m_RecoPhi->Fill(phi0Target);
1870 m_RecoD0->Fill(d0Target);
1871 m_RecoInvPt->Fill(invptTarget);
1872 if (m_unpackedNeuroTracksName != "") {
1873 CDCTriggerTrack* neuroHWTrack = recoTrack.getRelatedTo<CDCTriggerTrack>(m_unpackedNeuroTracksName);
1874
1875 if (neuroHWTrack) {
1876 bool valtrack = false;
1877 try {
1878 valtrack = neuroHWTrack->getValidStereoBit();
1879 } catch (...) {
1880 B2WARNING("HWTrack doesn't have 'valid bit', get it from relations now... ");
1881 unsigned checkpattern = getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentsName);
1882 valtrack = isValidPattern(checkpattern);
1883 }
1884 if (!valtrack) {
1885 continue;
1886 }
1887
1888 m_RecoHWZ->Fill(zTarget);
1889 m_RecoHWCosTheta->Fill(cosThetaTarget);
1890 m_RecoHWPhi->Fill(phi0Target);
1891 m_RecoHWD0->Fill(d0Target);
1892 m_RecoHWInvPt->Fill(invptTarget);
1893
1894 double neuroHWZ = neuroHWTrack->getZ0() ;
1895 m_neuroRecoHWOutZ->Fill(neuroHWZ);
1896 double cotTh = neuroHWTrack->getCotTheta() ;
1897 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
1898 double neuroHWcosTh = cosTh ;
1899 m_neuroRecoHWOutCosTheta->Fill(neuroHWcosTh);
1900 double neuroHWPt = neuroHWTrack->getPt() ;
1901 m_neuroRecoHWOutInvPt->Fill(neuroHWPt);
1902 phinorm = neuroHWTrack->getPhi0() * 180 / M_PI ;
1903 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1904 double neuroHWPhi0 = phinorm;
1905 m_neuroRecoHWOutPhi0->Fill(neuroHWPhi0);
1906 m_neuroRecoHWOutHitPattern->Fill(getPattern(neuroHWTrack, m_unpackedNeuroInputSegmentsName));
1907 nhwmatched++;
1908 unsigned hwMatchedSector =
1909 neuroHWTrack->getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getSector();
1910 m_neuroRecoHWSector->Fill(hwMatchedSector);
1911
1912 m_DeltaRecoHWZ->Fill(zTarget - neuroHWZ);
1913 m_DeltaRecoHWCosTheta->Fill(cosThetaTarget - neuroHWcosTh);
1914 m_DeltaRecoHWPhi->Fill(phi0Target - neuroHWPhi0);
1915 m_DeltaRecoHWInvPt->Fill(invptTarget - neuroHWPt);
1916 if (!m_limitedoutput) {
1917 m_RecoHWZScatter->Fill(zTarget, neuroHWZ);
1918 }
1919 }
1920 if (!m_limitedoutput && m_simNeuroTracksName != "") {
1921 CDCTriggerTrack* neuroSWTrack = recoTrack.getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksName);
1922 if (neuroSWTrack) {
1923 bool valtrack = false;
1924 try {
1925 valtrack = neuroSWTrack->getValidStereoBit();
1926 } catch (...) {
1927 B2INFO("SWTrack doesn't have 'valid bit', get it from relations now... ");
1928 unsigned checkpattern = getPattern(neuroSWTrack, m_unpackedNeuroInputSegmentsName);
1929 valtrack = isValidPattern(checkpattern);
1930 }
1931 if (!valtrack) {
1932 continue;
1933 }
1934
1935 m_RecoSWZ->Fill(zTarget);
1936 m_RecoSWCosTheta->Fill(cosThetaTarget);
1937 m_RecoSWPhi->Fill(phi0Target);
1938 m_RecoSWD0->Fill(d0Target);
1939 m_RecoSWInvPt->Fill(invptTarget);
1940
1941 double neuroSWZ = neuroSWTrack->getZ0() ;
1942 m_neuroRecoSWOutZ->Fill(neuroSWZ);
1943 double cotTh = neuroSWTrack->getCotTheta() ;
1944 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
1945 double neuroSWcosTh = cosTh ;
1946 m_neuroRecoSWOutCosTheta->Fill(neuroSWcosTh);
1947 double neuroSWPt = neuroSWTrack->getPt() ;
1948 m_neuroRecoSWOutInvPt->Fill(neuroSWPt);
1949 phinorm = neuroSWTrack->getPhi0() * 180 / M_PI ;
1950 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1951 double neuroSWPhi0 = phinorm ;
1952 m_neuroRecoSWOutPhi0->Fill(neuroSWPhi0);
1953 m_neuroRecoSWOutHitPattern->Fill(getPattern(neuroSWTrack, m_unpackedNeuroInputSegmentsName));
1954 nswmatched++;
1955 unsigned swMatchedSector =
1956 neuroSWTrack->getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getSector();
1957 m_neuroRecoSWSector->Fill(swMatchedSector);
1958
1959 m_DeltaRecoSWZ->Fill(zTarget - neuroSWZ);
1960 m_DeltaRecoSWCosTheta->Fill(cosThetaTarget - neuroSWcosTh);
1961 m_DeltaRecoSWPhi->Fill(phi0Target - neuroSWPhi0);
1962 m_DeltaRecoSWInvPt->Fill(invptTarget - neuroSWPt);
1963 m_RecoSWZScatter->Fill(zTarget, neuroSWZ);
1964 }
1965 }
1966 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
1967 CDCTriggerTrack* neuroSWTSSW2DTrack = recoTrack.getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksSWTSSW2DName);
1968 if (neuroSWTSSW2DTrack) {
1969 m_RecoSWTSSW2DZ->Fill(zTarget);
1970 m_RecoSWTSSW2DCosTheta->Fill(cosThetaTarget);
1971 m_RecoSWTSSW2DPhi->Fill(phi0Target);
1972 m_RecoSWTSSW2DD0->Fill(d0Target);
1973 m_RecoSWTSSW2DInvPt->Fill(invptTarget);
1974
1975 m_neuroRecoSWTSSW2DOutZ->Fill(neuroSWTSSW2DTrack->getZ0());
1976
1977 double cotTh = neuroSWTSSW2DTrack->getCotTheta();
1978 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
1979 m_neuroRecoSWTSSW2DOutCosTheta->Fill(cosTh);
1980 phinorm = neuroSWTSSW2DTrack->getPhi0() * 180 / M_PI;
1981 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1982 double phiNeuro = phinorm ;
1983 double invptNeuro = neuroSWTSSW2DTrack->getPt() ;
1984 m_neuroRecoSWTSSW2DOutInvPt->Fill(invptNeuro);
1985 m_neuroRecoSWTSSW2DOutPhi0->Fill(phiNeuro);
1986 m_neuroRecoSWTSSW2DOutHitPattern->Fill(getPattern(neuroSWTSSW2DTrack, m_simSegmentHitsName));
1987 nswtssw2dmatched++;
1988 unsigned swtssw2dMatchedSector =
1989 neuroSWTSSW2DTrack->getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorSWTSSW2DName)->getSector();
1990 m_neuroRecoSWTSSW2DSector->Fill(swtssw2dMatchedSector);
1991
1992 m_DeltaRecoSWTSSW2DZ->Fill(zTarget - neuroSWTSSW2DTrack->getZ0());
1993
1994
1995 m_DeltaRecoSWTSSW2DCosTheta->Fill(cosThetaTarget - cosTh);
1996 phinorm = neuroSWTSSW2DTrack->getPhi0() * 180. / M_PI ;
1997 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
1998 m_DeltaRecoSWTSSW2DPhi->Fill(phi0Target - phinorm);
1999 m_DeltaRecoSWTSSW2DInvPt->Fill(invptTarget - neuroSWTSSW2DTrack->getPt());
2000 m_RecoSWTSSW2DZScatter->Fill(zTarget, neuroSWTSSW2DTrack->getZ0());
2001 }
2002 }
2003 }
2004 }
2005 if (m_unpackedNeuroTracksName != "") {
2006 m_neuroRecoHWOutTrackCount->Fill(nhwmatched);
2007 if (!m_limitedoutput && m_simNeuroTracksName != "") {
2008 m_neuroRecoSWOutTrackCount->Fill(nswmatched);
2009 }
2010 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
2011 m_neuroRecoSWTSSW2DOutTrackCount->Fill(nswtssw2dmatched);
2012 }
2013 }
2014 }
2015 }
2016
2017 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
2018 m_neuroSWTSSW2DOutTrackCount->Fill(m_simNeuroTracksSWTSSW2D.getEntries());
2019 for (CDCTriggerTrack& neuroswTrack : m_simNeuroTracksSWTSSW2D) {
2020 m_neuroSWTSSW2DOutZ->Fill(neuroswTrack.getZ0());
2021 double cotThSW = neuroswTrack.getCotTheta();
2022 double cosThSW = copysign(1.0, cotThSW) / sqrt(1. / (cotThSW * cotThSW) + 1);
2023 m_neuroSWTSSW2DOutCosTheta->Fill(cosThSW);
2024 phinorm = neuroswTrack.getPhi0() * 180. / M_PI ;
2025 if (phinorm < 0.) {
2026 phinorm = phinorm + 360. ;
2027 }
2028 m_neuroSWTSSW2DOutPhi0->Fill(phinorm);
2029 m_neuroSWTSSW2DOutInvPt->Fill(neuroswTrack.getPt());
2030 unsigned simSWTSSW2DSector =
2031 neuroswTrack.getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorSWTSSW2DName)->getSector();
2032 m_neuroSWTSSW2DSector->Fill(simSWTSSW2DSector);
2033
2034 // sw NN selected sw ts
2035 unsigned pattern = 0;
2036 for (const CDCTriggerSegmentHit& hit :
2037 neuroswTrack.getRelationsTo<CDCTriggerSegmentHit>(m_simSegmentHitsName)) {
2038 m_neuroSWTSSW2DSelTSID->Fill(hit.getSegmentID());
2039 unsigned int sl = hit.getISuperLayer();
2040 m_neuroSWTSSW2DSelTSCount->Fill(sl);
2041 float neuroTime = neuroswTrack.getTime();
2042
2043 // find first occurence of hit (used to debug the selcted TS field)
2044 CDCTriggerSegmentHit firstHit = hit;
2045 for (CDCTriggerSegmentHit compare : m_simSegmentHits) {
2046 if (compare.getISuperLayer() == hit.getISuperLayer() &&
2047 compare.getIWireCenter() == hit.getIWireCenter() &&
2048 compare.getPriorityPosition() == hit.getPriorityPosition() &&
2049 compare.getLeftRight() == hit.getLeftRight() &&
2050 compare.priorityTime() == hit.priorityTime() &&
2051 compare.foundTime() < firstHit.foundTime()) {
2052 firstHit = compare;
2053 }
2054 }
2055
2056 switch (sl) {
2057 case 0: m_neuroSWTSSW2DSelTSPrioT_Layer0->Fill(hit.priorityTime());
2058 m_neuroSWTSSW2DSelTSFoundT_Layer0->Fill(firstHit.foundTime() - neuroTime);
2059 m_neuroSWTSSW2DSelTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2060 m_neuroSWTSSW2DSelTSLR_Layer0->Fill(hit.getLeftRight());
2061 break;
2062 case 1: m_neuroSWTSSW2DSelTSPrioT_Layer1->Fill(hit.priorityTime());
2063 m_neuroSWTSSW2DSelTSFoundT_Layer1->Fill(firstHit.foundTime() - neuroTime);
2064 m_neuroSWTSSW2DSelTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2065 m_neuroSWTSSW2DSelTSLR_Layer1->Fill(hit.getLeftRight());
2066 break;
2067 case 2: m_neuroSWTSSW2DSelTSPrioT_Layer2->Fill(hit.priorityTime());
2068 m_neuroSWTSSW2DSelTSFoundT_Layer2->Fill(firstHit.foundTime() - neuroTime);
2069 m_neuroSWTSSW2DSelTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2070 m_neuroSWTSSW2DSelTSLR_Layer2->Fill(hit.getLeftRight());
2071 break;
2072 case 3: m_neuroSWTSSW2DSelTSPrioT_Layer3->Fill(hit.priorityTime());
2073 m_neuroSWTSSW2DSelTSFoundT_Layer3->Fill(firstHit.foundTime() - neuroTime);
2074 m_neuroSWTSSW2DSelTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2075 m_neuroSWTSSW2DSelTSLR_Layer3->Fill(hit.getLeftRight());
2076 break;
2077 case 4: m_neuroSWTSSW2DSelTSPrioT_Layer4->Fill(hit.priorityTime());
2078 m_neuroSWTSSW2DSelTSFoundT_Layer4->Fill(firstHit.foundTime() - neuroTime);
2079 m_neuroSWTSSW2DSelTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2080 m_neuroSWTSSW2DSelTSLR_Layer4->Fill(hit.getLeftRight());
2081 break;
2082 case 5: m_neuroSWTSSW2DSelTSPrioT_Layer5->Fill(hit.priorityTime());
2083 m_neuroSWTSSW2DSelTSFoundT_Layer5->Fill(firstHit.foundTime() - neuroTime);
2084 m_neuroSWTSSW2DSelTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2085 m_neuroSWTSSW2DSelTSLR_Layer5->Fill(hit.getLeftRight());
2086 break;
2087 case 6: m_neuroSWTSSW2DSelTSPrioT_Layer6->Fill(hit.priorityTime());
2088 m_neuroSWTSSW2DSelTSFoundT_Layer6->Fill(firstHit.foundTime() - neuroTime);
2089 m_neuroSWTSSW2DSelTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2090 m_neuroSWTSSW2DSelTSLR_Layer6->Fill(hit.getLeftRight());
2091 break;
2092 case 7: m_neuroSWTSSW2DSelTSPrioT_Layer7->Fill(hit.priorityTime());
2093 m_neuroSWTSSW2DSelTSFoundT_Layer7->Fill(firstHit.foundTime() - neuroTime);
2094 m_neuroSWTSSW2DSelTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2095 m_neuroSWTSSW2DSelTSLR_Layer7->Fill(hit.getLeftRight());
2096 break;
2097 case 8: m_neuroSWTSSW2DSelTSPrioT_Layer8->Fill(hit.priorityTime());
2098 m_neuroSWTSSW2DSelTSFoundT_Layer8->Fill(firstHit.foundTime() - neuroTime);
2099 m_neuroSWTSSW2DSelTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2100 m_neuroSWTSSW2DSelTSLR_Layer8->Fill(hit.getLeftRight());
2101 break;
2102 }
2103 if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
2104 }
2105 m_neuroSWTSSW2DOutHitPattern->Fill(pattern);
2106
2107 // plot input vector
2108 vector<float> nnInput =
2109 neuroswTrack.getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorSWTSSW2DName)->getInput();
2110 condFill(m_neuroSWTSSW2DInputID_Layer0, nnInput[0]);
2111 condFill(m_neuroSWTSSW2DInputT_Layer0, nnInput[1]);
2112 condFill(m_neuroSWTSSW2DInputAlpha_Layer0, nnInput[2]);
2113 condFill(m_neuroSWTSSW2DInputID_Layer1, nnInput[3]);
2114 condFill(m_neuroSWTSSW2DInputT_Layer1, nnInput[4]);
2115 condFill(m_neuroSWTSSW2DInputAlpha_Layer1, nnInput[5]);
2116 condFill(m_neuroSWTSSW2DInputID_Layer2, nnInput[6]);
2117 condFill(m_neuroSWTSSW2DInputT_Layer2, nnInput[7]);
2118 condFill(m_neuroSWTSSW2DInputAlpha_Layer2, nnInput[8]);
2119 condFill(m_neuroSWTSSW2DInputID_Layer3, nnInput[9]);
2120 condFill(m_neuroSWTSSW2DInputT_Layer3, nnInput[10]);
2121 condFill(m_neuroSWTSSW2DInputAlpha_Layer3, nnInput[11]);
2122 condFill(m_neuroSWTSSW2DInputID_Layer4, nnInput[12]);
2123 condFill(m_neuroSWTSSW2DInputT_Layer4, nnInput[13]);
2124 condFill(m_neuroSWTSSW2DInputAlpha_Layer4, nnInput[14]);
2125 condFill(m_neuroSWTSSW2DInputID_Layer5, nnInput[15]);
2126 condFill(m_neuroSWTSSW2DInputT_Layer5, nnInput[16]);
2127 condFill(m_neuroSWTSSW2DInputAlpha_Layer5, nnInput[17]);
2128 condFill(m_neuroSWTSSW2DInputID_Layer6, nnInput[18]);
2129 condFill(m_neuroSWTSSW2DInputT_Layer6, nnInput[19]);
2130 condFill(m_neuroSWTSSW2DInputAlpha_Layer6, nnInput[20]);
2131 condFill(m_neuroSWTSSW2DInputID_Layer7, nnInput[21]);
2132 condFill(m_neuroSWTSSW2DInputT_Layer7, nnInput[22]);
2133 condFill(m_neuroSWTSSW2DInputAlpha_Layer7, nnInput[23]);
2134 condFill(m_neuroSWTSSW2DInputID_Layer8, nnInput[24]);
2135 condFill(m_neuroSWTSSW2DInputT_Layer8, nnInput[25]);
2136 condFill(m_neuroSWTSSW2DInputAlpha_Layer8, nnInput[26]);
2137 }
2138 }
2139 if (!m_limitedoutput && m_simNeuroTracksName != "") {
2140 m_neuroSWOutTrackCount->Fill(m_simNeuroTracks.getEntries());
2141 for (CDCTriggerTrack& neuroswTrack : m_simNeuroTracks) {
2142 bool valtrack = false;
2143 try {
2144 valtrack = neuroswTrack.getValidStereoBit();
2145 } catch (...) {
2146 B2INFO("HWTrack doesn't have 'valid bit', get it from relations now... ");
2147 unsigned checkpattern = getPattern(&neuroswTrack, m_unpackedNeuroInputSegmentsName);
2148 valtrack = isValidPattern(checkpattern);
2149 }
2150 if (!valtrack) {
2151 continue;
2152 }
2153
2154 m_neuroSWOutZ->Fill(neuroswTrack.getZ0());
2155 double cotThSW = neuroswTrack.getCotTheta();
2156 double cosThSW = copysign(1.0, cotThSW) / sqrt(1. / (cotThSW * cotThSW) + 1);
2157 m_neuroSWOutCosTheta->Fill(cosThSW);
2158 phinorm = neuroswTrack.getPhi0() * 180. / M_PI ;
2159 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
2160 m_neuroSWOutPhi0->Fill(phinorm);
2161 m_neuroSWOutInvPt->Fill(neuroswTrack.getPt());
2162
2163 unsigned simSector =
2164 neuroswTrack.getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getSector();
2165 m_neuroSWSector->Fill(simSector);
2166
2167 // sw NN selected sw ts
2168 unsigned pattern = 0;
2169 for (const CDCTriggerSegmentHit& hit :
2170 neuroswTrack.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentsName)) {
2171 m_neuroSWSelTSID->Fill(hit.getSegmentID());
2172 unsigned int sl = hit.getISuperLayer();
2173 m_neuroSWSelTSCount->Fill(sl);
2174 float neuroTime = neuroswTrack.getTime();
2175
2176 // find first occurence of hit (used to debug the selcted TS field)
2177 CDCTriggerSegmentHit firstHit = hit;
2178 for (CDCTriggerSegmentHit compare : m_simSegmentHits) {
2179 if (compare.getISuperLayer() == hit.getISuperLayer() &&
2180 compare.getIWireCenter() == hit.getIWireCenter() &&
2181 compare.getPriorityPosition() == hit.getPriorityPosition() &&
2182 compare.getLeftRight() == hit.getLeftRight() &&
2183 compare.priorityTime() == hit.priorityTime() &&
2184 compare.foundTime() < firstHit.foundTime()) {
2185 firstHit = compare;
2186 }
2187 }
2188
2189 switch (sl) {
2190 case 0: m_neuroSWSelTSPrioT_Layer0->Fill(hit.priorityTime());
2191 m_neuroSWSelTSFoundT_Layer0->Fill(firstHit.foundTime() - neuroTime);
2192 m_neuroSWSelTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2193 m_neuroSWSelTSLR_Layer0->Fill(hit.getLeftRight());
2194 break;
2195 case 1: m_neuroSWSelTSPrioT_Layer1->Fill(hit.priorityTime());
2196 m_neuroSWSelTSFoundT_Layer1->Fill(firstHit.foundTime() - neuroTime);
2197 m_neuroSWSelTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2198 m_neuroSWSelTSLR_Layer1->Fill(hit.getLeftRight());
2199 break;
2200 case 2: m_neuroSWSelTSPrioT_Layer2->Fill(hit.priorityTime());
2201 m_neuroSWSelTSFoundT_Layer2->Fill(firstHit.foundTime() - neuroTime);
2202 m_neuroSWSelTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2203 m_neuroSWSelTSLR_Layer2->Fill(hit.getLeftRight());
2204 break;
2205 case 3: m_neuroSWSelTSPrioT_Layer3->Fill(hit.priorityTime());
2206 m_neuroSWSelTSFoundT_Layer3->Fill(firstHit.foundTime() - neuroTime);
2207 m_neuroSWSelTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2208 m_neuroSWSelTSLR_Layer3->Fill(hit.getLeftRight());
2209 break;
2210 case 4: m_neuroSWSelTSPrioT_Layer4->Fill(hit.priorityTime());
2211 m_neuroSWSelTSFoundT_Layer4->Fill(firstHit.foundTime() - neuroTime);
2212 m_neuroSWSelTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2213 m_neuroSWSelTSLR_Layer4->Fill(hit.getLeftRight());
2214 break;
2215 case 5: m_neuroSWSelTSPrioT_Layer5->Fill(hit.priorityTime());
2216 m_neuroSWSelTSFoundT_Layer5->Fill(firstHit.foundTime() - neuroTime);
2217 m_neuroSWSelTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2218 m_neuroSWSelTSLR_Layer5->Fill(hit.getLeftRight());
2219 break;
2220 case 6: m_neuroSWSelTSPrioT_Layer6->Fill(hit.priorityTime());
2221 m_neuroSWSelTSFoundT_Layer6->Fill(firstHit.foundTime() - neuroTime);
2222 m_neuroSWSelTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2223 m_neuroSWSelTSLR_Layer6->Fill(hit.getLeftRight());
2224 break;
2225 case 7: m_neuroSWSelTSPrioT_Layer7->Fill(hit.priorityTime());
2226 m_neuroSWSelTSFoundT_Layer7->Fill(firstHit.foundTime() - neuroTime);
2227 m_neuroSWSelTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2228 m_neuroSWSelTSLR_Layer7->Fill(hit.getLeftRight());
2229 break;
2230 case 8: m_neuroSWSelTSPrioT_Layer8->Fill(hit.priorityTime());
2231 m_neuroSWSelTSFoundT_Layer8->Fill(firstHit.foundTime() - neuroTime);
2232 m_neuroSWSelTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2233 m_neuroSWSelTSLR_Layer8->Fill(hit.getLeftRight());
2234 break;
2235 }
2236 if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
2237 }
2238 m_neuroSWOutHitPattern->Fill(pattern);
2239
2240
2241 // plot input vector
2242 vector<float> nnInput =
2243 neuroswTrack.getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getInput();
2244 condFill(m_neuroSWInputID_Layer0, nnInput[0]);
2245 condFill(m_neuroSWInputT_Layer0, nnInput[1]);
2246 condFill(m_neuroSWInputAlpha_Layer0, nnInput[2]);
2247 condFill(m_neuroSWInputID_Layer1, nnInput[3]);
2248 condFill(m_neuroSWInputT_Layer1, nnInput[4]);
2249 condFill(m_neuroSWInputAlpha_Layer1, nnInput[5]);
2250 condFill(m_neuroSWInputID_Layer2, nnInput[6]);
2251 condFill(m_neuroSWInputT_Layer2, nnInput[7]);
2252 condFill(m_neuroSWInputAlpha_Layer2, nnInput[8]);
2253 condFill(m_neuroSWInputID_Layer3, nnInput[9]);
2254 condFill(m_neuroSWInputT_Layer3, nnInput[10]);
2255 condFill(m_neuroSWInputAlpha_Layer3, nnInput[11]);
2256 condFill(m_neuroSWInputID_Layer4, nnInput[12]);
2257 condFill(m_neuroSWInputT_Layer4, nnInput[13]);
2258 condFill(m_neuroSWInputAlpha_Layer4, nnInput[14]);
2259 condFill(m_neuroSWInputID_Layer5, nnInput[15]);
2260 condFill(m_neuroSWInputT_Layer5, nnInput[16]);
2261 condFill(m_neuroSWInputAlpha_Layer5, nnInput[17]);
2262 condFill(m_neuroSWInputID_Layer6, nnInput[18]);
2263 condFill(m_neuroSWInputT_Layer6, nnInput[19]);
2264 condFill(m_neuroSWInputAlpha_Layer6, nnInput[20]);
2265 condFill(m_neuroSWInputID_Layer7, nnInput[21]);
2266 condFill(m_neuroSWInputT_Layer7, nnInput[22]);
2267 condFill(m_neuroSWInputAlpha_Layer7, nnInput[23]);
2268 condFill(m_neuroSWInputID_Layer8, nnInput[24]);
2269 condFill(m_neuroSWInputT_Layer8, nnInput[25]);
2270 condFill(m_neuroSWInputAlpha_Layer8, nnInput[26]);
2271 }
2272 }
2273
2274 int nofintracks = 0;
2275 if (m_unpackedNeuroTracksName != "") {
2276 int nofouttracks = 0;
2277 int nofinsegments = 0;
2278 // fill neurotrigger histograms
2279 for (CDCTriggerTrack& neuroTrack : m_unpackedNeuroTracks) {
2280 bool valtrack = false;
2281 try {
2282 valtrack = neuroTrack.getValidStereoBit();
2283 } catch (...) {
2284 B2WARNING("NeuroTrack doesn't have 'valid bit', get it from relations now... ");
2285 unsigned checkpattern = getPattern(&neuroTrack, m_unpackedNeuroInputSegmentsName);
2286 valtrack = isValidPattern(checkpattern);
2287 }
2288 if (!valtrack) {
2289 continue;
2290 }
2291 // count number of tracks
2292 ++nofouttracks;
2293 // fill raw distributions
2294 m_neuroHWOutZ->Fill(neuroTrack.getZ0());
2295 double cotTh = neuroTrack.getCotTheta();
2296 double cosTh = copysign(1.0, cotTh) / sqrt(1. / (cotTh * cotTh) + 1);
2297 m_neuroHWOutCosTheta->Fill(cosTh);
2298 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2299 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
2300 m_neuroHWOutPhi0->Fill(phinorm);
2301 m_neuroHWOutInvPt->Fill(neuroTrack.getPt());
2302 m_neuroHWOutPt->Fill(neuroTrack.getPt());
2303 m_neuroHWOutm_time->Fill(neuroTrack.getTime());
2304
2305 unsigned hwSector =
2306 neuroTrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getSector();
2307 m_neuroHWSector->Fill(hwSector);
2308
2309 // fill hists per quadrant
2310 if (!m_limitedoutput) {
2311 switch (neuroTrack.getQuadrant()) {
2312 case -1:
2313 m_neuroHWOutQuad5Z->Fill(neuroTrack.getZ0());
2314 m_neuroHWOutQuad5CosTheta->Fill(cosTh);
2315 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2316 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2317 m_neuroHWOutQuad5Phi0->Fill(phinorm);
2318 m_neuroHWOutQuad5InvPt->Fill(neuroTrack.getPt());
2319 break;
2320 case 0:
2321 m_neuroHWOutQuad0Z->Fill(neuroTrack.getZ0());
2322 m_neuroHWOutQuad0CosTheta->Fill(cosTh);
2323 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2324 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2325 m_neuroHWOutQuad0Phi0->Fill(phinorm);
2326 m_neuroHWOutQuad0InvPt->Fill(neuroTrack.getPt());
2327 break;
2328 case 1:
2329 m_neuroHWOutQuad1Z->Fill(neuroTrack.getZ0());
2330 m_neuroHWOutQuad1CosTheta->Fill(cosTh);
2331 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2332 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2333 m_neuroHWOutQuad1Phi0->Fill(phinorm);
2334 m_neuroHWOutQuad1InvPt->Fill(neuroTrack.getPt());
2335 break;
2336 case 2:
2337 m_neuroHWOutQuad2Z->Fill(neuroTrack.getZ0());
2338 m_neuroHWOutQuad2CosTheta->Fill(cosTh);
2339 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2340 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2341 m_neuroHWOutQuad2Phi0->Fill(phinorm);
2342 m_neuroHWOutQuad2InvPt->Fill(neuroTrack.getPt());
2343 break;
2344 case 3:
2345 m_neuroHWOutQuad3Z->Fill(neuroTrack.getZ0());
2346 m_neuroHWOutQuad3CosTheta->Fill(cosTh);
2347 phinorm = neuroTrack.getPhi0() * 180. / M_PI ;
2348 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2349 m_neuroHWOutQuad3Phi0->Fill(phinorm);
2350 m_neuroHWOutQuad3InvPt->Fill(neuroTrack.getPt());
2351 break;
2352 }
2353 }
2354
2355 // get related stereo hits
2356 unsigned pattern = 0;
2357 for (const CDCTriggerSegmentHit& hit :
2358 neuroTrack.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentsName)) {
2359 m_neuroHWSelTSID->Fill(hit.getSegmentID());
2360 unsigned int sl = hit.getISuperLayer();
2361 m_neuroHWSelTSCount->Fill(sl);
2362 float neuroTime = neuroTrack.getTime();
2363 // find first occurence of hit (used to debug the selcted TS field)
2364 CDCTriggerSegmentHit firstHit = hit;
2365 for (CDCTriggerSegmentHit compare : m_unpackedNeuroInputSegments) {
2366 if (compare.getISuperLayer() == hit.getISuperLayer() &&
2367 compare.getIWireCenter() == hit.getIWireCenter() &&
2368 compare.getPriorityPosition() == hit.getPriorityPosition() &&
2369 compare.getLeftRight() == hit.getLeftRight() &&
2370 compare.priorityTime() == hit.priorityTime() &&
2371 compare.foundTime() < firstHit.foundTime()) {
2372 firstHit = compare;
2373 }
2374 }
2375
2376 if (!m_limitedoutput) {
2377 switch (sl) {
2378 case 0: m_neuroHWSelTSPrioT_Layer0->Fill(hit.priorityTime());
2379 m_neuroHWSelTSFoundT_Layer0->Fill(firstHit.foundTime() - neuroTime);
2380 m_neuroHWSelTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2381 m_neuroHWSelTSLR_Layer0->Fill(hit.getLeftRight());
2382 break;
2383 case 1: m_neuroHWSelTSPrioT_Layer1->Fill(hit.priorityTime());
2384 m_neuroHWSelTSFoundT_Layer1->Fill(firstHit.foundTime() - neuroTime);
2385 m_neuroHWSelTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2386 m_neuroHWSelTSLR_Layer1->Fill(hit.getLeftRight());
2387 break;
2388 case 2: m_neuroHWSelTSPrioT_Layer2->Fill(hit.priorityTime());
2389 m_neuroHWSelTSFoundT_Layer2->Fill(firstHit.foundTime() - neuroTime);
2390 m_neuroHWSelTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2391 m_neuroHWSelTSLR_Layer2->Fill(hit.getLeftRight());
2392 break;
2393 case 3: m_neuroHWSelTSPrioT_Layer3->Fill(hit.priorityTime());
2394 m_neuroHWSelTSFoundT_Layer3->Fill(firstHit.foundTime() - neuroTime);
2395 m_neuroHWSelTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2396 m_neuroHWSelTSLR_Layer3->Fill(hit.getLeftRight());
2397 break;
2398 case 4: m_neuroHWSelTSPrioT_Layer4->Fill(hit.priorityTime());
2399 m_neuroHWSelTSFoundT_Layer4->Fill(firstHit.foundTime() - neuroTime);
2400 m_neuroHWSelTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2401 m_neuroHWSelTSLR_Layer4->Fill(hit.getLeftRight());
2402 break;
2403 case 5: m_neuroHWSelTSPrioT_Layer5->Fill(hit.priorityTime());
2404 m_neuroHWSelTSFoundT_Layer5->Fill(firstHit.foundTime() - neuroTime);
2405 m_neuroHWSelTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2406 m_neuroHWSelTSLR_Layer5->Fill(hit.getLeftRight());
2407 break;
2408 case 6: m_neuroHWSelTSPrioT_Layer6->Fill(hit.priorityTime());
2409 m_neuroHWSelTSFoundT_Layer6->Fill(firstHit.foundTime() - neuroTime);
2410 m_neuroHWSelTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2411 m_neuroHWSelTSLR_Layer6->Fill(hit.getLeftRight());
2412 break;
2413 case 7: m_neuroHWSelTSPrioT_Layer7->Fill(hit.priorityTime());
2414 m_neuroHWSelTSFoundT_Layer7->Fill(firstHit.foundTime() - neuroTime);
2415 m_neuroHWSelTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2416 m_neuroHWSelTSLR_Layer7->Fill(hit.getLeftRight());
2417 break;
2418 case 8: m_neuroHWSelTSPrioT_Layer8->Fill(hit.priorityTime());
2419 m_neuroHWSelTSFoundT_Layer8->Fill(firstHit.foundTime() - neuroTime);
2420 m_neuroHWSelTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2421 m_neuroHWSelTSLR_Layer8->Fill(hit.getLeftRight());
2422 break;
2423 }
2424 }
2425 if (sl % 2 == 1) pattern |= (1 << ((sl - 1) / 2));
2426 }
2427 m_neuroHWOutHitPattern->Fill(pattern);
2428
2429 // plot input vector
2430 if (!m_limitedoutput) {
2431 vector<float> nnInput =
2432 neuroTrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
2433 condFill(m_neuroHWInputID_Layer0, nnInput[0]);
2434 condFill(m_neuroHWInputT_Layer0, nnInput[1]);
2435 condFill(m_neuroHWInputAlpha_Layer0, nnInput[2]);
2436 condFill(m_neuroHWInputID_Layer1, nnInput[3]);
2437 condFill(m_neuroHWInputT_Layer1, nnInput[4]);
2438 condFill(m_neuroHWInputAlpha_Layer1, nnInput[5]);
2439 condFill(m_neuroHWInputID_Layer2, nnInput[6]);
2440 condFill(m_neuroHWInputT_Layer2, nnInput[7]);
2441 condFill(m_neuroHWInputAlpha_Layer2, nnInput[8]);
2442 condFill(m_neuroHWInputID_Layer3, nnInput[9]);
2443 condFill(m_neuroHWInputT_Layer3, nnInput[10]);
2444 condFill(m_neuroHWInputAlpha_Layer3, nnInput[11]);
2445 condFill(m_neuroHWInputID_Layer4, nnInput[12]);
2446 condFill(m_neuroHWInputT_Layer4, nnInput[13]);
2447 condFill(m_neuroHWInputAlpha_Layer4, nnInput[14]);
2448 condFill(m_neuroHWInputID_Layer5, nnInput[15]);
2449 condFill(m_neuroHWInputT_Layer5, nnInput[16]);
2450 condFill(m_neuroHWInputAlpha_Layer5, nnInput[17]);
2451 condFill(m_neuroHWInputID_Layer6, nnInput[18]);
2452 condFill(m_neuroHWInputT_Layer6, nnInput[19]);
2453 condFill(m_neuroHWInputAlpha_Layer6, nnInput[20]);
2454 condFill(m_neuroHWInputID_Layer7, nnInput[21]);
2455 condFill(m_neuroHWInputT_Layer7, nnInput[22]);
2456 condFill(m_neuroHWInputAlpha_Layer7, nnInput[23]);
2457 condFill(m_neuroHWInputID_Layer8, nnInput[24]);
2458 condFill(m_neuroHWInputT_Layer8, nnInput[25]);
2459 condFill(m_neuroHWInputAlpha_Layer8, nnInput[26]);
2460
2461
2462 if (m_simNeuroTracksName != "") {
2463 // get related track from TSIM (via 2D finder track)
2464 CDCTriggerTrack* finderTrack =
2465 neuroTrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroInput2DTracksName);
2466 if (finderTrack) {
2467 CDCTriggerTrack* neuroSimTrack =
2468 finderTrack->getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksName);
2469 if (neuroSimTrack) {
2470 // check if they same TS are selected in the unpacked and TSIM track
2471 int nsameTS = 0;
2472 int ndiffTS = 0;
2473 for (const CDCTriggerSegmentHit& simhit :
2474 neuroSimTrack->getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentsName)) {
2475 unsigned int simsl = simhit.getISuperLayer();
2476 for (const CDCTriggerSegmentHit& hit :
2477 neuroTrack.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentsName)) {
2478 unsigned int sl = hit.getISuperLayer();
2479 if (sl == simsl) {
2480 m_neuroDeltaTSID->Fill(hit.getSegmentID() - simhit.getSegmentID());
2481 if (simhit.getSegmentID() == hit.getSegmentID() &&
2482 simhit.getPriorityPosition() == hit.getPriorityPosition() &&
2483 simhit.getLeftRight() == hit.getLeftRight() &&
2484 simhit.priorityTime() == hit.priorityTime()
2485 ) {
2486 nsameTS += 1;
2487 } else {
2488 ndiffTS += 1;
2489 }
2490 }
2491 }
2492 }
2493 m_simSameTS->Fill(nsameTS);
2494 m_simDiffTS->Fill(ndiffTS);
2495 // only calculate deltas if the same TS are selected in unpacker and TSIM
2496
2497
2498 if (nsameTS >= m_nsamets) {
2499 if (abs(neuroTrack.getZ0() - neuroSimTrack->getZ0()) > 1) {
2500 neuroSimTrack->setQualityVector(2);
2501 neuroTrack.setQualityVector(2);
2502 }
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);
2518 bool sameInputId = true;
2519 bool sameInputAlpha = true;
2520 bool scaleErr = false;
2521 bool missingTS = false;
2522 bool timeErr = false;
2523 for (unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
2524 m_neuroDeltaInputID->Fill(unpackedInput[ii] - simInput[ii]);
2525 m_neuroDeltaInputT->Fill(unpackedInput[ii + 1] - simInput[ii + 1]);
2526 m_neuroDeltaInputAlpha->Fill(unpackedInput[ii + 2] - simInput[ii + 2]);
2527 bool hwZero = false;
2528 bool hwSimZero = false;
2529 if (unpackedInput[ii] != simInput[ii]) {sameInputId = false;}
2530 if (unpackedInput[ii + 2] != simInput[ii + 2]) {sameInputAlpha = false;}
2531 if (unpackedInput[ii + 1] != simInput[ii + 1]) {timeErr = true;}
2532 if (unpackedInput[ii + 1] == 0 && fabs(simInput[ii + 1] > 0.99)) {scaleErr = true;}
2533 if (simInput[ii + 1] == 0 && fabs(unpackedInput[ii + 1] > 0.99)) {scaleErr = true;}
2534 if (unpackedInput[ii] == 0 && unpackedInput[ii + 1] == 0 && unpackedInput[ii + 2] == 0) {hwZero = true;}
2535 if (simInput[ii] == 0 && simInput[ii + 1] == 0 && simInput[ii + 2] == 0) {hwSimZero = true;}
2536 if (hwZero != hwSimZero) {missingTS = true;}
2537 }
2538 if (!sameInputId) {neuroTrack.setQualityVector(4);}
2539 if (!sameInputAlpha) {neuroTrack.setQualityVector(8);}
2540 if (scaleErr) {neuroTrack.setQualityVector(16);}
2541 if (missingTS) {neuroTrack.setQualityVector(32);}
2542 if (timeErr) {neuroTrack.setQualityVector(64);}
2543
2544 }
2545 }
2546 }
2547 }
2548 }
2549 }
2550 for (CDCTriggerTrack& neuroinput2dtrack : m_unpackedNeuroInput2DTracks) {
2551 nofintracks ++;
2552 phinorm = neuroinput2dtrack.getPhi0() * 180. / M_PI ;
2553 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2554 m_neuroHWInPhi0->Fill(phinorm);
2555 m_neuroHWInm_time->Fill(neuroinput2dtrack.getTime());
2556 m_neuroHWInInvPt->Fill(neuroinput2dtrack.getPt());
2557 }
2558 if (nofintracks > 0 || nofouttracks > 0) {
2559 m_neuroHWInTrackCount->Fill(nofintracks);
2560 m_neuroHWOutTrackCount->Fill(nofouttracks);
2561 m_neuroHWOutVsInTrackCount->Fill((nofouttracks - nofintracks));
2562 }
2563 for (CDCTriggerSegmentHit& neuroinputsegment : m_unpackedNeuroInputSegments) {
2564 ++nofinsegments;
2565 m_neuroHWInTSID->Fill(neuroinputsegment.getSegmentID());
2566 if (!m_limitedoutput) {
2567 unsigned int sl = neuroinputsegment.getISuperLayer();
2568 switch (sl) {
2569 case 0: m_neuroHWInTSPrioT_Layer0->Fill(neuroinputsegment.priorityTime());
2570 m_neuroHWInTSFoundT_Layer0->Fill(neuroinputsegment.foundTime());
2571 m_neuroHWInTSPrioB_Layer0->Fill(neuroinputsegment.getPriorityPosition());
2572 m_neuroHWInTSLR_Layer0->Fill(neuroinputsegment.getLeftRight());
2573 break;
2574 case 1: m_neuroHWInTSPrioT_Layer1->Fill(neuroinputsegment.priorityTime());
2575 m_neuroHWInTSFoundT_Layer1->Fill(neuroinputsegment.foundTime());
2576 m_neuroHWInTSPrioB_Layer1->Fill(neuroinputsegment.getPriorityPosition());
2577 m_neuroHWInTSLR_Layer1->Fill(neuroinputsegment.getLeftRight());
2578 break;
2579 case 2: m_neuroHWInTSPrioT_Layer2->Fill(neuroinputsegment.priorityTime());
2580 m_neuroHWInTSFoundT_Layer2->Fill(neuroinputsegment.foundTime());
2581 m_neuroHWInTSPrioB_Layer2->Fill(neuroinputsegment.getPriorityPosition());
2582 m_neuroHWInTSLR_Layer2->Fill(neuroinputsegment.getLeftRight());
2583 break;
2584 case 3: m_neuroHWInTSPrioT_Layer3->Fill(neuroinputsegment.priorityTime());
2585 m_neuroHWInTSFoundT_Layer3->Fill(neuroinputsegment.foundTime());
2586 m_neuroHWInTSPrioB_Layer3->Fill(neuroinputsegment.getPriorityPosition());
2587 m_neuroHWInTSLR_Layer3->Fill(neuroinputsegment.getLeftRight());
2588 break;
2589 case 4: m_neuroHWInTSPrioT_Layer4->Fill(neuroinputsegment.priorityTime());
2590 m_neuroHWInTSFoundT_Layer4->Fill(neuroinputsegment.foundTime());
2591 m_neuroHWInTSPrioB_Layer4->Fill(neuroinputsegment.getPriorityPosition());
2592 m_neuroHWInTSLR_Layer4->Fill(neuroinputsegment.getLeftRight());
2593 break;
2594 case 5: m_neuroHWInTSPrioT_Layer5->Fill(neuroinputsegment.priorityTime());
2595 m_neuroHWInTSFoundT_Layer5->Fill(neuroinputsegment.foundTime());
2596 m_neuroHWInTSPrioB_Layer5->Fill(neuroinputsegment.getPriorityPosition());
2597 m_neuroHWInTSLR_Layer5->Fill(neuroinputsegment.getLeftRight());
2598 break;
2599 case 6: m_neuroHWInTSPrioT_Layer6->Fill(neuroinputsegment.priorityTime());
2600 m_neuroHWInTSFoundT_Layer6->Fill(neuroinputsegment.foundTime());
2601 m_neuroHWInTSPrioB_Layer6->Fill(neuroinputsegment.getPriorityPosition());
2602 m_neuroHWInTSLR_Layer6->Fill(neuroinputsegment.getLeftRight());
2603 break;
2604 case 7: m_neuroHWInTSPrioT_Layer7->Fill(neuroinputsegment.priorityTime());
2605 m_neuroHWInTSFoundT_Layer7->Fill(neuroinputsegment.foundTime());
2606 m_neuroHWInTSPrioB_Layer7->Fill(neuroinputsegment.getPriorityPosition());
2607 m_neuroHWInTSLR_Layer7->Fill(neuroinputsegment.getLeftRight());
2608 break;
2609 case 8: m_neuroHWInTSPrioT_Layer8->Fill(neuroinputsegment.priorityTime());
2610 m_neuroHWInTSFoundT_Layer8->Fill(neuroinputsegment.foundTime());
2611 m_neuroHWInTSPrioB_Layer8->Fill(neuroinputsegment.getPriorityPosition());
2612 m_neuroHWInTSLR_Layer8->Fill(neuroinputsegment.getLeftRight());
2613 break;
2614 }
2615 }
2616 }
2617 if (nofinsegments > 0) {
2618 m_neuroHWInTSCount->Fill(nofinsegments);
2619 }
2620 }
2621
2622
2623 if (!m_limitedoutput && m_simSegmentHitsName != "" && m_sim2DTracksSWTSName != "") {
2624 m_2DSWOutTrackCount->Fill(m_sim2DTracksSWTS.getEntries());
2625 for (CDCTriggerTrack& sim2dtrack : m_sim2DTracksSWTS) {
2626 phinorm = sim2dtrack.getPhi0() * 180. / M_PI ;
2627 if (phinorm < 0.) { phinorm = phinorm + 360. ;}
2628 m_2DSWOutPhi0->Fill(phinorm);
2629 m_2DSWOutm_time->Fill(sim2dtrack.getTime());
2630 m_2DSWOutInvPt->Fill(sim2dtrack.getPt());
2631 }
2632 }
2633 if (m_unpacked2DTracksName != "") {
2634 int nof2douttracks = 0;
2635 for (CDCTriggerTrack& finder2dtrack : m_unpacked2DTracks) {
2636 ++nof2douttracks;
2637 phinorm = finder2dtrack.getPhi0() * 180. / M_PI ;
2638 if (phinorm < 0.) {phinorm = phinorm + 360. ;}
2639 m_2DHWOutPhi0->Fill(phinorm);
2640 m_2DHWOutm_time->Fill(finder2dtrack.getTime());
2641 m_2DHWOutInvPt->Fill(finder2dtrack.getPt());
2642 }
2643 if (nof2douttracks > 0) {
2644 m_2DHWOutTrackCount->Fill(nof2douttracks);
2645 if (m_unpackedNeuroTracksName != "") {
2646 m_neuroHWInVs2DOutTrackCount->Fill((nofintracks - nof2douttracks));
2647 }
2648 }
2649
2650 int nof2dinsegments = 0;
2651
2652 for (CDCTriggerSegmentHit& hit : m_unpackedSegmentHits) {
2653 ++nof2dinsegments;
2654 if (!m_limitedoutput) {
2655 unsigned int sl = hit.getISuperLayer();
2656 switch (sl) {
2657 case 0: m_2DHWInTSPrioT_Layer0->Fill(hit.priorityTime());
2658 m_2DHWInTSFoundT_Layer0->Fill(hit.foundTime());
2659 m_2DHWInTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2660 m_2DHWInTSLR_Layer0->Fill(hit.getLeftRight());
2661 break;
2662 case 2: m_2DHWInTSPrioT_Layer2->Fill(hit.priorityTime());
2663 m_2DHWInTSFoundT_Layer2->Fill(hit.foundTime());
2664 m_2DHWInTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2665 m_2DHWInTSLR_Layer2->Fill(hit.getLeftRight());
2666 break;
2667 case 4: m_2DHWInTSPrioT_Layer4->Fill(hit.priorityTime());
2668 m_2DHWInTSFoundT_Layer4->Fill(hit.foundTime());
2669 m_2DHWInTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2670 m_2DHWInTSLR_Layer4->Fill(hit.getLeftRight());
2671 break;
2672 case 6: m_2DHWInTSPrioT_Layer6->Fill(hit.priorityTime());
2673 m_2DHWInTSFoundT_Layer6->Fill(hit.foundTime());
2674 m_2DHWInTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2675 m_2DHWInTSLR_Layer6->Fill(hit.getLeftRight());
2676 break;
2677 case 8: m_2DHWInTSPrioT_Layer8->Fill(hit.priorityTime());
2678 m_2DHWInTSFoundT_Layer8->Fill(hit.foundTime());
2679 m_2DHWInTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2680 m_2DHWInTSLR_Layer8->Fill(hit.getLeftRight());
2681 break;
2682 }
2683 }
2684 }
2685 if (nof2dinsegments > 0) {
2686 }
2687 }
2688
2689
2690 // sw TS
2691 if (!m_limitedoutput && m_simNeuroTracksSWTSSW2DName != "") {
2692 m_neuroSWTSSW2DInTSCount->Fill(m_simSegmentHits.getEntries());
2693 for (CDCTriggerSegmentHit& hit : m_simSegmentHits) {
2694 m_neuroSWTSSW2DInTSID->Fill(hit.getSegmentID());
2695 unsigned int sl = hit.getISuperLayer();
2696 switch (sl) {
2697 case 0: m_neuroSWTSSW2DInTSPrioT_Layer0->Fill(hit.priorityTime());
2698 m_neuroSWTSSW2DInTSFoundT_Layer0->Fill(hit.foundTime());
2699 m_neuroSWTSSW2DInTSPrioB_Layer0->Fill(hit.getPriorityPosition());
2700 m_neuroSWTSSW2DInTSLR_Layer0->Fill(hit.getLeftRight());
2701 break;
2702 case 1: m_neuroSWTSSW2DInTSPrioT_Layer1->Fill(hit.priorityTime());
2703 m_neuroSWTSSW2DInTSFoundT_Layer1->Fill(hit.foundTime());
2704 m_neuroSWTSSW2DInTSPrioB_Layer1->Fill(hit.getPriorityPosition());
2705 m_neuroSWTSSW2DInTSLR_Layer1->Fill(hit.getLeftRight());
2706 break;
2707 case 2: m_neuroSWTSSW2DInTSPrioT_Layer2->Fill(hit.priorityTime());
2708 m_neuroSWTSSW2DInTSFoundT_Layer2->Fill(hit.foundTime());
2709 m_neuroSWTSSW2DInTSPrioB_Layer2->Fill(hit.getPriorityPosition());
2710 m_neuroSWTSSW2DInTSLR_Layer2->Fill(hit.getLeftRight());
2711 break;
2712 case 3: m_neuroSWTSSW2DInTSPrioT_Layer3->Fill(hit.priorityTime());
2713 m_neuroSWTSSW2DInTSFoundT_Layer3->Fill(hit.foundTime());
2714 m_neuroSWTSSW2DInTSPrioB_Layer3->Fill(hit.getPriorityPosition());
2715 m_neuroSWTSSW2DInTSLR_Layer3->Fill(hit.getLeftRight());
2716 break;
2717 case 4: m_neuroSWTSSW2DInTSPrioT_Layer4->Fill(hit.priorityTime());
2718 m_neuroSWTSSW2DInTSFoundT_Layer4->Fill(hit.foundTime());
2719 m_neuroSWTSSW2DInTSPrioB_Layer4->Fill(hit.getPriorityPosition());
2720 m_neuroSWTSSW2DInTSLR_Layer4->Fill(hit.getLeftRight());
2721 break;
2722 case 5: m_neuroSWTSSW2DInTSPrioT_Layer5->Fill(hit.priorityTime());
2723 m_neuroSWTSSW2DInTSFoundT_Layer5->Fill(hit.foundTime());
2724 m_neuroSWTSSW2DInTSPrioB_Layer5->Fill(hit.getPriorityPosition());
2725 m_neuroSWTSSW2DInTSLR_Layer5->Fill(hit.getLeftRight());
2726 break;
2727 case 6: m_neuroSWTSSW2DInTSPrioT_Layer6->Fill(hit.priorityTime());
2728 m_neuroSWTSSW2DInTSFoundT_Layer6->Fill(hit.foundTime());
2729 m_neuroSWTSSW2DInTSPrioB_Layer6->Fill(hit.getPriorityPosition());
2730 m_neuroSWTSSW2DInTSLR_Layer6->Fill(hit.getLeftRight());
2731 break;
2732 case 7: m_neuroSWTSSW2DInTSPrioT_Layer7->Fill(hit.priorityTime());
2733 m_neuroSWTSSW2DInTSFoundT_Layer7->Fill(hit.foundTime());
2734 m_neuroSWTSSW2DInTSPrioB_Layer7->Fill(hit.getPriorityPosition());
2735 m_neuroSWTSSW2DInTSLR_Layer7->Fill(hit.getLeftRight());
2736 break;
2737 case 8: m_neuroSWTSSW2DInTSPrioT_Layer8->Fill(hit.priorityTime());
2738 m_neuroSWTSSW2DInTSFoundT_Layer8->Fill(hit.foundTime());
2739 m_neuroSWTSSW2DInTSPrioB_Layer8->Fill(hit.getPriorityPosition());
2740 m_neuroSWTSSW2DInTSLR_Layer8->Fill(hit.getLeftRight());
2741 break;
2742 }
2743 }
2744 }
2745
2746 static constexpr std::array<int, 9> nWiresInSuperLayer = {
2747 160, 160, 192, 224, 256, 288, 320, 352, 384
2748 };
2749 unsigned axhwts = 0;
2750 unsigned sthwts = 0;
2751 unsigned axswts = 0;
2752 unsigned stswts = 0;
2753
2754 std::vector<TSLine> hwtsoutput;
2755 std::vector<TSLine> swtsoutput;
2756 if (m_unpackedSegmentHitsName != "") {
2757 for (const CDCTriggerSegmentHit& xhit : m_unpackedNeuroInputSegments) {
2758 if (xhit.getISuperLayer() % 2 == 0) {
2759 axhwts ++;
2760 } else {
2761 sthwts ++;
2762 }
2763 int iSL = xhit.getISuperLayer();
2764 int iTS = xhit.getIWire();
2765 int nwires = nWiresInSuperLayer[ iSL ];
2766 if (iSL == 8) {
2767 iTS += 16;
2768 if (iTS > nwires) {
2769 iTS -= nwires;
2770 }
2771 }
2772 int tsIDInTracker = iTS - nwires * xhit.getQuadrant() / 4;
2773 if (tsIDInTracker < 0) {
2774 tsIDInTracker += nwires;
2775 }
2776 TSLine l(xhit);
2777 l.strline = "("
2778 + padto(std::to_string(xhit.getISuperLayer()), 2) + ", "
2779 + padto(std::to_string(xhit.getQuadrant()), 1) + ", "
2780 + padto(std::to_string(xhit.getSegmentID()), 4) + ", "
2781 + padto(std::to_string(xhit.getIWire()), 5) + ", "
2782 + padto(std::to_string(xhit.getPriorityPosition()), 2) + ", "
2783 + padto(std::to_string(xhit.getLeftRight()), 2) + ", "
2784 + padto(std::to_string(xhit.priorityTime()), 4) + ", "
2785 + padto(std::to_string(xhit.foundTime()), 3) + ", "
2786 + padto(std::to_string(tsIDInTracker), 4) + ") | ";
2787
2788 if (m_unpackedNeuroTracksName != "") {
2789 unsigned count2d = 0;
2790 for (CDCTriggerTrack& track : m_unpackedNeuroInput2DTracks) {
2791 count2d++;
2792 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentsName)) {
2793 l.strline += std::to_string(count2d);
2794 } else {
2795 l.strline += ".";
2796 }
2797 }
2798 l.strline += " | ";
2799 unsigned counthwn = 0;
2800 for (CDCTriggerTrack& track : m_unpackedNeuroTracks) {
2801 counthwn++;
2802 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentsName)) {
2803 if (track.getValidStereoBit()) {
2804 l.strline += std::to_string(counthwn);
2805 } else {
2806 l.strline += "x";
2807 }
2808 } else {
2809 l.strline += ".";
2810 }
2811 }
2812 l.strline += " | ";
2813 }
2814 if (m_simNeuroTracksName != "") {
2815 unsigned countswn = 0;
2816 for (CDCTriggerTrack& track : m_simNeuroTracks) {
2817 countswn++;
2818 if (have_relation(track, xhit, m_unpackedNeuroInputSegmentsName)) {
2819 l.strline += std::to_string(countswn);
2820 } else {
2821 l.strline += ".";
2822 }
2823 }
2824 l.strline += " | ";
2825 }
2826 if (m_recoTracksName != "") {
2827 unsigned countreco = 0;
2828 for (const auto& track : m_RecoTracks) {
2829 countreco++;
2830 bool related = false;
2831 for (const CDCTriggerSegmentHit& ts : track.getRelationsTo<CDCTriggerSegmentHit>(m_unpackedNeuroInputSegmentsName)) {
2832 if (&ts == &xhit) {related = true;}
2833 }
2834 if (related) {
2835 l.strline += std::to_string(countreco);
2836 } else {
2837 l.strline += ".";
2838 }
2839 }
2840 l.strline += " | ";
2841 }
2842 if (m_unpackedNeuroTracksName != "") {
2843 sorted_insert(hwtsoutput, l, m_unpackedNeuroInputSegmentsName, m_unpackedNeuroInput2DTracksName, m_unpackedNeuroTracksName);
2844 } else {
2845 hwtsoutput.push_back(l);
2846 }
2847 }
2848 }
2849 std::string axhw = std::to_string(axhwts) + " / " + std::to_string(sthwts);
2850 if (!m_limitedoutput && m_simSegmentHitsName != "") {
2851 for (const CDCTriggerSegmentHit& xhit : m_simSegmentHits) {
2852 if (xhit.getISuperLayer() % 2 == 0) {
2853 axswts ++;
2854 } else {
2855 stswts ++;
2856 }
2857 int iSL = xhit.getISuperLayer();
2858 int iTS = xhit.getIWire();
2859 int nwires = nWiresInSuperLayer[ iSL ];
2860 if (iSL == 8) {
2861 iTS += 16;
2862 if (iTS > nwires) {
2863 iTS -= nwires;
2864 }
2865 }
2866 int tsIDInTracker = iTS - nwires * xhit.getQuadrant() / 4;
2867 if (tsIDInTracker < 0) {
2868 tsIDInTracker += nwires;
2869 }
2870 TSLine l(xhit);
2871 l.strline = "("
2872 + padto(std::to_string(xhit.getISuperLayer()), 2) + ", "
2873 + padto(std::to_string(xhit.getSegmentID()), 4) + ", "
2874 + padto(std::to_string(xhit.getIWire()), 5) + ", "
2875 + padto(std::to_string(xhit.getPriorityPosition()), 2) + ", "
2876 + padto(std::to_string(xhit.getLeftRight()), 2) + ", "
2877 + padto(std::to_string(xhit.priorityTime()), 4) + ", "
2878 + padto(std::to_string(xhit.foundTime()), 3) + ", "
2879 + padto(std::to_string(tsIDInTracker), 4) + ") ";
2880
2881 if (m_sim2DTracksSWTSName != "") {
2882 unsigned count2d = 0;
2883 for (CDCTriggerTrack& track : m_sim2DTracksSWTS) {
2884 count2d++;
2885 if (have_relation(track, xhit, m_simSegmentHitsName)) {
2886 l.strline += std::to_string(count2d);
2887 } else {
2888 l.strline += ".";
2889 }
2890 }
2891 l.strline += " | ";
2892 }
2893 if (m_simNeuroTracksSWTSSW2DName != "") {
2894 unsigned countswn = 0;
2895 for (CDCTriggerTrack& track : m_simNeuroTracksSWTSSW2D) {
2896 countswn++;
2897 if (have_relation(track, xhit, m_simSegmentHitsName)) {
2898 l.strline += std::to_string(countswn);
2899 } else {
2900 l.strline += ".";
2901 }
2902 }
2903 l.strline += " | ";
2904 }
2905 if (m_recoTracksName != "") {
2906 unsigned countreco = 0;
2907 for (const auto& track : m_RecoTracks) {
2908 countreco++;
2909 bool related = false;
2910 for (const CDCTriggerSegmentHit& ts : track.getRelationsTo<CDCTriggerSegmentHit>(m_simSegmentHitsName)) {
2911 if (&ts == &xhit) {related = true;}
2912 }
2913 if (related) {
2914 l.strline += std::to_string(countreco);
2915 } else {
2916 l.strline += ".";
2917 }
2918 }
2919 l.strline += " | ";
2920 }
2921 if (m_simNeuroTracksSWTSSW2DName != "") {
2922 sorted_insert(swtsoutput, l, m_simSegmentHitsName, m_sim2DTracksSWTSName, m_simNeuroTracksSWTSSW2DName);
2923 } else {
2924 swtsoutput.push_back(l);
2925 }
2926 }
2927 }
2928 std::string hwtsstring = "(SL, Q, SID , WID , PP, LR, pT , fT , TSID) | HWNNIn2D | HWNeuro | SWNeuro | ";
2929 std::string swtsstring = "(SL, Q, SID , WID , PP, LR, pT , fT , TSID) | SW2D | SWNeuro | ";
2930 if (m_recoTracksName != "") {
2931 hwtsstring += "Reco | ";
2932 swtsstring += "Reco | ";
2933 }
2934 B2DEBUG(10, padright(" ", 100));
2935 B2DEBUG(10, "----------------------------------------------------------------------------------------------------");
2936 B2DEBUG(10, padright(" ", 100));
2937 std::string experimentstring = "Experiment " + std::to_string(eventMetaData->getExperiment()) + " Run " +
2938 std::to_string(eventMetaData->getRun()) + " Event " + std::to_string(eventMetaData->getEvent());
2939 B2DEBUG(10, padright(experimentstring, 100));
2940 B2DEBUG(10, padright(" ", 100));
2941 B2DEBUG(10, padright(" ", 100));
2942 if (m_unpackedNeuroTracksName != "" && m_unpacked2DTracksName != "") {
2943 B2DEBUG(10, padright("Number of NN HW TS (Axial/Stereo): ", 40) << padright(axhw, 60));
2944 B2DEBUG(10, padright("Number of HW 2DFinderTracks: ", 40) << padright(std::to_string(m_unpacked2DTracks.getEntries()),
2945 60));
2946 unsigned f2dtrn = 0;
2947 for (CDCTriggerTrack& ltrack : m_unpacked2DTracks) {
2948 f2dtrn++;
2949 std::stringstream strpt;
2950 std::stringstream stromega;
2951 std::stringstream strphi;
2952 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
2953 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
2954 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
2955 std::string trs = " HW2DFinderTrack Nr. " + std::to_string(f2dtrn) + " (pt, omega, phi) = ";
2956 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ")";
2957 B2DEBUG(15, padright(trs, 100));
2958 }
2959 B2DEBUG(10, padright("Number of HW NNInput2DFinderTracks: ",
2960 40) << padright(std::to_string(m_unpackedNeuroInput2DTracks.getEntries()), 60));
2961 unsigned n2dtrn = 0;
2962 for (CDCTriggerTrack& ltrack : m_unpackedNeuroInput2DTracks) {
2963 n2dtrn++;
2964 std::stringstream strpt;
2965 std::stringstream stromega;
2966 std::stringstream strphi;
2967 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
2968 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
2969 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
2970 std::string trs = " HWNeuroInput2DTrack Nr. " + std::to_string(n2dtrn) + " (pt, omega, phi) = ";
2971 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ", " + ")";
2972 B2DEBUG(15, padright(trs, 100));
2973 }
2974 B2DEBUG(10, padright("Number of HW NeuroTracks: ",
2975 40) << padright(std::to_string(m_unpackedNeuroTracks.getEntries()), 60));
2976 unsigned hwntrn = 0;
2977 for (CDCTriggerTrack& ltrack : m_unpackedNeuroTracks) {
2978 hwntrn++;
2979 std::stringstream strpt;
2980 std::stringstream stromega;
2981 std::stringstream strphi;
2982 std::stringstream strtheta;
2983 std::stringstream strz;
2984 std::stringstream hwomega;
2985 std::stringstream hwphi;
2986 std::stringstream hwtheta;
2987 std::stringstream hwz;
2988 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
2989 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
2990 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
2991 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
2992 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
2993 hwomega << std::fixed << std::setprecision(0) << ltrack.getRawOmega();
2994 hwphi << std::fixed << std::setprecision(0) << ltrack.getRawPhi0();
2995 hwtheta << std::fixed << std::setprecision(0) << ltrack.getRawTheta();
2996 hwz << std::fixed << std::setprecision(0) << ltrack.getRawZ();
2997 std::string trs = " HWNeuroTrack Nr. " + std::to_string(hwntrn) + " (pt,om,phi,theta,z)=(";
2998 trs += padto(strpt.str(), 4) + "," + padto(stromega.str(), 6) + "," + padto(strphi.str(), 6) + "," + padto(strtheta.str(),
2999 6) + "," + padto(strz.str(), 6) + "),(x," + padto(hwomega.str(), 3) + "," + padto(hwphi.str(), 3) + "," + padto(hwtheta.str(),
3000 3) + "," + padto(hwz.str(), 3) + ")";
3001 B2DEBUG(15, padright(trs, 100));
3002 std::string infostr = ", Found old track: ( ";
3003 for (bool x : ltrack.getFoundOldTrack()) {
3004 infostr += std::to_string(x);
3005 }
3006 infostr += "), ";
3007 infostr = padright(infostr, 50);
3008 infostr += "Drift threshold: ( ";
3009 for (bool x : ltrack.getDriftThreshold()) {
3010 infostr += std::to_string(x);
3011 }
3012 infostr += ")";
3013 infostr += (ltrack.getValidStereoBit()) ? " valid" : " NOT valid";
3014 B2DEBUG(15, padright(infostr, 100));
3015 std::string infostr2 = " std. ETF vld:";
3016 infostr2 += std::to_string(m_eventTime.isValid());
3017 infostr2 += ", ETFT0: ";
3018 if (m_eventTime.isValid()) {
3019 infostr2 += std::to_string(m_eventTime->getBinnedEventT0(Const::CDC));
3020 } else {
3021 infostr2 += " ";
3022 }
3023 infostr2 += ", ETF in CC: ";
3024 infostr2 += std::to_string(ltrack.getETF_unpacked());
3025 infostr2 += ", ETF recalculated: ";
3026 infostr2 += std::to_string(ltrack.getETF_recalced());
3027 B2DEBUG(15, padright(infostr2, 100));
3028 std::string info2str = " Expert Network Number: " + std::to_string(ltrack.getExpert());
3029 info2str += ", TSVector: (";
3030 for (unsigned x : ltrack.getTSVector()) {
3031 info2str += std::to_string(x) + " ";
3032 }
3033 info2str += ")";
3034 info2str += ", Quality=";
3035 info2str += std::to_string(ltrack.getQualityVector());
3036 B2DEBUG(15, padright(info2str, 100));
3037 CDCTriggerTrack* ftrack = ltrack.getRelatedFrom<CDCTriggerTrack>(m_unpackedNeuroInput2DTracksName);
3038 CDCTriggerTrack* strack = ftrack->getRelatedTo<CDCTriggerTrack>(m_simNeuroTracksName);
3039 if (strack) {
3040 vector<float> unpackedInput =
3041 ltrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
3042 // vector<float> simInput = ltrack.getRelatedTo<CDCTriggerMLPInput>(m_unpackedNeuroInputVectorName)->getInput();
3043 vector<float> simInput =
3044 strack->getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorName)->getInput();
3045 B2DEBUG(20, padright(" Input Vector unpacked (id, t, alpha), sim (id, t, alpha), delta (id, t, alpha):", 100));
3046 for (unsigned ii = 0; ii < unpackedInput.size(); ii += 3) {
3047 std::string lla = " " + std::to_string(ii / 3) + ")";
3048 std::string llb = " " + std::to_string(ii / 3) + ")";
3049 lla += "(" + padright(std::to_string(unpackedInput[ii]), 8) + " " + padright(std::to_string(unpackedInput[ii + 1]),
3050 8) + " " + padright(std::to_string(unpackedInput[ii + 2]), 8) + "),(" + padright(std::to_string(simInput[ii]),
3051 8) + " " + padright(std::to_string(simInput[ii + 1]), 8) + " " + padright(std::to_string(simInput[ii + 2]),
3052 8) + "),(" + padright(std::to_string(unpackedInput[ii] - simInput[ii]),
3053 8) + " " + padright(std::to_string(unpackedInput[ii + 1] - simInput[ii + 1]),
3054 8) + " " + padright(std::to_string(unpackedInput[ii + 2] - simInput[ii + 2]), 8) + ")";
3055 llb += " (" + padright(std::to_string(int(unpackedInput[ii] * 4096)),
3056 8) + " " + padright(std::to_string(int(unpackedInput[ii + 1] * 4096)),
3057 8) + " " + padright(std::to_string(int(unpackedInput[ii + 2] * 4096)),
3058 8) + "),(" + padright(std::to_string(int(simInput[ii] * 4096)), 8) + " " + padright(std::to_string(int(simInput[ii + 1] * 4096)),
3059 8) + " " + padright(std::to_string(int(simInput[ii + 2] * 4096)),
3060 8) + "),(" + padright(std::to_string(int(unpackedInput[ii] * 4096 - simInput[ii] * 4096)),
3061 8) + " " + padright(std::to_string(int(unpackedInput[ii + 1] * 4096 - simInput[ii + 1] * 4096)),
3062 8) + " " + padright(std::to_string(int(unpackedInput[ii + 2] * 4096 - simInput[ii + 2] * 4096)), 8) + ")";
3063
3064 // cout << hex;
3065 // cout.setf(ios::showbase);
3066 // cout << " (" << setw(11) << (int)(unpackedInput[ii] * 4096) << ", " << setw(11) << (int)(
3067 // unpackedInput[ii + 1] * 4096) << ", " << setw(11) << (int)(unpackedInput[ii + 2] * 4096) << "), ";
3068 // cout << "(" << setw(11) << (int)(simInput[ii] * 4096) << ", " << setw(11) << (int)(
3069 // simInput[ii + 1] * 4096) << ", " << setw(11) << (int)(simInput[ii + 2] * 4096) << "), ";
3070 // cout << "(" << setw(11) << (int)(unpackedInput[ii] * 4096 - simInput[ii] * 4096) << ", " << setw(11) << (int)(
3071 // unpackedInput[ii + 1] * 4096 - simInput[ii + 1] * 4096) << ", " << setw(11) << (int)(unpackedInput[ii + 2] * 4096 - simInput[ii +
3072 // 2] * 4096) << "), " << endl;
3073 // cout.unsetf(ios::showbase);
3074 // cout << dec;
3075 //std::cout << " (" << simInput[ii] / unpackedInput[ii] << std::endl << ", " << simInput[ii + 1] / unpackedInput[ii + 1] << ", " <<
3076 // simInput[ii + 2] / unpackedInput[ii + 2] << ")" << std::endl;
3077 B2DEBUG(30, padright(lla, 100));
3078 B2DEBUG(20, padright(llb, 100));
3079 }
3080 }
3081 }
3082
3083
3084 }
3085 if (!m_limitedoutput && m_simNeuroTracksName != "") {
3086 B2DEBUG(10, padright("Number of SW NeuroTracks: ", 40) << padright(std::to_string(m_simNeuroTracks.getEntries()), 60));
3087 unsigned swntrn = 0;
3088 for (CDCTriggerTrack& ltrack : m_simNeuroTracks) {
3089 swntrn++;
3090 std::stringstream strpt;
3091 std::stringstream stromega;
3092 std::stringstream strphi;
3093 std::stringstream strtheta;
3094 std::stringstream strz;
3095 std::stringstream strquality;
3096 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
3097 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
3098 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
3099 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
3100 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
3101 strquality << std::fixed << ltrack.getQualityVector();
3102
3103 std::string trs = " SWNeuroTrack Nr. " + std::to_string(swntrn) + " (pt,om,phi,theta,z)=(";
3104 trs += padto(strpt.str(), 5) + "," + padto(stromega.str(), 5) + "," + padto(strphi.str(), 6) + "," + padto(strtheta.str(),
3105 6) + ", " + padto(strz.str(), 6) + ")"
3106 + " Q=" + strquality.str();
3108 B2DEBUG(15, padright(trs, 100));
3109 }
3110 }
3111 if (!m_limitedoutput && m_simSegmentHitsName != "") {
3112 std::string axsw = std::to_string(axswts) + " / " + std::to_string(stswts);
3113 B2DEBUG(10, padright("Number of AllSW TS (Axial/Stereo): ", 40) << padright(axsw, 60));
3114 if (m_sim2DTracksSWTSName != "" && m_simNeuroTracksSWTSSW2DName != "") {
3115 B2DEBUG(10, padright("Number of SW 2DFinderSWTSTracks: ", 40) << padright(std::to_string(m_sim2DTracksSWTS.getEntries()),
3116 60));
3117 unsigned sf2dtrn = 0;
3118 for (CDCTriggerTrack& ltrack : m_sim2DTracksSWTS) {
3119 sf2dtrn++;
3120 std::stringstream strpt;
3121 std::stringstream stromega;
3122 std::stringstream strphi;
3123 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
3124 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
3125 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
3126 std::string trs = " SW2DFinderSWTSTrack Nr. " + std::to_string(sf2dtrn) + " (pt, omega, phi) = ";
3127 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ")";
3128 B2DEBUG(15, padright(trs, 100));
3129 }
3130 B2DEBUG(10, padright("Number of SW NeuroSWTSSW2DTracks: ",
3131 40) << padright(std::to_string(m_simNeuroTracksSWTSSW2D.getEntries()), 60));
3132 unsigned aswntrn = 0;
3133 for (CDCTriggerTrack& ltrack : m_simNeuroTracksSWTSSW2D) {
3134 aswntrn++;
3135 std::stringstream strpt;
3136 std::stringstream stromega;
3137 std::stringstream strphi;
3138 std::stringstream strtheta;
3139 std::stringstream strz;
3140 strpt << std::fixed << std::setprecision(2) << ltrack.getPt();
3141 stromega << std::fixed << std::setprecision(2) << ltrack.getOmega();
3142 strphi << std::fixed << std::setprecision(2) << (ltrack.getPhi0() * 180. / M_PI);
3143 strtheta << std::fixed << std::setprecision(2) << (ltrack.getDirection().Theta() * 180. / M_PI);
3144 strz << std::fixed << std::setprecision(2) << ltrack.getZ0();
3145 std::string trs = " SWNeuroSWTSSW2DTrack Nr. " + std::to_string(aswntrn) + " (pt, omega, phi, theta, z) = ";
3146 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ", " + padto(strtheta.str(),
3147 6) + ", " + padto(strz.str(), 6) + ")";
3148 B2DEBUG(15, padright(trs, 100));
3149 vector<float> simInputSWTSSW2D =
3150 ltrack.getRelatedTo<CDCTriggerMLPInput>(m_simNeuroInputVectorSWTSSW2DName)->getInput();
3151 B2DEBUG(20, padright(" Input Vector simulated (id, t, alpha):", 100));
3152 for (unsigned ii = 0; ii < simInputSWTSSW2D.size(); ii += 3) {
3153 std::string lla = " " + std::to_string(ii / 3) + ")";
3154 std::string llb = " " + std::to_string(ii / 3) + ")";
3155 lla += "(" + padright(std::to_string(simInputSWTSSW2D[ii]),
3156 8) + " " + padright(std::to_string(simInputSWTSSW2D[ii + 1]), 8) + " " + padright(std::to_string(simInputSWTSSW2D[ii + 2]),
3157 8) + ")";
3158 llb += " (" + padright(std::to_string(int(simInputSWTSSW2D[ii] * 4096)),
3159 8) + " " + padright(std::to_string(int(simInputSWTSSW2D[ii + 1] * 4096)),
3160 8) + " " + padright(std::to_string(int(simInputSWTSSW2D[ii + 2] * 4096)),
3161 8) + ")";
3162 B2DEBUG(30, padright(lla, 100));
3163 B2DEBUG(20, padright(llb, 100));
3164 }
3165
3166 }
3167 }
3168 }
3169 if (m_recoTracksName != "") {
3170 B2DEBUG(10, padright("Number of RecoTracks: ", 40) << padright(std::to_string(m_RecoTracks.getEntries()), 60));
3171 unsigned recotrn = 0;
3172 for (RecoTrack& ltrack : m_RecoTracks) {
3173 double phi0Target = 0;
3174 double invptTarget = 0;
3175 double thetaTarget = 0;
3176 double zTarget = 0;
3177 double d0Target = 0;
3178 bool foundValidRep = false;
3179 for (genfit::AbsTrackRep* rep : ltrack.getRepresentations()) {
3180 if (!ltrack.wasFitSuccessful(rep))
3181 continue;
3182 // get state (position, momentum etc.) from hit closest to IP and
3183 // extrapolate to z-axis (may throw an exception -> continue to next representation)
3184 try {
3185 genfit::MeasuredStateOnPlane state =
3186 ltrack.getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), rep);
3187 rep->extrapolateToLine(state, TVector3(0, 0, -1000), TVector3(0, 0, 2000));
3188 // TODO check after matching
3189 // // flip tracks if necessary, such that trigger tracks and reco tracks
3190 // // point in the same direction
3191 // if (state.getMom().Dot(m_tracks[itrack]->getDirection()) < 0) {
3192 // state.setPosMom(state.getPos(), -state.getMom());
3193 // state.setChargeSign(-state.getCharge());
3194 // }
3195 // get track parameters
3196 phi0Target = state.getMom().Phi() * 180. / M_PI ;
3197 if (phi0Target < 0.) {phi0Target = phi0Target + 360. ;}
3198 invptTarget = state.getCharge() * state.getMom().Pt();
3199 thetaTarget = acos(state.getMom().CosTheta()) * 180 / M_PI;
3200 zTarget = state.getPos().Z();
3201 d0Target = state.getPos().Perp();
3202 } catch (...) {
3203 continue;
3204 }
3205 // break loop
3206 foundValidRep = true;
3207 break;
3208 }
3209 if (!foundValidRep) {
3210 B2DEBUG(150, "No valid representation found for RecoTrack, skipping.");
3211 continue;
3212 } else {
3213 if (m_maxRecoZDist != -1.0 and abs(zTarget) > m_maxRecoZDist) {
3214 B2DEBUG(150, "RecoTrack not close to IP (maxRecoZDist), zReco = " << zTarget);
3215 continue;
3216 }
3217 if (m_maxRecoD0Dist != -1.0 and abs(d0Target) > m_maxRecoD0Dist) {
3218 B2DEBUG(150, "RecoTrack not close to the z axis (maxRecoD0Dist), d0Reco = " << d0Target);
3219 continue;
3220 }
3221 }
3222 recotrn++;
3223 std::stringstream strpt;
3224 std::stringstream stromega;
3225 std::stringstream strphi;
3226 std::stringstream strtheta;
3227 std::stringstream strz;
3228 strpt << std::fixed << std::setprecision(2) << invptTarget;
3229 stromega << std::fixed << std::setprecision(2) << d0Target;
3230 strphi << std::fixed << std::setprecision(2) << phi0Target;
3231 strtheta << std::fixed << std::setprecision(2) << thetaTarget;
3232 strz << std::fixed << std::setprecision(2) << zTarget;
3233 std::string trs = " RecoTrack Nr. " + std::to_string(recotrn) + " (invpt, d0, phi, theta, z) = ";
3234 trs += padto(strpt.str(), 6) + ", " + padto(stromega.str(), 6) + ", " + padto(strphi.str(), 6) + ", " + padto(strtheta.str(),
3235 6) + ", " + padto(strz.str(), 6) + ")";
3236 B2DEBUG(15, padright(trs, 100));
3237 }
3238 }
3239 B2DEBUG(10, padright(" ", 100));
3240 B2DEBUG(10, padright(" ", 100));
3241 if (m_unpackedSegmentHitsName != "") {
3242 B2DEBUG(15, padright("Detailed information about HW TS ", 100));
3243 B2DEBUG(15, padright(" ", 100));
3244 B2DEBUG(15, padright(hwtsstring, 100));
3245 for (auto x : hwtsoutput) {
3246 B2DEBUG(15, padright(x.strline, 100));
3247 }
3248 B2DEBUG(15, padright(" ", 100));
3249 }
3250 if (!m_limitedoutput && m_simSegmentHitsName != "") {
3251 B2DEBUG(15, padright(" ", 100));
3252 B2DEBUG(15, padright("Detailed information about SW TS ", 100));
3253 B2DEBUG(15, padright(" ", 100));
3254 B2DEBUG(15, padright(swtsstring, 100));
3255 for (auto x : swtsoutput) {
3256 B2DEBUG(15, padright(x.strline, 100));
3257 }
3258 }
3259}
3260
3261
3262void CDCTriggerNeuroDQMModule::endRun()
3263{
3264}
3265
3266
3267void CDCTriggerNeuroDQMModule::terminate()
3268{
3269}
Belle2::BinnedEventT0::getBinnedEventT0
int getBinnedEventT0(const Const::EDetector detector) const
Return the stored binned event t0 for the given detector or 0 if nothing stored.
Definition: BinnedEventT0.cc:13
Belle2::CDCTriggerMLPInput
Class to hold some intermediate information for the monitoring of the neurotrigger.
Definition: CDCTriggerMLPInput.h:20
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroInputVector
StoreArray< CDCTriggerMLPInput > m_simNeuroInputVector
StoreArray for neuro input vector from TSIM.
Definition: CDCTriggerNeuroDQMModule.h:233
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer6
TH1F * m_neuroSWTSSW2DInputID_Layer6
simulated id input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:647
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutInvPt
TH1F * m_neuroRecoSWOutInvPt
reco matched Inverse Pt distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:700
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer8
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:557
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer4
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:553
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer0
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:506
Belle2::CDCTriggerNeuroDQMModule::m_limitedoutput
bool m_limitedoutput
Switch to supress output for dqm online module.
Definition: CDCTriggerNeuroDQMModule.h:171
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer7
TH1F * m_neuroSWSelTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:470
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaInputT
TH1F * m_neuroDeltaInputT
unpacked time input - TSIM time input
Definition: CDCTriggerNeuroDQMModule.h:301
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroInputSegments
StoreArray< CDCTriggerSegmentHit > m_unpackedNeuroInputSegments
StoreArray for neuro input Track segments.
Definition: CDCTriggerNeuroDQMModule.h:229
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer3
TH1F * m_neuroSWSelTSPrioT_Layer3
Priority time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:447
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer7
TH1F * m_neuroHWInputID_Layer7
unpacked id input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:592
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer5
TH1F * m_neuroSWSelTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:478
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer2
TH1F * m_neuroSWSelTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:475
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer6
TH1F * m_neuroSWTSSW2DInputT_Layer6
simulated time input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:648
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer5
TH1F * m_neuroHWSelTSPrioT_Layer5
Priority time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:380
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer1
TH1F * m_neuroSWSelTSPrioT_Layer1
Priority time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:445
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer4
TH1F * m_2DHWInTSPrioB_Layer4
Priority bits of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:431
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroInput2DTracks
StoreArray< CDCTriggerTrack > m_unpackedNeuroInput2DTracks
StoreArray for neuro input 2dfinder tracks.
Definition: CDCTriggerNeuroDQMModule.h:227
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer3
TH1F * m_neuroHWInTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:365
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer3
TH1F * m_neuroSWInputAlpha_Layer3
simulated alpha input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:611
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroTracks
StoreArray< CDCTriggerTrack > m_unpackedNeuroTracks
StoreArray for neuro tracks from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:223
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutInvPt
TH1F * m_neuroSWOutInvPt
Inverse Pt distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:273
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer7
TH1F * m_neuroSWInputID_Layer7
simulated id input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:621
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer2
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer2
Found time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:541
Belle2::CDCTriggerNeuroDQMModule::m_2DHWOutInvPt
TH1F * m_2DHWOutInvPt
Inverse Pt of 2dtracks.
Definition: CDCTriggerNeuroDQMModule.h:264
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer2
TH1F * m_neuroSWTSSW2DInputID_Layer2
simulated id input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:635
Belle2::CDCTriggerNeuroDQMModule::m_unpackedSegmentHitsName
std::string m_unpackedSegmentHitsName
Name for TS hits from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:176
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutZ
TH1F * m_neuroRecoHWOutZ
reco matched z distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:675
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer1
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer1
Found time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:497
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInPhi0
TH1F * m_neuroHWInPhi0
Phi0 of incoming 2dtrack.
Definition: CDCTriggerNeuroDQMModule.h:259
Belle2::CDCTriggerNeuroDQMModule::m_2DHWOutTrackCount
TH1F * m_2DHWOutTrackCount
number of 2dtracks per event
Definition: CDCTriggerNeuroDQMModule.h:267
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer3
TH1F * m_neuroSWSelTSFoundT_Layer3
Found time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:456
Belle2::CDCTriggerNeuroDQMModule::m_recoTrackMultiplicity
int m_recoTrackMultiplicity
Select events with a specific RecoTrack track multiplicity.
Definition: CDCTriggerNeuroDQMModule.h:196
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer2
TH1F * m_neuroSWTSSW2DInputAlpha_Layer2
simulated alpha input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:637
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer8
TH1F * m_neuroHWInTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:360
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer5
TH1F * m_neuroHWInTSPrioT_Layer5
Priority time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:338
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer6
TH1F * m_neuroSWInputID_Layer6
simulated id input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:618
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer0
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:549
Belle2::CDCTriggerNeuroDQMModule::m_RecoInvPt
TH1F * m_RecoInvPt
reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:661
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer2
TH1F * m_neuroSWTSSW2DInTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:518
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer4
TH1F * m_neuroHWInputAlpha_Layer4
unpacked alpha input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:585
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer3
TH1F * m_neuroSWTSSW2DSelTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:562
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer8
TH1F * m_neuroSWSelTSPrioT_Layer8
Priority time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:452
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer6
TH1F * m_neuroHWInTSFoundT_Layer6
Found time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:348
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer8
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer8
Found time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:547
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer7
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer7
Priority time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:537
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer3
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:552
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer0
TH1F * m_neuroSWSelTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:463
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1Z
TH1F * m_neuroHWOutQuad1Z
z distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:317
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer5
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer5
Priority time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:535
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer3
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer3
Found time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:542
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutInvPt
TH1F * m_neuroSWTSSW2DOutInvPt
Inverse Pt distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:288
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInVs2DOutTrackCount
TH1F * m_neuroHWInVs2DOutTrackCount
neuroHWInTrackCount - 2DHWOutTrackCountput
Definition: CDCTriggerNeuroDQMModule.h:268
Belle2::CDCTriggerNeuroDQMModule::m_neuroScatterTheta
TH2F * m_neuroScatterTheta
unpacked theta vs TSIM theta, scatter plot
Definition: CDCTriggerNeuroDQMModule.h:298
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer5
TH1F * m_neuroSWInputT_Layer5
simulated time input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:616
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer2
TH1F * m_2DHWInTSFoundT_Layer2
Found time of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:424
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWZScatter
TH2F * m_RecoHWZScatter
matched to HW reconstructed z scatter plot
Definition: CDCTriggerNeuroDQMModule.h:672
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer1
TH1F * m_neuroSWSelTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:464
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSCount
TH1F * m_neuroSWTSSW2DInTSCount
number of TS per event
Definition: CDCTriggerNeuroDQMModule.h:486
Belle2::CDCTriggerNeuroDQMModule::m_maxRecoD0Dist
double m_maxRecoD0Dist
Select only RecoTracks with a maximum d0 distance to the z axis.
Definition: CDCTriggerNeuroDQMModule.h:202
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutPhi0
TH1F * m_neuroRecoSWTSSW2DOutPhi0
reco matched phi distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:724
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutCosTheta
TH1F * m_neuroRecoHWOutCosTheta
reco matched cos theta distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:676
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer2
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer2
Priority time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:532
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSCount
TH1F * m_neuroHWSelTSCount
number of selected TS per SL
Definition: CDCTriggerNeuroDQMModule.h:374
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutPhi0
TH1F * m_neuroSWOutPhi0
phi distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:274
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DInvPt
TH1F * m_DeltaRecoSWTSSW2DInvPt
matched to SWTSSW2DSWNN reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:733
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer2
TH1F * m_neuroHWInTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:364
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer4
TH1F * m_neuroHWInTSPrioT_Layer4
Priority time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:337
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutHitPattern
TH1F * m_neuroRecoHWOutHitPattern
reco matched stereo hit pattern from unpacker
Definition: CDCTriggerNeuroDQMModule.h:679
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInm_time
TH1F * m_neuroHWInm_time
m_time distribution from incoming 2dtracks
Definition: CDCTriggerNeuroDQMModule.h:260
Belle2::CDCTriggerNeuroDQMModule::m_RecoTrackCount
TH1F * m_RecoTrackCount
number of reconstructed tracks per event
Definition: CDCTriggerNeuroDQMModule.h:664
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer6
TH1F * m_neuroSWSelTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:479
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer4
TH1F * m_2DHWInTSFoundT_Layer4
Found time of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:425
Belle2::CDCTriggerNeuroDQMModule::m_showRecoTracks
bool m_showRecoTracks
Switch to turn on a comparison with the reconstruction.
Definition: CDCTriggerNeuroDQMModule.h:194
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaTheta
TH1F * m_neuroDeltaTheta
unpacked theta - TSIM theta
Definition: CDCTriggerNeuroDQMModule.h:296
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutInvPt
TH1F * m_neuroRecoSWTSSW2DOutInvPt
reco matched Inverse Pt distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:723
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer5
TH1F * m_neuroSWSelTSFoundT_Layer5
Found time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:458
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer4
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer4
Found time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:543
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DInvPt
TH1F * m_RecoSWTSSW2DInvPt
matched to SWTSSW2DSWNN reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:715
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer4
TH1F * m_2DHWInTSLR_Layer4
Left/Right of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:436
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer0
TH1F * m_2DHWInTSFoundT_Layer0
Found time of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:423
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer1
TH1F * m_neuroSWTSSW2DInputT_Layer1
simulated time input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:633
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutZ
TH1F * m_neuroHWOutZ
z distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:248
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer2
TH1F * m_neuroHWInputT_Layer2
unpacked time input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:578
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer5
TH1F * m_neuroSWTSSW2DInputID_Layer5
simulated id input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:644
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DCosTheta
TH1F * m_DeltaRecoSWTSSW2DCosTheta
matched to SWTSSW2DSWNN reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:732
Belle2::CDCTriggerNeuroDQMModule::initialize
virtual void initialize() override
Module functions.
Definition: CDCTriggerNeuroDQMModule.cc:1263
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer0
TH1F * m_neuroSWTSSW2DInTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:516
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInInvPt
TH1F * m_neuroHWInInvPt
Inverse Pt distribution from incoming 2dtrack.
Definition: CDCTriggerNeuroDQMModule.h:258
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutInvPt
TH1F * m_neuroRecoHWOutInvPt
reco matched Inverse Pt distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:677
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2InvPt
TH1F * m_neuroHWOutQuad2InvPt
Inverse Pt distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:324
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSector
TH1F * m_neuroSWSector
NN sector from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:277
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer7
TH1F * m_neuroSWSelTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:480
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer1
TH1F * m_neuroHWSelTSFoundT_Layer1
Found time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:385
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer1
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:507
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer3
TH1F * m_neuroHWInputAlpha_Layer3
unpacked alpha input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:582
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer6
TH1F * m_neuroSWTSSW2DInputAlpha_Layer6
simulated alpha input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:649
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer6
TH1F * m_neuroHWSelTSFoundT_Layer6
Found time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:390
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer2
TH1F * m_neuroHWInTSFoundT_Layer2
Found time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:344
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0Phi0
TH1F * m_neuroHWOutQuad0Phi0
phi distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:315
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWInvPt
TH1F * m_DeltaRecoHWInvPt
matched to HW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:686
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer0
TH1F * m_neuroSWInputT_Layer0
simulated time input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:601
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer1
TH1F * m_neuroHWInTSPrioT_Layer1
Priority time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:334
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer6
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer6
Priority time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:493
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer1
TH1F * m_neuroSWInputAlpha_Layer1
simulated alpha input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:605
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutTrackCount
TH1F * m_neuroSWOutTrackCount
number of simulated tracks per event (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:276
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutTrackCount
TH1F * m_neuroSWTSSW2DOutTrackCount
number of simulated tracks per event (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:291
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer5
TH1F * m_neuroHWSelTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:399
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer4
TH1F * m_neuroHWSelTSFoundT_Layer4
Found time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:388
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer3
TH1F * m_neuroSWTSSW2DInputAlpha_Layer3
simulated alpha input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:640
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer4
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer4
Found time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:500
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer8
TH1F * m_2DHWInTSFoundT_Layer8
Found time of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:427
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer8
TH1F * m_2DHWInTSPrioT_Layer8
Priority time of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:422
Belle2::CDCTriggerNeuroDQMModule::condFill
void condFill(TH1F *histo, float value)
Fill a histogram only with non-zero values.
Definition: CDCTriggerNeuroDQMModule.h:65
Belle2::CDCTriggerNeuroDQMModule::m_simSameTS
TH1F * m_simSameTS
number of TS selected in both, unpacked and TSIM tracks
Definition: CDCTriggerNeuroDQMModule.h:305
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer8
TH1F * m_neuroHWInTSFoundT_Layer8
Found time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:350
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer3
TH1F * m_neuroHWSelTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:397
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer8
TH1F * m_neuroSWInputID_Layer8
simulated id input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:624
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSFoundT_Layer6
TH1F * m_2DHWInTSFoundT_Layer6
Found time of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:426
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutTrackCount
TH1F * m_neuroRecoSWOutTrackCount
reco matched number of simulated tracks per event (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:703
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer6
TH1F * m_neuroSWInputAlpha_Layer6
simulated alpha input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:620
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer3
TH1F * m_neuroSWTSSW2DInputT_Layer3
simulated time input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:639
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer8
TH1F * m_2DHWInTSPrioB_Layer8
Priority bits of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:433
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer3
TH1F * m_neuroSWTSSW2DInTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:519
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1InvPt
TH1F * m_neuroHWOutQuad1InvPt
Inverse Pt distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:320
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer0
TH1F * m_neuroSWSelTSPrioT_Layer0
Priority time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:444
Belle2::CDCTriggerNeuroDQMModule::event
virtual void event() override
Function to process event record.
Definition: CDCTriggerNeuroDQMModule.cc:1795
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWPhi
TH1F * m_RecoSWPhi
matched to SW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:693
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWD0
TH1F * m_RecoSWD0
matched to SW reconstructed d0
Definition: CDCTriggerNeuroDQMModule.h:694
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer3
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer3
Found time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:499
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutHitPattern
TH1F * m_neuroRecoSWTSSW2DOutHitPattern
reco matched stereo hit pattern of simulated neuro tracks (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:725
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer5
TH1F * m_neuroHWInTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:367
Belle2::CDCTriggerNeuroDQMModule::m_simSegmentHits
StoreArray< CDCTriggerSegmentHit > m_simSegmentHits
StoreArray for simulated TS hits.
Definition: CDCTriggerNeuroDQMModule.h:238
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer6
TH1F * m_neuroHWInTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:368
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer6
TH1F * m_neuroSWSelTSPrioT_Layer6
Priority time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:450
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer2
TH1F * m_neuroHWInputAlpha_Layer2
unpacked alpha input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:579
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWD0
TH1F * m_RecoHWD0
matched to HW reconstructed d0
Definition: CDCTriggerNeuroDQMModule.h:671
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer0
TH1F * m_neuroSWSelTSFoundT_Layer0
Found time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:453
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer2
TH1F * m_neuroSWTSSW2DSelTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:561
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer1
TH1F * m_neuroHWInTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:353
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer4
TH1F * m_neuroHWInputID_Layer4
unpacked id input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:583
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer6
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer6
Found time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:545
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer5
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer5
Found time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:544
Belle2::CDCTriggerNeuroDQMModule::m_simSegmentHitsName
std::string m_simSegmentHitsName
Name for simulated TS hits.
Definition: CDCTriggerNeuroDQMModule.h:205
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSID
TH1F * m_neuroSWTSSW2DSelTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:528
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer7
TH1F * m_neuroSWInputT_Layer7
simulated time input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:622
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer6
TH1F * m_neuroHWSelTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:400
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer1
TH1F * m_neuroSWTSSW2DInTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:517
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSID
TH1F * m_neuroSWSelTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:442
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer4
TH1F * m_neuroSWTSSW2DInTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:520
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSector
TH1F * m_neuroSWTSSW2DSector
NN sector from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:292
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer5
TH1F * m_neuroHWInTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:357
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer3
TH1F * m_neuroSWTSSW2DInputID_Layer3
simulated id input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:638
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer7
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer7
Priority time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:494
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer4
TH1F * m_neuroSWSelTSPrioT_Layer4
Priority time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:448
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer0
TH1F * m_neuroSWInputID_Layer0
simulated id input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:600
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutHitPattern
TH1F * m_neuroRecoSWOutHitPattern
reco matched stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:702
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer8
TH1F * m_neuroSWTSSW2DSelTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:567
Belle2::CDCTriggerNeuroDQMModule::m_unpacked2DTracksName
std::string m_unpacked2DTracksName
Name for 2D finder tracks from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:178
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer2
TH1F * m_neuroHWSelTSPrioT_Layer2
Priority time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:377
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer7
TH1F * m_neuroHWInTSFoundT_Layer7
Found time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:349
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DZScatter
TH2F * m_RecoSWTSSW2DZScatter
matched to SWTSSW2DSWNN reconstructed z scatter plot
Definition: CDCTriggerNeuroDQMModule.h:718
Belle2::CDCTriggerNeuroDQMModule::m_simDiffTS
TH1F * m_simDiffTS
number of TS selcted in TSIM but not in unpacked
Definition: CDCTriggerNeuroDQMModule.h:306
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer6
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:512
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer4
TH1F * m_neuroHWInTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:356
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutZ
TH1F * m_neuroSWOutZ
z distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:271
Belle2::CDCTriggerNeuroDQMModule::endRun
virtual void endRun() override
Function to process end_run record.
Definition: CDCTriggerNeuroDQMModule.cc:3262
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer7
TH1F * m_neuroHWSelTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:401
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer5
TH1F * m_neuroSWTSSW2DInputAlpha_Layer5
simulated alpha input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:646
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutInvPt
TH1F * m_2DSWOutInvPt
Inverse Pt of 2dtracks (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:280
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer7
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer7
Found time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:503
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer1
TH1F * m_neuroHWInputT_Layer1
unpacked time input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:575
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer3
TH1F * m_neuroHWInputID_Layer3
unpacked id input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:580
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer0
TH1F * m_neuroSWInputAlpha_Layer0
simulated alpha input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:602
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutHitPattern
TH1F * m_neuroSWTSSW2DOutHitPattern
stereo hit pattern of simulated neuro tracks (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:290
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroInputSegmentsName
std::string m_unpackedNeuroInputSegmentsName
Name for neuro input Track segments.
Definition: CDCTriggerNeuroDQMModule.h:186
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer2
TH1F * m_neuroHWInTSPrioT_Layer2
Priority time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:335
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer4
TH1F * m_neuroSWInputID_Layer4
simulated id input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:612
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWCosTheta
TH1F * m_RecoSWCosTheta
matched to SW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:691
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutm_time
TH1F * m_2DSWOutm_time
m_time 2dtracks (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:282
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer0
TH1F * m_2DHWInTSPrioB_Layer0
Priority bits of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:429
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutTrackCount
TH1F * m_2DSWOutTrackCount
number of 2dtracks per event (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:283
Belle2::CDCTriggerNeuroDQMModule::terminate
virtual void terminate() override
Function to terminate module.
Definition: CDCTriggerNeuroDQMModule.cc:3267
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer7
TH1F * m_neuroHWSelTSPrioT_Layer7
Priority time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:382
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer0
TH1F * m_neuroHWSelTSPrioT_Layer0
Priority time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:375
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWZScatter
TH2F * m_RecoSWZScatter
matched to SW reconstructed z scatter plot
Definition: CDCTriggerNeuroDQMModule.h:695
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroInput2DTracksName
std::string m_unpackedNeuroInput2DTracksName
Name for neuro input 2d finder tracks.
Definition: CDCTriggerNeuroDQMModule.h:184
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer0
TH1F * m_neuroHWInputT_Layer0
unpacked time input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:572
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer6
TH1F * m_neuroHWInputID_Layer6
unpacked id input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:589
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutTrackCount
TH1F * m_neuroRecoSWTSSW2DOutTrackCount
reco matched number of simulated tracks per event (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:727
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0CosTheta
TH1F * m_neuroHWOutQuad0CosTheta
cos theta distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:314
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer4
TH1F * m_neuroSWTSSW2DSelTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:563
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer8
TH1F * m_neuroSWSelTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:471
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer1
TH1F * m_neuroHWInTSFoundT_Layer1
Found time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:343
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutPt
TH1F * m_neuroHWOutPt
Pt distribution of unpacked neuro tracks.
Definition: CDCTriggerNeuroDQMModule.h:251
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer6
TH1F * m_neuroHWSelTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:410
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3Phi0
TH1F * m_neuroHWOutQuad3Phi0
phi distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:327
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer7
TH1F * m_neuroHWInputAlpha_Layer7
unpacked alpha input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:594
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer8
TH1F * m_neuroSWInputT_Layer8
simulated time input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:625
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer0
TH1F * m_neuroHWInTSFoundT_Layer0
Found time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:342
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5CosTheta
TH1F * m_neuroHWOutQuad5CosTheta
cos theta distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:310
Belle2::CDCTriggerNeuroDQMModule::m_2DSWOutPhi0
TH1F * m_2DSWOutPhi0
Phi0 of 2dtracks (sw TS sw 2D)
Definition: CDCTriggerNeuroDQMModule.h:281
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer6
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer6
Priority time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:536
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroInputVector
StoreArray< CDCTriggerMLPInput > m_unpackedNeuroInputVector
StoreArray for neuro input vector from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:225
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer6
TH1F * m_neuroSWInputT_Layer6
simulated time input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:619
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroInputVectorSWTSSW2D
StoreArray< CDCTriggerMLPInput > m_simNeuroInputVectorSWTSSW2D
StoreArray for neuro input vector using simulated TS and simulated 2D.
Definition: CDCTriggerNeuroDQMModule.h:242
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWInvPt
TH1F * m_DeltaRecoSWInvPt
matched to SW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:709
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer0
TH1F * m_neuroHWSelTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:404
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer6
TH1F * m_neuroSWTSSW2DInTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:522
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer1
TH1F * m_neuroSWInputID_Layer1
simulated id input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:603
Belle2::CDCTriggerNeuroDQMModule::m_skipWithoutHWTS
bool m_skipWithoutHWTS
Switch to skip events without unpacked TS.
Definition: CDCTriggerNeuroDQMModule.h:198
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer0
TH1F * m_neuroSWTSSW2DInputT_Layer0
simulated time input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:630
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer7
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:556
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer3
TH1F * m_neuroHWInTSFoundT_Layer3
Found time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:345
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer6
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer6
Found time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:502
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer4
TH1F * m_neuroHWInputT_Layer4
unpacked time input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:584
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer5
TH1F * m_neuroHWInputAlpha_Layer5
unpacked alpha input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:588
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DPhi
TH1F * m_RecoSWTSSW2DPhi
matched to SWTSSW2DSWNN reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:716
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer0
TH1F * m_neuroHWInTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:362
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer5
TH1F * m_neuroSWTSSW2DSelTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:564
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWCosTheta
TH1F * m_DeltaRecoHWCosTheta
matched to HW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:685
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSID
TH1F * m_neuroSWTSSW2DInTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:485
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer1
TH1F * m_neuroHWInputID_Layer1
unpacked id input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:574
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DZ
TH1F * m_RecoSWTSSW2DZ
matched to SWTSSW2DSWNN reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:713
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer3
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:509
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroTracks
StoreArray< CDCTriggerTrack > m_simNeuroTracks
StoreArray for neuro tracks from TSIM.
Definition: CDCTriggerNeuroDQMModule.h:231
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer3
TH1F * m_neuroHWSelTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:407
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer8
TH1F * m_neuroHWSelTSFoundT_Layer8
Found time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:392
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer6
TH1F * m_neuroSWTSSW2DSelTSLR_Layer6
Left/Right of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:565
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutZ
TH1F * m_neuroRecoSWTSSW2DOutZ
reco matched z distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:721
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroInputVectorName
std::string m_simNeuroInputVectorName
Name for simulated neuro input vector using HW TS, HW 2D.
Definition: CDCTriggerNeuroDQMModule.h:192
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer4
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:510
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer2
TH1F * m_2DHWInTSPrioT_Layer2
Priority time of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:419
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutPhi0
TH1F * m_neuroHWOutPhi0
phi distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:252
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3Z
TH1F * m_neuroHWOutQuad3Z
z distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:325
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer5
TH1F * m_neuroHWInTSFoundT_Layer5
Found time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:347
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1Phi0
TH1F * m_neuroHWOutQuad1Phi0
phi distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:319
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSector
TH1F * m_neuroHWSector
sector of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:256
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer8
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer8
Priority time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:538
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTrackCount
TH1F * m_neuroHWInTrackCount
number of neuro input 2dtracks per event
Definition: CDCTriggerNeuroDQMModule.h:261
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer2
TH1F * m_neuroHWSelTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:396
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer4
TH1F * m_neuroHWInTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:366
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutHitPattern
TH1F * m_neuroSWOutHitPattern
stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:275
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer6
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:555
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer0
TH1F * m_2DHWInTSLR_Layer0
Left/Right of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:434
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWOutCosTheta
TH1F * m_neuroSWOutCosTheta
cos theta distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:272
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer2
TH1F * m_neuroSWInputT_Layer2
simulated time input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:607
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWSector
TH1F * m_neuroRecoHWSector
reco matched NN sector from unpacker
Definition: CDCTriggerNeuroDQMModule.h:681
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer0
TH1F * m_neuroSWTSSW2DInputID_Layer0
simulated id input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:629
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer2
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer2
Priority time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:489
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer8
TH1F * m_neuroHWInTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:370
Belle2::CDCTriggerNeuroDQMModule::m_unpackedSegmentHits
StoreArray< CDCTriggerSegmentHit > m_unpackedSegmentHits
StoreArray for TS hits from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:219
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer4
TH1F * m_neuroHWSelTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:398
Belle2::CDCTriggerNeuroDQMModule::beginRun
virtual void beginRun() override
Function to process begin_run record.
Definition: CDCTriggerNeuroDQMModule.cc:1318
Belle2::CDCTriggerNeuroDQMModule::m_histogramDirectoryName
std::string m_histogramDirectoryName
Name of the histogram directory in ROOT file.
Definition: CDCTriggerNeuroDQMModule.h:169
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer4
TH1F * m_neuroSWSelTSPrioB_Layer4
Priority bits of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:467
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0Z
TH1F * m_neuroHWOutQuad0Z
z distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:313
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer1
TH1F * m_neuroHWInputAlpha_Layer1
unpacked alpha input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:576
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer7
TH1F * m_neuroHWInTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:359
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer2
TH1F * m_neuroSWSelTSFoundT_Layer2
Found time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:455
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer2
TH1F * m_neuroSWSelTSPrioT_Layer2
Priority time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:446
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer6
TH1F * m_2DHWInTSLR_Layer6
Left/Right of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:437
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer1
TH1F * m_neuroHWSelTSPrioT_Layer1
Priority time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:376
Belle2::CDCTriggerNeuroDQMModule::m_sim2DTracksSWTS
StoreArray< CDCTriggerTrack > m_sim2DTracksSWTS
StoreArray for simulated 2D finder tracks using simulated TS.
Definition: CDCTriggerNeuroDQMModule.h:240
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer5
TH1F * m_neuroHWSelTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:409
Belle2::CDCTriggerNeuroDQMModule::m_recoTracksName
std::string m_recoTracksName
Name for the RecoTrack array name.
Definition: CDCTriggerNeuroDQMModule.h:214
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWPhi
TH1F * m_RecoHWPhi
matched to HW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:670
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad1CosTheta
TH1F * m_neuroHWOutQuad1CosTheta
cos theta distribution from unpacker (quadrant 1)
Definition: CDCTriggerNeuroDQMModule.h:318
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer2
TH1F * m_neuroSWInputID_Layer2
simulated id input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:606
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer5
TH1F * m_neuroHWSelTSFoundT_Layer5
Found time of selected track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:389
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutInvPt
TH1F * m_neuroHWOutInvPt
Inverse Pt distribution of unpacked neuro tracks.
Definition: CDCTriggerNeuroDQMModule.h:250
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer3
TH1F * m_neuroSWSelTSLR_Layer3
Left/Right of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:476
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer5
TH1F * m_neuroSWTSSW2DInTSLR_Layer5
Left/Right of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:521
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaInputAlpha
TH1F * m_neuroDeltaInputAlpha
unpacked alpha input - TSIM alpha input
Definition: CDCTriggerNeuroDQMModule.h:302
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer8
TH1F * m_neuroHWInTSPrioT_Layer8
Priority time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:341
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer7
TH1F * m_neuroSWSelTSPrioT_Layer7
Priority time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:451
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer3
TH1F * m_neuroSWInputT_Layer3
simulated time input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:610
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer6
TH1F * m_neuroSWSelTSFoundT_Layer6
Found time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:459
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer4
TH1F * m_neuroSWSelTSFoundT_Layer4
Found time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:457
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSCount
TH1F * m_neuroHWInTSCount
number of TS per track
Definition: CDCTriggerNeuroDQMModule.h:332
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWSector
TH1F * m_neuroRecoSWSector
reco matched NN sector from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:704
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaSector
TH1F * m_neuroDeltaSector
unpacked sector - TSIM sector
Definition: CDCTriggerNeuroDQMModule.h:304
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutm_time
TH1F * m_neuroHWOutm_time
m_time distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:254
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer8
TH1F * m_2DHWInTSLR_Layer8
Left/Right of 2D track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:438
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWCosTheta
TH1F * m_RecoHWCosTheta
matched to HW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:668
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroInputVectorSWTSSW2DName
std::string m_simNeuroInputVectorSWTSSW2DName
Name for neuro input vector using simulated TS and simulated 2D.
Definition: CDCTriggerNeuroDQMModule.h:211
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer1
TH1F * m_neuroSWSelTSFoundT_Layer1
Found time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:454
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer5
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:554
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DOutCosTheta
TH1F * m_neuroRecoSWTSSW2DOutCosTheta
reco matched cos theta distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:722
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer7
TH1F * m_neuroHWSelTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:411
Belle2::CDCTriggerNeuroDQMModule::m_maxRecoZDist
double m_maxRecoZDist
Select only RecoTracks with a maximum z distance to the IP.
Definition: CDCTriggerNeuroDQMModule.h:200
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer0
TH1F * m_neuroHWSelTSFoundT_Layer0
Found time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:384
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer3
TH1F * m_neuroSWSelTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:466
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer7
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer7
Found time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:546
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer5
TH1F * m_neuroSWTSSW2DInputT_Layer5
simulated time input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:645
Belle2::CDCTriggerNeuroDQMModule::m_nsamets
int m_nsamets
Number of identical track segments to be required for matching between HW and SW Neurotrigger.
Definition: CDCTriggerNeuroDQMModule.h:173
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWCosTheta
TH1F * m_DeltaRecoSWCosTheta
matched to SW reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:708
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroTracksName
std::string m_simNeuroTracksName
Name for neuro tracks from TSIM using HW TS, HW 2D.
Definition: CDCTriggerNeuroDQMModule.h:190
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer8
TH1F * m_neuroHWSelTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:402
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DD0
TH1F * m_RecoSWTSSW2DD0
matched to SWTSSW2DSWNN reconstructed d0
Definition: CDCTriggerNeuroDQMModule.h:717
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer5
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer5
Found time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:501
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer2
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer2
Found time of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:498
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer1
TH1F * m_neuroSWTSSW2DInputAlpha_Layer1
simulated alpha input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:634
Belle2::CDCTriggerNeuroDQMModule::getPattern
unsigned getPattern(CDCTriggerTrack *track, std::string hitCollectionName)
get pattern of the track
Definition: CDCTriggerNeuroDQMModule.h:72
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer0
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer0
Priority time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:530
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer7
TH1F * m_neuroSWTSSW2DInputT_Layer7
simulated time input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:651
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer5
TH1F * m_neuroSWInputID_Layer5
simulated id input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:615
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer6
TH1F * m_neuroHWInTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:358
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer0
TH1F * m_neuroSWSelTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:473
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer4
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer4
Priority time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:534
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer2
TH1F * m_neuroHWInputID_Layer2
unpacked id input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:577
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer0
TH1F * m_neuroHWInTSPrioT_Layer0
Priority time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:333
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutZ
TH1F * m_neuroRecoSWOutZ
reco matched z distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:698
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer4
TH1F * m_neuroSWInputAlpha_Layer4
simulated alpha input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:614
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer1
TH1F * m_neuroSWTSSW2DSelTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:560
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer5
TH1F * m_neuroHWInputID_Layer5
unpacked id input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:586
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer8
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer8
Priority bits of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:514
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSCount
TH1F * m_neuroSWSelTSCount
number of TS per SL
Definition: CDCTriggerNeuroDQMModule.h:443
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer7
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer7
Priority bits of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:513
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer5
TH1F * m_neuroSWInputAlpha_Layer5
simulated alpha input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:617
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroInputVectorName
std::string m_unpackedNeuroInputVectorName
Name for neuro input vector from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:182
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer3
TH1F * m_neuroHWSelTSPrioT_Layer3
Priority time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:378
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer6
TH1F * m_neuroHWSelTSPrioT_Layer6
Priority time of selected track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:381
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer2
TH1F * m_neuroSWTSSW2DInputT_Layer2
simulated time input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:636
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer8
TH1F * m_neuroSWTSSW2DInputID_Layer8
simulated id input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:653
Belle2::CDCTriggerNeuroDQMModule::m_sim2DTracksSWTSName
std::string m_sim2DTracksSWTSName
Name for simulated 2D finder tracks using simulated TS.
Definition: CDCTriggerNeuroDQMModule.h:207
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer5
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:511
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWZ
TH1F * m_RecoHWZ
matched to HW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:667
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer7
TH1F * m_neuroHWSelTSFoundT_Layer7
Found time of selected track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:391
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer1
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer1
Priority time of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:488
Belle2::CDCTriggerNeuroDQMModule::m_neuroScatterZ
TH2F * m_neuroScatterZ
unpacked z vs TSIM z, scatter plot
Definition: CDCTriggerNeuroDQMModule.h:297
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2Z
TH1F * m_neuroHWOutQuad2Z
z distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:321
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaInputID
TH1F * m_neuroDeltaInputID
unpacked ID input - TSIM ID input
Definition: CDCTriggerNeuroDQMModule.h:300
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer4
TH1F * m_neuroHWSelTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:408
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSFoundT_Layer4
TH1F * m_neuroHWInTSFoundT_Layer4
Found time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:346
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer3
TH1F * m_neuroHWInTSPrioT_Layer3
Priority time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:336
Belle2::CDCTriggerNeuroDQMModule::m_RecoHWInvPt
TH1F * m_RecoHWInvPt
matched to HW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:669
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer2
TH1F * m_neuroHWInTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:354
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer0
TH1F * m_neuroHWInputAlpha_Layer0
unpacked alpha input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:573
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutTrackCount
TH1F * m_neuroHWOutTrackCount
number of unpacked tracks per event
Definition: CDCTriggerNeuroDQMModule.h:255
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWZ
TH1F * m_DeltaRecoSWZ
matched to SW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:707
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer7
TH1F * m_neuroSWTSSW2DInputAlpha_Layer7
simulated alpha input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:652
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSLR_Layer2
TH1F * m_2DHWInTSLR_Layer2
Left/Right of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:435
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer4
TH1F * m_neuroSWSelTSLR_Layer4
Left/Right of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:477
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer0
TH1F * m_2DHWInTSPrioT_Layer0
Priority time of 2D track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:418
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWZ
TH1F * m_DeltaRecoHWZ
matched to HW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:684
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWTSSW2DSector
TH1F * m_neuroRecoSWTSSW2DSector
reco matched NN sector from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:728
Belle2::CDCTriggerNeuroDQMModule::isValidPattern
bool isValidPattern(unsigned pattern)
Validity of the pattern.
Definition: CDCTriggerNeuroDQMModule.h:82
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer0
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer0
Priority time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:487
Belle2::CDCTriggerNeuroDQMModule::m_eventTime
StoreObjPtr< BinnedEventT0 > m_eventTime
storeobjpointer for event time
Definition: CDCTriggerNeuroDQMModule.h:246
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutPhi0
TH1F * m_neuroRecoHWOutPhi0
reco matched phi distribution from unpacker
Definition: CDCTriggerNeuroDQMModule.h:678
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutPhi0
TH1F * m_neuroSWTSSW2DOutPhi0
phi distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:289
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroTracksSWTSSW2DName
std::string m_simNeuroTracksSWTSSW2DName
Name for neuro tracks using simulated TS and simulated 2D.
Definition: CDCTriggerNeuroDQMModule.h:209
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutCosTheta
TH1F * m_neuroHWOutCosTheta
cos theta distribution of unpacked neuro tracks
Definition: CDCTriggerNeuroDQMModule.h:249
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer4
TH1F * m_neuroHWSelTSPrioT_Layer4
Priority time of selected track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:379
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputID_Layer3
TH1F * m_neuroSWInputID_Layer3
simulated id input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:609
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer0
TH1F * m_neuroHWInputID_Layer0
unpacked id input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:571
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer1
TH1F * m_neuroHWSelTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:405
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutZ
TH1F * m_neuroSWTSSW2DOutZ
z distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:286
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer8
TH1F * m_neuroSWInputAlpha_Layer8
simulated alpha input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:626
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3CosTheta
TH1F * m_neuroHWOutQuad3CosTheta
cos theta distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:326
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad3InvPt
TH1F * m_neuroHWOutQuad3InvPt
Inverse Pt distribution from unpacker (quadrant 3)
Definition: CDCTriggerNeuroDQMModule.h:328
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer8
TH1F * m_neuroHWInputT_Layer8
unpacked time input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:596
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer1
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer1
Found time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:540
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer5
TH1F * m_neuroSWSelTSPrioB_Layer5
Priority bits of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:468
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer7
TH1F * m_neuroHWInTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:369
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DZ
TH1F * m_DeltaRecoSWTSSW2DZ
matched to SWTSSW2DSWNN reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:731
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer2
TH1F * m_2DHWInTSPrioB_Layer2
Priority bits of 2D track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:430
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer4
TH1F * m_neuroSWTSSW2DInputID_Layer4
simulated id input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:641
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer8
TH1F * m_neuroHWInputAlpha_Layer8
unpacked alpha input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:597
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer4
TH1F * m_neuroSWInputT_Layer4
simulated time input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:613
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioT_Layer5
TH1F * m_neuroSWSelTSPrioT_Layer5
Priority time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:449
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DOutCosTheta
TH1F * m_neuroSWTSSW2DOutCosTheta
cos theta distribution from simulation (sw TS sw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:287
Belle2::CDCTriggerNeuroDQMModule::m_unpacked2DTracks
StoreArray< CDCTriggerTrack > m_unpacked2DTracks
StoreArray for 2D finder tracks from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:221
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer7
TH1F * m_neuroHWInputT_Layer7
unpacked time input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:593
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer6
TH1F * m_2DHWInTSPrioT_Layer6
Priority time of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:421
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer7
TH1F * m_neuroSWInputAlpha_Layer7
simulated alpha input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:623
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSFoundT_Layer0
TH1F * m_neuroSWTSSW2DSelTSFoundT_Layer0
Found time of selected track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:539
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer4
TH1F * m_neuroSWTSSW2DInputAlpha_Layer4
simulated alpha input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:643
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutVsInTrackCount
TH1F * m_neuroHWOutVsInTrackCount
neuroHWOutTracks - neuroHWInTrackCount
Definition: CDCTriggerNeuroDQMModule.h:262
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWTSSW2DCosTheta
TH1F * m_RecoSWTSSW2DCosTheta
matched to SWTSSW2DSWNN reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:714
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer7
TH1F * m_neuroSWTSSW2DInputID_Layer7
simulated id input in layer 7
Definition: CDCTriggerNeuroDQMModule.h:650
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer3
TH1F * m_neuroHWInTSPrioB_Layer3
Priority bits of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:355
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputT_Layer1
TH1F * m_neuroSWInputT_Layer1
simulated time input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:604
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioB_Layer6
TH1F * m_2DHWInTSPrioB_Layer6
Priority bits of 2D track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:432
Belle2::CDCTriggerNeuroDQMModule::m_unpackedNeuroTracksName
std::string m_unpackedNeuroTracksName
Name for neuro tracks from unpacker.
Definition: CDCTriggerNeuroDQMModule.h:180
Belle2::CDCTriggerNeuroDQMModule::m_RecoCosTheta
TH1F * m_RecoCosTheta
reconstructed cos(theta)
Definition: CDCTriggerNeuroDQMModule.h:660
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer2
TH1F * m_neuroHWSelTSLR_Layer2
Left/Right of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:406
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer8
TH1F * m_neuroSWSelTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:481
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5Z
TH1F * m_neuroHWOutQuad5Z
z distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:309
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer4
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer4
Priority time of track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:491
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer8
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer8
Priority time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:495
Belle2::CDCTriggerNeuroDQMModule::m_RecoTracks
StoreArray< RecoTrack > m_RecoTracks
StoreArray for RecoTracks.
Definition: CDCTriggerNeuroDQMModule.h:235
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5Phi0
TH1F * m_neuroHWOutQuad5Phi0
phi distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:311
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSLR_Layer1
TH1F * m_neuroSWSelTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:474
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWZ
TH1F * m_RecoSWZ
matched to SW reconstructed z
Definition: CDCTriggerNeuroDQMModule.h:690
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer2
TH1F * m_neuroHWSelTSFoundT_Layer2
Found time of selected track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:386
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer6
TH1F * m_neuroSWSelTSPrioB_Layer6
Priority bits of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:469
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer8
TH1F * m_neuroSWSelTSFoundT_Layer8
Found time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:461
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer1
TH1F * m_neuroHWSelTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:395
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWInputAlpha_Layer2
TH1F * m_neuroSWInputAlpha_Layer2
simulated alpha input in layer 2
Definition: CDCTriggerNeuroDQMModule.h:608
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer8
TH1F * m_neuroSWTSSW2DInputT_Layer8
simulated time input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:654
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSPrioB_Layer2
TH1F * m_neuroSWSelTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:465
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer5
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer5
Priority time of track segments in layer 5.
Definition: CDCTriggerNeuroDQMModule.h:492
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer0
TH1F * m_neuroSWTSSW2DSelTSLR_Layer0
Left/Right of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:559
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer7
TH1F * m_neuroSWTSSW2DInTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:523
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutHitPattern
TH1F * m_neuroHWOutHitPattern
stereo hit pattern of simulated neuro tracks (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:253
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad0InvPt
TH1F * m_neuroHWOutQuad0InvPt
Inverse Pt distribution from unpacker (quadrant 0)
Definition: CDCTriggerNeuroDQMModule.h:316
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWTSSW2DPhi
TH1F * m_DeltaRecoSWTSSW2DPhi
matched to SWTSSW2DSWNN reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:734
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer1
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer1
Priority bits of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:550
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoHWPhi
TH1F * m_DeltaRecoHWPhi
matched to HW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:687
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer7
TH1F * m_neuroHWInTSPrioT_Layer7
Priority time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:340
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2CosTheta
TH1F * m_neuroHWOutQuad2CosTheta
cos theta distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:322
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSCount
TH1F * m_neuroSWTSSW2DSelTSCount
number of TS per SL
Definition: CDCTriggerNeuroDQMModule.h:529
Belle2::CDCTriggerNeuroDQMModule::m_DeltaRecoSWPhi
TH1F * m_DeltaRecoSWPhi
matched to SW reconstructed phi
Definition: CDCTriggerNeuroDQMModule.h:710
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioB_Layer2
TH1F * m_neuroSWTSSW2DSelTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:551
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioB_Layer2
TH1F * m_neuroSWTSSW2DInTSPrioB_Layer2
Priority bits of track segments in layer 2.
Definition: CDCTriggerNeuroDQMModule.h:508
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSLR_Layer7
TH1F * m_neuroSWTSSW2DSelTSLR_Layer7
Left/Right of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:566
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoHWOutTrackCount
TH1F * m_neuroRecoHWOutTrackCount
reco matched number of unpacked and matched tracks per event
Definition: CDCTriggerNeuroDQMModule.h:680
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioT_Layer8
TH1F * m_neuroHWSelTSPrioT_Layer8
Priority time of selected track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:383
Belle2::CDCTriggerNeuroDQMModule::m_neuroDeltaTSID
TH1F * m_neuroDeltaTSID
unpacked selected TSID - TSIM selected TSID
Definition: CDCTriggerNeuroDQMModule.h:303
Belle2::CDCTriggerNeuroDQMModule::m_simNeuroTracksSWTSSW2D
StoreArray< CDCTriggerTrack > m_simNeuroTracksSWTSSW2D
StoreArray for neuro tracks using simulated TS and simulated 2D.
Definition: CDCTriggerNeuroDQMModule.h:244
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer8
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer8
Found time of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:504
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSLR_Layer1
TH1F * m_neuroHWInTSLR_Layer1
Left/Right of track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:363
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputAlpha_Layer6
TH1F * m_neuroHWInputAlpha_Layer6
unpacked alpha input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:591
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad5InvPt
TH1F * m_neuroHWOutQuad5InvPt
Inverse Pt distribution from unpacker (no quadrant set)
Definition: CDCTriggerNeuroDQMModule.h:312
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer3
TH1F * m_neuroHWInputT_Layer3
unpacked time input in layer 3
Definition: CDCTriggerNeuroDQMModule.h:581
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutPhi0
TH1F * m_neuroRecoSWOutPhi0
reco matched phi distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:701
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer5
TH1F * m_neuroHWInputT_Layer5
unpacked time input in layer 5
Definition: CDCTriggerNeuroDQMModule.h:587
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSPrioB_Layer0
TH1F * m_neuroHWSelTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:394
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer0
TH1F * m_neuroSWTSSW2DInputAlpha_Layer0
simulated alpha input in layer 0
Definition: CDCTriggerNeuroDQMModule.h:631
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputID_Layer8
TH1F * m_neuroHWInputID_Layer8
unpacked id input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:595
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputAlpha_Layer8
TH1F * m_neuroSWTSSW2DInputAlpha_Layer8
simulated alpha input in layer 8
Definition: CDCTriggerNeuroDQMModule.h:655
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioB_Layer0
TH1F * m_neuroHWInTSPrioB_Layer0
Priority bits of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:352
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInputT_Layer6
TH1F * m_neuroHWInputT_Layer6
unpacked time input in layer 6
Definition: CDCTriggerNeuroDQMModule.h:590
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSPrioT_Layer6
TH1F * m_neuroHWInTSPrioT_Layer6
Priority time of track segments in layer 6.
Definition: CDCTriggerNeuroDQMModule.h:339
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSLR_Layer8
TH1F * m_neuroSWTSSW2DInTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:524
Belle2::CDCTriggerNeuroDQMModule::m_neuroRecoSWOutCosTheta
TH1F * m_neuroRecoSWOutCosTheta
reco matched cos theta distribution from simulation (hw TS hw 2D sw NN)
Definition: CDCTriggerNeuroDQMModule.h:699
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSLR_Layer8
TH1F * m_neuroHWSelTSLR_Layer8
Left/Right of track segments in layer 8.
Definition: CDCTriggerNeuroDQMModule.h:412
Belle2::CDCTriggerNeuroDQMModule::m_2DHWInTSPrioT_Layer4
TH1F * m_2DHWInTSPrioT_Layer4
Priority time of 2D track segments in layer 4.
Definition: CDCTriggerNeuroDQMModule.h:420
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSPrioT_Layer3
TH1F * m_neuroSWTSSW2DInTSPrioT_Layer3
Priority time of track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:490
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWSelTSFoundT_Layer7
TH1F * m_neuroSWSelTSFoundT_Layer7
Found time of track segments in layer 7.
Definition: CDCTriggerNeuroDQMModule.h:460
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputT_Layer4
TH1F * m_neuroSWTSSW2DInputT_Layer4
simulated time input in layer 4
Definition: CDCTriggerNeuroDQMModule.h:642
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSFoundT_Layer3
TH1F * m_neuroHWSelTSFoundT_Layer3
Found time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:387
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWOutQuad2Phi0
TH1F * m_neuroHWOutQuad2Phi0
phi distribution from unpacker (quadrant 2)
Definition: CDCTriggerNeuroDQMModule.h:323
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInTSFoundT_Layer0
TH1F * m_neuroSWTSSW2DInTSFoundT_Layer0
Found time of track segments in layer 0.
Definition: CDCTriggerNeuroDQMModule.h:496
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWInTSID
TH1F * m_neuroHWInTSID
ID of incoming track segments.
Definition: CDCTriggerNeuroDQMModule.h:331
Belle2::CDCTriggerNeuroDQMModule::defineHisto
virtual void defineHisto() override
Histogram definitions such as TH1(), TH2(), TNtuple(), TTree()....
Definition: CDCTriggerNeuroDQMModule.cc:96
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer1
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer1
Priority time of selected track segments in layer 1.
Definition: CDCTriggerNeuroDQMModule.h:531
Belle2::CDCTriggerNeuroDQMModule::m_neuroHWSelTSID
TH1F * m_neuroHWSelTSID
ID of selected track segments.
Definition: CDCTriggerNeuroDQMModule.h:373
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DInputID_Layer1
TH1F * m_neuroSWTSSW2DInputID_Layer1
simulated id input in layer 1
Definition: CDCTriggerNeuroDQMModule.h:632
Belle2::CDCTriggerNeuroDQMModule::m_neuroSWTSSW2DSelTSPrioT_Layer3
TH1F * m_neuroSWTSSW2DSelTSPrioT_Layer3
Priority time of selected track segments in layer 3.
Definition: CDCTriggerNeuroDQMModule.h:533
Belle2::CDCTriggerNeuroDQMModule::m_RecoSWInvPt
TH1F * m_RecoSWInvPt
matched to SW reconstructed inverse Pt
Definition: CDCTriggerNeuroDQMModule.h:692
Belle2::CDCTriggerSegmentHit
Combination of several CDCHits to a track segment hit for the trigger.
Definition: CDCTriggerSegmentHit.h:23
Belle2::CDCTriggerSegmentHit::foundTime
short foundTime() const
get time when segment hit was found in trigger clocks
Definition: CDCTriggerSegmentHit.h:87
Belle2::CDCTriggerTrack
Track created by the CDC trigger.
Definition: CDCTriggerTrack.h:21
Belle2::CDCTriggerTrack::getValidStereoBit
bool getValidStereoBit() const
returns true, if at least 3 stereo ts were found
Definition: CDCTriggerTrack.h:132
Belle2::CDCTriggerTrack::setQualityVector
void setQualityVector(const unsigned newbits)
setter and getter for the quality vector.
Definition: CDCTriggerTrack.h:147
Belle2::CDCTriggerTrack::getPt
double getPt() const
get the absolute value of the transverse momentum at the perigee assuming d0 = 0
Definition: CDCTriggerTrack.h:118
Belle2::HistoModule
HistoModule.h is supposed to be used instead of Module.h for the modules with histogram definitions t...
Definition: HistoModule.h:29
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:214
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:208
Belle2::Module::c_ParallelProcessingCertified
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition: Module.h:80
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:79
Belle2::StoreAccessorBase::isRequired
bool isRequired(const std::string &name="")
Ensure this array/object has been registered previously.
Definition: StoreAccessorBase.h:78
Belle2::StoreArray::requireRelationTo
bool requireRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, const std::string &namedRelation="") const
Produce error if no relation from this array to 'toArray' has been registered.
Definition: StoreArray.h:155
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:216
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: StoreObjPtr.h:96
Belle2::StoreObjPtr::isValid
bool isValid() const
Check whether the object was created.
Definition: StoreObjPtr.h:111
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:560
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:650
Belle2::sqrt
double sqrt(double a)
sqrt for double
Definition: beamHelpers.h:28
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.