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