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