Belle II Software  release-05-01-25
TRGTOPDQMModule.cc
1 //---------------------------------------------------------------
2 // $Id$
3 //---------------------------------------------------------------
4 // Filename : TRGTOPDQMModule.cc
5 // Section : TRG TOP
6 // Owner :
7 // Email :
8 //---------------------------------------------------------------
9 // Description : DQM module for TRGTOP
10 //---------------------------------------------------------------
11 // 1.00 : 2020/09/20 : First version
12 //
13 // Modeled after / heavily borrowing from GDL, GRL and ECL DQM modules
14 //---------------------------------------------------------------
15 #include <trg/top/modules/trgtopDQM/TRGTOPDQMModule.h>
16 #include <mdst/dataobjects/SoftwareTriggerResult.h>
17 
18 #include <framework/datastore/StoreObjPtr.h>
19 #include <framework/datastore/StoreArray.h>
20 
21 #include "trg/top/dataobjects/TRGTOPUnpackerStore.h"
22 
23 #include <TDirectory.h>
24 #include <TPostScript.h>
25 #include <TCanvas.h>
26 #include <TStyle.h>
27 #include <fstream>
28 #include <framework/logging/Logger.h>
29 #include <boost/algorithm/string.hpp>
30 
31 #include <iostream>
32 
33 using namespace std;
34 using namespace Belle2;
35 
36 REG_MODULE(TRGTOPDQM);
37 
38 TRGTOPDQMModule::TRGTOPDQMModule() : HistoModule()
39 {
40 
41  setDescription("DQM for TOP Trigger subsystem");
42  setPropertyFlags(c_ParallelProcessingCertified);
43 
44  addParam("doECLCorrelations", m_doECLCorrelations,
45  "Do ECL-TOP correlations (true)",
46  true);
47 
48  addParam("requireECLBarrel", m_requireEclBarrel,
49  "Require the most energetic ECL TC in the barrel if doing correlations with ECL (false)",
50  true);
51 
52  addParam("requireECLBarrelB2B", m_requireEclBarrelB2B,
53  "Require ECL barrel back-to-back if doing correlations with ECL (false)",
54  false);
55 
56  addParam("doGDLCorrelations", m_doGDLCorrelations,
57  "Do GDL-TOP correlations (true)",
58  true);
59 
60  addParam("doGRLCorrelations", m_doGRLCorrelations,
61  "Do GRL-TOP correlations (true)",
62  true);
63 
64  addParam("requireCDC2DTrack", m_requireCDC2DTrack,
65  "Require at least one CDC 2D track at TRG level",
66  false);
67 
68  addParam("generatePostscriptFile", m_generatePostscriptFile,
69  "Generate postscript file (false)",
70  false);
71 
72  addParam("postScriptFileName", m_postScriptFileName,
73  "postscript file name",
74  string("topl1dqm.ps"));
75 
76  addParam("skim", m_skim,
77  "use skim information (-1)",
78  int(-1));
79 
80  addParam("nHistClasses", m_nHistClassesActual,
81  "The number of histogram classes: 1, 2, 3 (1); use 2 and 3 for detailed studies only",
82  int(1));
83 
84  addParam("m_histLevel", m_histLevel,
85  "Histogramming level: 1, 2, 3 (1); 3 most detailed",
86  int(1));
87 
88 }
89 
90 void TRGTOPDQMModule::defineHisto()
91 {
92  oldDir = gDirectory;
93  dirDQM = gDirectory;
94  oldDir->mkdir("TRGTOP");
95  dirDQM->cd("TRGTOP");
96 
97  if (m_nHistClassesActual > nHistClasses) m_nHistClassesActual = nHistClasses;
98  if (m_nHistClassesActual < 1) m_nHistClassesActual = 1;
99 
100  //-------------------------------------------------------------------------------------------------------------------------------------------
101 
102  for (int iskim = start_skim_topdqm; iskim < end_skim_topdqm; iskim++) {
103 
104  //
105  // combined decisions information
106  //
107 
108  h_topCombinedTimingTopAll[iskim] = new TH1I(Form("h_t0_comb_%s", skim_smap[iskim].c_str()), "ALL TOP combined t0 decisions", 100,
109  0,
110  100000);
111  h_topCombinedTimingTopAll[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decision time (us)");
112 
113  h_topNSlotsCombinedTimingTopAll[iskim] = new TH1I(Form("h_n_slots_comb_%s", skim_smap[iskim].c_str()),
114  "ALL TOP combined t0 decisions: N slots", 17, 0, 17);
115  h_topNSlotsCombinedTimingTopAll[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N slots");
116 
117  h_topNHitSumAll[iskim] = new TH1I(Form("h_nhit_per_slot_comb_%s", skim_smap[iskim].c_str()),
118  "ALL TOP combined t0 decisions: N hits per slot", 200, 0, 200);
119  h_topNHitSumAll[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N hits per slot");
120 
121  h_topLogLSumAll[iskim] = new TH1I(Form("h_logl_per_slot_comb_%s", skim_smap[iskim].c_str()),
122  "ALL TOP combined t0 decisions: log L per slot", 100, 0, 60000);
123  h_topLogLSumAll[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: log L per slot");
124 
125  h_topNSlotsCombinedTimingVsNHitsTopAll[iskim] = new TH2I(Form("h_n_slots_vs_nhit_total_comb_%s", skim_smap[iskim].c_str()),
126  "ALL TOP combined t0 decisions: N slots vs N hits (total)", 300, 0, 300, 17, 0, 17);
127  h_topNSlotsCombinedTimingVsNHitsTopAll[iskim]->GetXaxis()->SetTitle("N hits (total)");
128  h_topNSlotsCombinedTimingVsNHitsTopAll[iskim]->GetYaxis()->SetTitle("N slots");
129 
130  h_topTrigType[iskim] = new TH1I(Form("h_trig_type_%s", skim_smap[iskim].c_str()),
131  "ALL TOP combined decisions: trig type", 10, 0, 10);
132  h_topTrigType[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: trig type");
133 
134  h_topTimingResiduals[iskim] = new TH1I(Form("h_timing_residuals_%s", skim_smap[iskim].c_str()),
135  "ALL TOP combined decisions: timing residual", 100, 0, 100);
136  h_topTimingResiduals[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: timing residuals");
137 
138  h_topTimingVariance[iskim] = new TH1I(Form("h_timing_variance_%s", skim_smap[iskim].c_str()),
139  "ALL TOP combined decisions: timing variance", 100, 0, 100);
140  h_topTimingVariance[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: timing variance");
141 
142  //-------------------------------------------------------------------------------------------------------------------------------------------
143  //
144  // slot-level information for combined decisions
145  //
146 
147  h_topSlotAll[iskim] = new TH1I(Form("h_slot_number_%s", skim_smap[iskim].c_str()), "slot", 16, 1, 17);
148  h_topSlotAll[iskim]->GetXaxis()->SetTitle("slot number in combined decisions (over 1us)");
149 
150  h_topSegmentAll[iskim] = new TH1I(Form("h_segment_slot_%s", skim_smap[iskim].c_str()), "segment", 10, 1, 11);
151  h_topSegmentAll[iskim]->GetXaxis()->SetTitle("segment for each slot in combined decisions (over 1us)");
152 
153  h_topNHitsAll[iskim] = new TH1I(Form("h_nhit_slot_%s", skim_smap[iskim].c_str()), "nhit", 200, 0, 200);
154  h_topNHitsAll[iskim]->GetXaxis()->SetTitle("N hits (for slots in combined decisions (over 1us))");
155 
156  h_topLogLAll[iskim] = new TH1I(Form("h_logl_slot_%s", skim_smap[iskim].c_str()), "log L", 100, 0, 60000);
157  h_topLogLAll[iskim]->GetXaxis()->SetTitle("log L (for slots in combined decisions (over 1us))");
158 
159  h_topT0All[iskim] = new TH1I(Form("h_t0_slot_%s", skim_smap[iskim].c_str()), "t0", 100, 0, 100000);
160  h_topT0All[iskim]->GetXaxis()->SetTitle("t0 for slots in combined decisions (over 1us)");
161 
162  //-------------------------------------------------------------------------------------------------------------------------------------------
163  //
164  // correlations in slot-level information for combined decisions
165  //
166 
167  h_topSlotVsSegment[iskim] = new TH2I(Form("h_slot_vs_segment_%s", skim_smap[iskim].c_str()), "slot # vs slot segment", 10, 1, 11,
168  16, 1, 17);
169  h_topSlotVsSegment[iskim]->GetXaxis()->SetTitle("segment");
170  h_topSlotVsSegment[iskim]->GetYaxis()->SetTitle("slot");
171 
172  h_topSlotVsNHits[iskim] = new TH2I(Form("h_slot_vs_nhit_%s", skim_smap[iskim].c_str()), "slot # vs slot nhit", 200, 0, 200, 16, 1,
173  17);
174  h_topSlotVsNHits[iskim]->GetXaxis()->SetTitle("N hits");
175  h_topSlotVsNHits[iskim]->GetYaxis()->SetTitle("slot");
176 
177  h_topSlotVsLogL[iskim] = new TH2I(Form("h_slot_vs_logl_%s", skim_smap[iskim].c_str()), "slot # vs slot log L", 100, 0, 60000, 16,
178  1, 17);
179  h_topSlotVsLogL[iskim]->GetXaxis()->SetTitle("logL");
180  h_topSlotVsLogL[iskim]->GetYaxis()->SetTitle("slot");
181 
182  h_topSlotVsT0[iskim] = new TH2I(Form("h_slot_vs_t0_%s", skim_smap[iskim].c_str()), "slot # vs slot t0", 100, 0, 100000, 16, 1, 17);
183  h_topSlotVsT0[iskim]->GetXaxis()->SetTitle("t0");
184  h_topSlotVsT0[iskim]->GetYaxis()->SetTitle("slot");
185 
186  h_topSegmentVsNHits[iskim] = new TH2I(Form("h_segment_vs_nhit_%s", skim_smap[iskim].c_str()), "slot segment vs slot nhit", 200, 0,
187  200, 10, 1, 11);
188  h_topSegmentVsNHits[iskim]->GetXaxis()->SetTitle("N hits");
189  h_topSegmentVsNHits[iskim]->GetYaxis()->SetTitle("segment");
190 
191  h_topSegmentVsLogL[iskim] = new TH2I(Form("h_segment_vs_logl_%s", skim_smap[iskim].c_str()), "slot segment vs slot log L", 100, 0,
192  60000, 10, 1, 11);
193  h_topSegmentVsLogL[iskim]->GetXaxis()->SetTitle("logL");
194  h_topSegmentVsLogL[iskim]->GetYaxis()->SetTitle("segment");
195 
196  h_topSegmentVsT0[iskim] = new TH2I(Form("h_segment_vs_t0_%s", skim_smap[iskim].c_str()), "slot segment vs slot t0", 100, 0, 100000,
197  10, 1, 11);
198  h_topSegmentVsT0[iskim]->GetXaxis()->SetTitle("t0");
199  h_topSegmentVsT0[iskim]->GetYaxis()->SetTitle("segment");
200 
201  h_topNHitsVsLogL[iskim] = new TH2I(Form("h_nhit_vs_logl_%s", skim_smap[iskim].c_str()), "slot nhit vs slot log L", 100, 0, 100000,
202  200, 0, 200);
203  h_topNHitsVsLogL[iskim]->GetXaxis()->SetTitle("logL");
204  h_topNHitsVsLogL[iskim]->GetYaxis()->SetTitle("N hits");
205 
206  h_topNHitsVsT0[iskim] = new TH2I(Form("h_nhit_vs_t0_%s", skim_smap[iskim].c_str()), "slot nhit vs slot t0", 100, 0, 100000, 200, 0,
207  200);
208  h_topNHitsVsT0[iskim]->GetXaxis()->SetTitle("t0");
209  h_topNHitsVsT0[iskim]->GetYaxis()->SetTitle("N hits");
210 
211  h_topLogLVsT0[iskim] = new TH2I(Form("h_logl_vs_t0_%s", skim_smap[iskim].c_str()), "slot log L vs slot t0", 100, 0, 100000, 100, 0,
212  60000);
213  h_topLogLVsT0[iskim]->GetXaxis()->SetTitle("t0");
214  h_topLogLVsT0[iskim]->GetYaxis()->SetTitle("logL");
215 
216  //-------------------------------------------------------------------------------------------------------------------------------------------
217  //
218  // more slot-level information (per slot) for combined decisions
219  //
220 
221  for (int slot = 0; slot <= 15; slot++) {
222 
223  h_topSlotSegment[iskim][slot] = new TH1I(Form("h_segment_slot_%s_%s", (to_string(slot + 1)).c_str(), skim_smap[iskim].c_str()),
224  "segment", 10, 1, 11);
225  h_topSlotSegment[iskim][slot]->GetXaxis()->SetTitle("segment");
226 
227  h_topSlotNHits[iskim][slot] = new TH1I(Form("h_nhit_slot_%s_%s", (to_string(slot + 1)).c_str(), skim_smap[iskim].c_str()), "nhit",
228  200, 0, 200);
229  h_topSlotNHits[iskim][slot]->GetXaxis()->SetTitle("N hits");
230 
231  h_topSlotLogL[iskim][slot] = new TH1I(Form("h_logl_slot_%s_%s", (to_string(slot + 1)).c_str(), skim_smap[iskim].c_str()), "log L",
232  100, 0, 60000);
233  h_topSlotLogL[iskim][slot]->GetXaxis()->SetTitle("log L");
234 
235  h_topSlotT0[iskim][slot] = new TH1I(Form("h_t0_slot_%s_%s", (to_string(slot + 1)).c_str(), skim_smap[iskim].c_str()), "t0", 100, 0,
236  100000);
237  h_topSlotT0[iskim][slot]->GetXaxis()->SetTitle("t0");
238 
239  }
240 
241  //-------------------------------------------------------------------------------------------------------------------------------------------
242  //
243  // GDL-TOP comparisons for slots in combined decisions
244  //
245 
246  h_gdl_ecltop_timing_diff_vs_slot[iskim] = new TH2I(Form("h_gdl_slot_vs_ecltop_timing_diff_%s", skim_smap[iskim].c_str()),
247  "slot vs GDL ECL-TOP slot t0 difference", 400, 1400,
248  2200, 16, 1, 17);
249  h_gdl_ecltop_timing_diff_vs_slot[iskim]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
250  h_gdl_ecltop_timing_diff_vs_slot[iskim]->GetYaxis()->SetTitle("slot");
251 
252  h_gdl_ecltop_timing_diff_vs_segment[iskim] = new TH2I(Form("h_gdl_segment_vs_ecltop_timing_diff_%s", skim_smap[iskim].c_str()),
253  "segment vs GDL ECL-TOP slot t0 difference",
254  400, 1400, 2200, 10, 1, 11);
255  h_gdl_ecltop_timing_diff_vs_segment[iskim]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
256  h_gdl_ecltop_timing_diff_vs_segment[iskim]->GetYaxis()->SetTitle("segment");
257 
258  h_gdl_ecltop_timing_diff_vs_nhits[iskim] = new TH2I(Form("h_gdl_nhits_vs_ecltop_timing_diff_%s", skim_smap[iskim].c_str()),
259  "N hits (for slots) vs GDL ECL-TOP slot t0 difference", 400, 1400, 2200, 200, 0, 200);
260  h_gdl_ecltop_timing_diff_vs_nhits[iskim]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
261  h_gdl_ecltop_timing_diff_vs_nhits[iskim]->GetYaxis()->SetTitle("N hits");
262 
263  h_gdl_ecltop_timing_diff_vs_logl[iskim] = new TH2I(Form("h_gdl_logl_vs_ecltop_timing_diff_%s", skim_smap[iskim].c_str()),
264  "log L (for slots) vs GDL ECL-TOP slot t0 difference", 400, 1400, 2200, 100, 0, 60000);
265  h_gdl_ecltop_timing_diff_vs_logl[iskim]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
266  h_gdl_ecltop_timing_diff_vs_logl[iskim]->GetYaxis()->SetTitle("log L");
267 
268  //-------------------------------------------------------------------------------------------------------------------------------------------
269 
270  h_ecl_gdl_top_timing_diff_both[iskim] = new TH1I(Form("h_ecl_gdl_top_timing_diff_both_%s", skim_smap[iskim].c_str()), "", 400,
271  1400, 2200);
272  h_ecl_gdl_top_timing_diff_both[iskim]->GetXaxis()->SetTitle("Both ECL - GDL_TOP timing difference (2ns)");
273 
274  h_ecl_top_top_timing_diff_both[iskim] = new TH1I(Form("h_ecl_top_top_timing_diff_both_%s", skim_smap[iskim].c_str()), "", 400,
275  1400, 2200);
276  h_ecl_top_top_timing_diff_both[iskim]->GetXaxis()->SetTitle("Both ECL - TOP_TOP timing difference (2ns)");
277 
278  //-------------------------------------------------------------------------------------------------------------------------------------------
279 
280  if (m_histLevel > 2) {
281 
282  //
283  // various rvc-related distributions for GDL/TOP
284  //
285 
286  h_gdl_top_rvc_vs_top_timing[iskim] = new TH2I(Form("h_gdl_top_rvc_vs_top_timing_%s", skim_smap[iskim].c_str()),
287  "ALL GDL TOP rvc vs GDL TOP timing (7.8ns)",
288  128, 0, 1280, 128, 0, 1280);
289  h_gdl_top_rvc_vs_top_timing[iskim]->GetXaxis()->SetTitle("TOP timing according to GDL (7.8ns)");
290  h_gdl_top_rvc_vs_top_timing[iskim]->GetYaxis()->SetTitle("GDL rvc((TOP decision (received))");
291 
292  h_gdl_ecltop_rvc_diff[iskim] = new TH1I(Form("h_gdl_ecltop_rvc_diff_%s", skim_smap[iskim].c_str()),
293  "ALL GDL ECL-TOP rvc difference",
294  10, 0, 10);
295  h_gdl_ecltop_rvc_diff[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP rvc difference (clks)");
296 
297  h_gdl_cdctop_rvc_diff[iskim] = new TH1I(Form("h_gdl_cdctop_rvc_diff_%s", skim_smap[iskim].c_str()),
298  "ALL GDL CDC-TOP rvc difference",
299  10, 0, 10);
300  h_gdl_cdctop_rvc_diff[iskim]->GetXaxis()->SetTitle("TOPTRG GDL CDC-TOP rvc difference (clks)");
301 
302  //-------------------------------------------------------------------------------------------------------------------------------------------
303 
304  h_gdl_gdltop_rvc_diff_all[iskim] = new TH1I(Form("h_gdl_gdltop_rvc_diff_%s", skim_smap[iskim].c_str()),
305  "ALL GDL GDL-TOP rvc difference",
306  10, 1270, 1280);
307  h_gdl_gdltop_rvc_diff_all[iskim]->GetXaxis()->SetTitle("TOPTRG GDL GDL-TOP rvc difference (clks)");
308 
309  h_gdl_comtop_rvc_diff_all[iskim] = new TH1I(Form("h_gdl_comtop_rvc_diff_%s", skim_smap[iskim].c_str()),
310  "ALL GDL COM-TOP rvc difference",
311  30, 20, 50);
312  h_gdl_comtop_rvc_diff_all[iskim]->GetXaxis()->SetTitle("TOPTRG GDL COM-TOP rvc difference (clks)");
313 
314  //-------------------------------------------------------------------------------------------------------------------------------------------
315 
316  h_topRvcDiff1All[iskim] = new TH1I(Form("h_top_rvc_diff_1_%s", skim_smap[iskim].c_str()), "ALL rvc(posted to GDL)-rvc(TOP(this))",
317  250, -100, 150);
318  h_topRvcDiff1All[iskim]->GetXaxis()->SetTitle("rvc(posted to GDL)-rvc(TOP(this))");
319 
320  h_topRvcDiff2All[iskim] = new TH1I(Form("h_top_rvc_diff_2_%s", skim_smap[iskim].c_str()), "ALL rvc(TOP(this))-rvc(TOP(prev))",
321  128, 0, 1280);
322  h_topRvcDiff2All[iskim]->GetXaxis()->SetTitle("rvc(TOP(this))-rvc(TOP(prev))");
323 
324  h_topRvcDiff3All[iskim] = new TH1I(Form("h_top_rvc_diff_3_%s", skim_smap[iskim].c_str()), "ALL rvc(CB(window))-rvc(TOP(this))",
325  150, 0, 150);
326  h_topRvcDiff3All[iskim]->GetXaxis()->SetTitle("rvc(CB(window))-rvc(TOP(this))");
327 
328  h_topRvcDiff4All[iskim] = new TH1I(Form("h_top_rvc_diff_4_%s", skim_smap[iskim].c_str()),
329  "ALL rvc(received L1 from GDL)-rvc(TOP(this))",
330  250, 0, 250);
331  h_topRvcDiff4All[iskim]->GetXaxis()->SetTitle("rvc(L1)-rvc(TOP(this))");
332 
333  //-------------------------------------------------------------------------------------------------------------------------------------------
334 
335  h_topGdlRvcDiff1All[iskim] = new TH1I(Form("h_gdl_top_l1_rvc_diff_%s", skim_smap[iskim].c_str()),
336  "ALL rvc(L1(GDL))-rvc(L1(as reported to TOP))",
337  10, 1235, 1245);
338  h_topGdlRvcDiff1All[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(L1(as reported to TOP))");
339 
340  h_topGdlRvcDiff2All[iskim] = new TH1I(Form("h_gdl_l1_top_t0_this_rvc_diff_%s", skim_smap[iskim].c_str()),
341  "ALL rvc(TOP(received by GDL))-rvc(TOP(this))",
342  50, 0, 200);
343  h_topGdlRvcDiff2All[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(TOP(this))");
344 
345  h_topGdlRvcDiff3All[iskim] = new TH1I(Form("h_gdl_l1_top_t0_prev_rvc_diff_%s", skim_smap[iskim].c_str()),
346  "ALL rvc(TOP(received by GDL))-rvc(TOP(prev))",
347  128, 0, 1280);
348  h_topGdlRvcDiff3All[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(TOP(prev))");
349 
350  //-------------------------------------------------------------------------------------------------------------------------------------------
351 
352  h_decisionNumberVsNumberDecisionsGood[iskim] = new TH2I(Form("h_decision_vs_n_decisions_good_%s", skim_smap[iskim].c_str()),
353  "Good decision number vs N of decisions", 5, 0,
354  5, 5, 0, 5);
355  h_decisionNumberVsNumberDecisionsGood[iskim]->GetXaxis()->SetTitle("N decisions");
356  h_decisionNumberVsNumberDecisionsGood[iskim]->GetYaxis()->SetTitle("Decision number");
357 
358  //------------------
359 
360  h_ecl_gdl_top_timing_diff_good[iskim] = new TH1I(Form("h_ecl_gdl_top_timing_diff_good_%s", skim_smap[iskim].c_str()), "", 400,
361  1400, 2200);
362  h_ecl_gdl_top_timing_diff_good[iskim]->GetXaxis()->SetTitle("Good ECL - GDL_TOP timing difference (2ns)");
363 
364  h_ecl_top_top_timing_diff_good[iskim] = new TH1I(Form("h_ecl_top_top_timing_diff_good_%s", skim_smap[iskim].c_str()), "", 400,
365  1400, 2200);
366  h_ecl_top_top_timing_diff_good[iskim]->GetXaxis()->SetTitle("Good ECL - TOP_TOP timing difference (2ns)");
367 
368  //------------------
369 
370  h_gdl_ecltop_timing_diff_vs_toptop_good[iskim] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_toptop_good_%s",
371  skim_smap[iskim].c_str()),
372  "GOOD TOP-TOP vs (GDL ECL)-(GDL TOP) (combined) t0 differences", 110, -760, 10240, 110, -760, 10240);
373  h_gdl_ecltop_timing_diff_vs_toptop_good[iskim]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(GDL TOP) t0 difference (ns, 100ns bins)");
374  h_gdl_ecltop_timing_diff_vs_toptop_good[iskim]->GetYaxis()->SetTitle("TOP timing (TOP) - TOP timing (GDL) (ns, 100ns bins)");
375 
376  h_top_ecltop_timing_diff_vs_toptop_good[iskim] = new TH2I(Form("h_top_ecltop_timing_diff_vs_toptop_good_%s",
377  skim_smap[iskim].c_str()),
378  "GOOD TOP-TOP vs (GDL ECL)-(TOP TOP) (combined) t0 differences", 110, -760, 10240, 110, -760, 10240);
379  h_top_ecltop_timing_diff_vs_toptop_good[iskim]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (ns, 100ns bins)");
380  h_top_ecltop_timing_diff_vs_toptop_good[iskim]->GetYaxis()->SetTitle("TOP timing (TOP) - TOP timing (GDL) (ns, 100ns bins)");
381 
382  h_gdl_ecltop_timing_diff_vs_ecltop_good[iskim] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_ecltop_good_%s",
383  skim_smap[iskim].c_str()),
384  "GOOD (GDL ECL)-(TOP TOP) vs (GDL ECL)-(GDL TOP) (combined) t0 differences", 110, -760, 10240, 110, -760, 10240);
385  h_gdl_ecltop_timing_diff_vs_ecltop_good[iskim]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(GDL TOP) t0 difference (ns, 100ns bins)");
386  h_gdl_ecltop_timing_diff_vs_ecltop_good[iskim]->GetYaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (ns, 100ns bins)");
387 
388  //-------------------------------------------------------------------------------------------------------------------------------------------
389 
390  h_gdl_gdltop_rvc_diff_good[iskim] = new TH1I(Form("h_gdl_gdltop_rvc_diff_good_%s", skim_smap[iskim].c_str()),
391  "GOOD GDL GDL-TOP rvc difference",
392  10, 1270, 1280);
393  h_gdl_gdltop_rvc_diff_good[iskim]->GetXaxis()->SetTitle("TOPTRG GDL GDL-TOP rvc difference (clks)");
394 
395  h_gdl_comtop_rvc_diff_good[iskim] = new TH1I(Form("h_gdl_comtop_rvc_diff_good_%s", skim_smap[iskim].c_str()),
396  "GOOD GDL COM-TOP rvc difference",
397  30, 20, 50);
398  h_gdl_comtop_rvc_diff_good[iskim]->GetXaxis()->SetTitle("TOPTRG GDL COM-TOP rvc difference (clks)");
399 
400  //-------------
401 
402  h_topCombinedTimingTopGood[iskim] = new TH1I(Form("h_t0_good_%s", skim_smap[iskim].c_str()), "GOOD TOP combined t0 decision", 100,
403  0,
404  100000);
405  h_topCombinedTimingTopGood[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions");
406 
407  h_topNSlotsCombinedTimingTopGood[iskim] = new TH1I(Form("h_n_slots_good_%s", skim_smap[iskim].c_str()),
408  "GOOD TOP combined t0 decision: N slots", 17, 0, 17);
409  h_topNSlotsCombinedTimingTopGood[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N slots");
410 
411  h_topNHitSumGood[iskim] = new TH1I(Form("h_n_hit_per_slot_good_%s", skim_smap[iskim].c_str()),
412  "GOOD TOP combined t0 decision: N hit per slot", 200, 0, 200);
413  h_topNHitSumGood[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N hits per slot");
414 
415  h_topLogLSumGood[iskim] = new TH1I(Form("h_logl_per_slot_good_%s", skim_smap[iskim].c_str()),
416  "GOOD TOP combined t0 decision: log L per slot", 100, 0, 60000);
417  h_topLogLSumGood[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: log L per slot");
418 
419  //-------------
420 
421  h_topRvcDiff1Good[iskim] = new TH1I(Form("h_rvc_diff_1_good_%s", skim_smap[iskim].c_str()),
422  "GOOD rvc(posted to GDL)-rvc(TOP(this))",
423  250, -100, 150);
424  h_topRvcDiff1Good[iskim]->GetXaxis()->SetTitle("rvc(posted to GDL)-rvc(TOP(this))");
425 
426  h_topRvcDiff2Good[iskim] = new TH1I(Form("h_rvc_diff_2_good_%s", skim_smap[iskim].c_str()), "GOOD rvc(TOP(this))-rvc(TOP(prev))",
427  128, 0, 1280);
428  h_topRvcDiff2Good[iskim]->GetXaxis()->SetTitle("rvc(TOP(this))-rvc(TOP(prev))");
429 
430  h_topRvcDiff3Good[iskim] = new TH1I(Form("h_rvc_diff_3_good_%s", skim_smap[iskim].c_str()), "GOOD rvc(CB(window))-rvc(TOP(this))",
431  150, 0, 150);
432  h_topRvcDiff3Good[iskim]->GetXaxis()->SetTitle("rvc(CB(window))-rvc(TOP(this))");
433 
434  h_topRvcDiff4Good[iskim] = new TH1I(Form("h_rvc_diff_4_good_%s", skim_smap[iskim].c_str()),
435  "GOOD rvc(received L1 from GDL)-rvc(TOP(this))",
436  250, 0, 250);
437  h_topRvcDiff4Good[iskim]->GetXaxis()->SetTitle("rvc(L1)-rvc(TOP(this))");
438 
439  //-------------------------------------------------------------------------------------------------------------------------------------------
440 
441  h_topGdlRvcDiff1Good[iskim] = new TH1I(Form("h_gdl_top_l1_rvc_diff_good_%s", skim_smap[iskim].c_str()),
442  "GOOD rvc(L1(GDL))-rvc(L1(as reported to TOP))",
443  10, 1235, 1245);
444  h_topGdlRvcDiff1Good[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(L1(as reported to TOP))");
445 
446  h_topGdlRvcDiff2Good[iskim] = new TH1I(Form("h_gdl_l1_top_t0_this_rvc_diff_good_%s", skim_smap[iskim].c_str()),
447  "GOOD rvc(TOP(received by GDL))-rvc(TOP(this))",
448  100, 0, 200);
449  h_topGdlRvcDiff2Good[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(TOP(this))");
450 
451  h_topGdlRvcDiff3Good[iskim] = new TH1I(Form("h_gdl_l1_top_t0_prev_rvc_diff_good_%s", skim_smap[iskim].c_str()),
452  "GOOD rvc(TOP(received by GDL))-rvc(TOP(prev))",
453  128, 0, 1280);
454  h_topGdlRvcDiff3Good[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(TOP(prev))");
455 
456  //-------------------------------------------------------------------------------------------------------------------------------------------
457 
458  h_decisionNumberVsNumberDecisionsBad[iskim] = new TH2I(Form("h_decision_vs_n_decisions_bad_%s", skim_smap[iskim].c_str()),
459  "Bad decision number vs N of decisions", 5, 0, 5,
460  5, 0, 5);
461  h_decisionNumberVsNumberDecisionsBad[iskim]->GetXaxis()->SetTitle("N decisions");
462  h_decisionNumberVsNumberDecisionsBad[iskim]->GetYaxis()->SetTitle("Decision number");
463 
464  //------------------
465 
466  h_ecl_gdl_top_timing_diff_bad[iskim] = new TH1I(Form("h_ecl_gdl_top_timing_diff_bad_%s", skim_smap[iskim].c_str()), "", 400, 1400,
467  2200);
468  h_ecl_gdl_top_timing_diff_bad[iskim]->GetXaxis()->SetTitle("Bad ECL - GDL_TOP timing difference (2ns)");
469 
470  h_ecl_top_top_timing_diff_bad[iskim] = new TH1I(Form("h_ecl_top_top_timing_diff_bad_%s", skim_smap[iskim].c_str()), "", 400, 1400,
471  2200);
472  h_ecl_top_top_timing_diff_bad[iskim]->GetXaxis()->SetTitle("Bad ECL - TOP_TOP timing difference (2ns)");
473 
474  //------------------
475 
476  h_gdl_ecltop_timing_diff_vs_toptop_bad[iskim] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_toptop_bad_%s",
477  skim_smap[iskim].c_str()),
478  "BAD TOP-TOP vs (GDL ECL)-(GDL TOP) t0 differences", 110, -760, 10240, 110, -760, 10240);
479  h_gdl_ecltop_timing_diff_vs_toptop_bad[iskim]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(GDL TOP) (combined) t0 difference (ns, 100ns bins)");
480  h_gdl_ecltop_timing_diff_vs_toptop_bad[iskim]->GetYaxis()->SetTitle("TOP timing (TOP) - TOP timing (GDL) (ns, 100ns bins)");
481 
482  h_top_ecltop_timing_diff_vs_toptop_bad[iskim] = new TH2I(Form("h_top_ecltop_timing_diff_vs_toptop_bad_%s",
483  skim_smap[iskim].c_str()),
484  "BAD TOP-TOP vs (GDL ECL)-(TOP TOP) (combined) t0 differences", 110, -760, 10240, 110, -760, 10240);
485  h_top_ecltop_timing_diff_vs_toptop_bad[iskim]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (ns, 100ns bins)");
486  h_top_ecltop_timing_diff_vs_toptop_bad[iskim]->GetYaxis()->SetTitle("TOP timing (TOP) - TOP timing (GDL) (ns, 100ns bins)");
487 
488  h_gdl_ecltop_timing_diff_vs_ecltop_bad[iskim] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_ecltop_bad_%s",
489  skim_smap[iskim].c_str()),
490  "BAD (GDL ECL)-(TOP TOP) vs (GDL ECL)-(GDL TOP) (combined) t0 differences", 110, -760, 10240, 110, -760, 10240);
491  h_gdl_ecltop_timing_diff_vs_ecltop_bad[iskim]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(GDL TOP) t0 difference (ns, 100ns bins)");
492  h_gdl_ecltop_timing_diff_vs_ecltop_bad[iskim]->GetYaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (ns, 100ns bins)");
493 
494  //-------------------------------------------------------------------------------------------------------------------------------------------
495 
496  h_gdl_gdltop_rvc_diff_bad[iskim] = new TH1I(Form("h_gdl_gdltop_rvc_diff_bad_%s", skim_smap[iskim].c_str()),
497  "BAD GDL GDL-TOP rvc difference",
498  10, 1270, 1280);
499  h_gdl_gdltop_rvc_diff_bad[iskim]->GetXaxis()->SetTitle("TOPTRG GDL GDL-TOP rvc difference (clks)");
500 
501  h_gdl_comtop_rvc_diff_bad[iskim] = new TH1I(Form("h_gdl_comtop_rvc_diff_bad_%s", skim_smap[iskim].c_str()),
502  "BAD GDL COM-TOP rvc difference",
503  30, 20, 50);
504  h_gdl_comtop_rvc_diff_bad[iskim]->GetXaxis()->SetTitle("TOPTRG GDL COM-TOP rvc difference (clks)");
505 
506  //-------------
507 
508  h_topCombinedTimingTopBad[iskim] = new TH1I(Form("h_t0_bad_%s", skim_smap[iskim].c_str()), "BAD TOP combined t0 decision", 100, 0,
509  100000);
510  h_topCombinedTimingTopBad[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions");
511 
512  h_topNSlotsCombinedTimingTopBad[iskim] = new TH1I(Form("h_N_slots_bad_%s", skim_smap[iskim].c_str()),
513  "BAD TOP combined t0 decision: N slots", 17, 0, 17);
514  h_topNSlotsCombinedTimingTopBad[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N slots");
515 
516  h_topNHitSumBad[iskim] = new TH1I(Form("h_n_hit_per_slot_bad_%s", skim_smap[iskim].c_str()),
517  "BAD TOP combined t0 decision: N hit per slot", 200, 0, 200);
518  h_topNHitSumBad[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N hits per slot");
519 
520  h_topLogLSumBad[iskim] = new TH1I(Form("h_logl_per_slot_bad_%s", skim_smap[iskim].c_str()),
521  "BAD TOP combined t0 decision: log L per slot", 100, 0, 60000);
522  h_topLogLSumBad[iskim]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: log L per slot");
523 
524  //-------------
525 
526  h_topRvcDiff1Bad[iskim] = new TH1I(Form("h_rvc_diff_1_bad_%s", skim_smap[iskim].c_str()), "BAD rvc(posted to GDL)-rvc(TOP(this))",
527  250, -100, 150);
528 
529  h_topRvcDiff1Bad[iskim]->GetXaxis()->SetTitle("rvc(posted to GDL)-rvc(TOP(this))");
530 
531  h_topRvcDiff2Bad[iskim] = new TH1I(Form("h_rvc_diff_2_bad_%s", skim_smap[iskim].c_str()), "BAD rvc(TOP(this))-rvc(TOP(prev))",
532  128, 0, 1280);
533  h_topRvcDiff2Bad[iskim]->GetXaxis()->SetTitle("rvc(TOP(this))-rvc(TOP(prev))");
534 
535  h_topRvcDiff3Bad[iskim] = new TH1I(Form("h_rvc_diff_3_bad_%s", skim_smap[iskim].c_str()), "BAD rvc(CB(window))-rvc(TOP(this))",
536  150, 0, 150);
537  h_topRvcDiff3Bad[iskim]->GetXaxis()->SetTitle("rvc(CB(window))-rvc(TOP(this))");
538 
539  h_topRvcDiff4Bad[iskim] = new TH1I(Form("h_rvc_diff_4_bad_%s", skim_smap[iskim].c_str()),
540  "BAD rvc(received L1 from GDL)-rvc(TOP(this))",
541  250, 0, 250);
542  h_topRvcDiff4Bad[iskim]->GetXaxis()->SetTitle("rvc(L1)-rvc(TOP(this))");
543 
544  //-------------------------------------------------------------------------------------------------------------------------------------------
545 
546  h_topGdlRvcDiff1Bad[iskim] = new TH1I(Form("h_gdl_top_l1_rvc_diff_bad_%s", skim_smap[iskim].c_str()),
547  "BAD rvc(L1(GDL))-rvc(L1(as reported to TOP))",
548  10, 1235, 1245);
549  h_topGdlRvcDiff1Bad[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(L1(as reported to TOP))");
550 
551  h_topGdlRvcDiff2Bad[iskim] = new TH1I(Form("h_gdl_l1_top_t0_this_rvc_diff_bad_%s", skim_smap[iskim].c_str()),
552  "BAD rvc(TOP(received by GDL))-rvc(TOP(this))",
553  100, 0, 200);
554  h_topGdlRvcDiff2Bad[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(TOP(this))");
555 
556  h_topGdlRvcDiff3Bad[iskim] = new TH1I(Form("h_gdl_l1_top_t0_prev_rvc_diff_bad_%s", skim_smap[iskim].c_str()),
557  "BAD rvc(TOP(received by GDL))-rvc(TOP(prev))",
558  128, 0, 1280);
559  h_topGdlRvcDiff3Bad[iskim]->GetXaxis()->SetTitle("rvc(L1(GDL))-rvc(TOP(prev))");
560 
561  }
562  //-------------------------------------------------------------------------------------------------------------------------------------------
563 
564  h_top_nt0decisions_vs_hist_class[iskim] = new TH2I(Form("h_top_nt0decisions_vs_hist_class_%s", skim_smap[iskim].c_str()),
565  "N t0 decisions vs event class according to TOP info matching between GDL and TOP",
566  3, 0, 3, 5, 1, 6);
567  h_top_nt0decisions_vs_hist_class[iskim]->GetXaxis()->SetTitle("TOP info match (GDL vs TOP): 0/1/2 : first decision match/no match/match in some other decision");
568  h_top_nt0decisions_vs_hist_class[iskim]->GetYaxis()->SetTitle("Number of t0 decisions");
569 
570  h_top_gdl_match_decision_number[iskim] = new TH1I(Form("h_top_gdl_match_decision_number_%s", skim_smap[iskim].c_str()),
571  "Decision number where TOP info is the same at TOP and GDL",
572  6, 0, 6);
573  h_top_gdl_match_decision_number[iskim]->GetXaxis()->SetTitle("TOPTRG combined decision # where TOP info is the same at TOP and GDL");
574 
575  h_gdl_ecltop_timing_diff_5ns[iskim] = new TH1I(Form("h_gdl_ecltop_timing_diff_5ns_%s", skim_smap[iskim].c_str()),
576  "GDL ECL-TOP t0 difference", 248, 0, 10240);
577  h_gdl_ecltop_timing_diff_5ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference (5ns)");
578 
579  h_gdl_cdctop_timing_diff_5ns[iskim] = new TH1I(Form("h_gdl_cdctop_timing_diff_5ns_%s", skim_smap[iskim].c_str()),
580  "GDL CDC-TOP t0 difference", 248, 0, 10240);
581  h_gdl_cdctop_timing_diff_5ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL CDC-TOP t0 difference (5ns)");
582 
583  //--- resolution plots ---
584 
585  h_gdl_ecltop_timing_diff_2ns[iskim] = new TH1I(Form("h_gdl_ecltop_timing_diff_2ns_%s", skim_smap[iskim].c_str()),
586  "GDL ECL-TOP t0 difference", 400, 1400, 2200);
587  h_gdl_ecltop_timing_diff_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference (2ns)");
588 
589  h_gdl_ecltop_timing_diff_grl_matched_2ns[iskim] = new TH1I(Form("h_gdl_ecltop_timing_diff_grl_matched_2ns_%s",
590  skim_smap[iskim].c_str()),
591  "GDL ECL-TOP t0 difference", 400, 1400, 2200);
592  h_gdl_ecltop_timing_diff_grl_matched_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference when TOP and GRL match (2ns)");
593 
594  h_gdl_ecltop_timing_diff_no_grl_matched_2ns[iskim] = new TH1I(Form("h_gdl_ecltop_timing_diff_no_grl_matched_2ns_%s",
595  skim_smap[iskim].c_str()),
596  "GDL ECL-TOP t0 difference", 400, 1400, 2200);
597  h_gdl_ecltop_timing_diff_no_grl_matched_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference when TOP and GRL do not match (2ns)");
598 
599  h_gdl_ecltop_timing_diff_no_grl_at_all_2ns[iskim] = new TH1I(Form("h_gdl_ecltop_timing_diff_no_grl_at_all_2ns_%s",
600  skim_smap[iskim].c_str()),
601  "GDL ECL-TOP t0 difference", 400, 1400, 2200);
602  h_gdl_ecltop_timing_diff_no_grl_at_all_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference when GRL has no 2D tracks (2ns)");
603 
604  h_gdl_ecltop_timing_diff_vs_nslots_2ns[iskim] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_nslots_2ns_%s",
605  skim_smap[iskim].c_str()),
606  "GDL N slots vs ECL-TOP t0 difference", 400, 1400, 2200, 16, 1, 17);
607  h_gdl_ecltop_timing_diff_vs_nslots_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference (2ns)");
608  h_gdl_ecltop_timing_diff_vs_nslots_2ns[iskim]->GetYaxis()->SetTitle("N slots in combined decision");
609 
610  h_top_ecltop_timing_diff_combined_2ns[iskim] = new TH1I(Form("h_gdl_ecltop_timing_diff_combined_2ns_%s", skim_smap[iskim].c_str()),
611  "GDL ECL-TOP TOP t0 difference", 400, 1400, 2200);
612  h_top_ecltop_timing_diff_combined_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference (2ns)");
613 
614  h_top_ecltop_timing_diff_best_slot_2ns[iskim] = new TH1I(Form("h_gdl_ecltop_timing_diff_best_slot_2ns_%s",
615  skim_smap[iskim].c_str()),
616  "GDL ECL-TOP TOP t0 difference using slot with max N hits", 400, 1400, 2200);
617  h_top_ecltop_timing_diff_best_slot_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL ECL-TOP t0 difference (2ns)");
618 
619  h_gdl_cdctop_timing_diff_2ns[iskim] = new TH1I(Form("h_gdl_cdctop_timing_diff_2ns_%s", skim_smap[iskim].c_str()),
620  "GDL CDC-TOP t0 difference", 250, 0, 500);
621  h_gdl_cdctop_timing_diff_2ns[iskim]->GetXaxis()->SetTitle("TOPTRG GDL CDC-TOP t0 difference (2ns)");
622 
623  //------------------------
624 
625  for (int histClass = 0; histClass < m_nHistClassesActual; histClass++) {
626 
627  // max N of combined t0 decisions (over past ~us) = N windows in circular buffer
628  h_N_decision[iskim][histClass] = new TH1I(Form("h_N_decisions_%d_%s", histClass, skim_smap[iskim].c_str()),
629  "N t0 decisions in 1 us before GDL L1", 5, 1,
630  6);
631  h_N_decision[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG N combined t0 decisions");
632 
633  //-------------
634 
635  h_topNHitVsNhit[iskim][histClass] = new TH2I(Form("h_nhit_vs_nhit_first_decision_%d_%s", histClass, skim_smap[iskim].c_str()),
636  "First decision: N hits vs N hits", 20, 0, 100, 20, 0, 100);
637  h_topNHitVsNhit[iskim][histClass]->GetXaxis()->SetTitle("N hits for slot with largest N hits");
638  h_topNHitVsNhit[iskim][histClass]->GetYaxis()->SetTitle("N hits for slot with next to the largest N hits");
639 
640  h_topSlotVsSlot[iskim][histClass] = new TH2I(Form("h_slot_vs_slot_first_decision_%d_%s", histClass, skim_smap[iskim].c_str()),
641  "First decision: slot # vs slot #", 16, 1, 17, 16, 1, 17);
642  h_topSlotVsSlot[iskim][histClass]->GetXaxis()->SetTitle("Slot # for slot with largest N hits");
643  h_topSlotVsSlot[iskim][histClass]->GetYaxis()->SetTitle("Slot # for slot with next to the largest N hits");
644 
645  h_topT0VsT0[iskim][histClass] = new TH2I(Form("h_t0_vs_t0_first_decision_%d_%s", histClass, skim_smap[iskim].c_str()),
646  "First decision: T0 vs T0", 100, 0, 100000, 100, 0, 100000);
647  h_topT0VsT0[iskim][histClass]->GetXaxis()->SetTitle("T0 for slot with largest N hits");
648  h_topT0VsT0[iskim][histClass]->GetYaxis()->SetTitle("T0 for slot with next to the largest N hits");
649 
650  h_topSegmentVsSegment[iskim][histClass] = new TH2I(Form("h_segment_vs_segment_first_decision_%d_%s", histClass,
651  skim_smap[iskim].c_str()),
652  "First decision: segment # vs segment #", 10, 1, 11, 10, 1, 11);
653  h_topSegmentVsSegment[iskim][histClass]->GetXaxis()->SetTitle("Segment # for slot with largest N hits");
654  h_topSegmentVsSegment[iskim][histClass]->GetYaxis()->SetTitle("Segment # for slot with next to the largest N hits");
655 
656  h_topLogLVsLogL[iskim][histClass] = new TH2I(Form("h_logl_vs_logl_first_decision_%d_%s", histClass, skim_smap[iskim].c_str()),
657  "First decision: log L vs log L", 100, 0, 60000, 100, 0, 60000);
658  h_topLogLVsLogL[iskim][histClass]->GetXaxis()->SetTitle("log L for slot with largest N hits");
659  h_topLogLVsLogL[iskim][histClass]->GetYaxis()->SetTitle("log L for slot with next to the largest N hits");
660 
661  }
662 
663  //------------------------
664 
665  if (m_histLevel > 1) {
666 
667  // these two for loops are nested in this particular way to simplify browsing through the histograms
668 
669  for (int histClass = 0; histClass < m_nHistClassesActual; histClass++) {
670 
671  h_topCombinedTimingTop[iskim][histClass] = new TH1I(Form("h_t0_%d_%s", histClass, skim_smap[iskim].c_str()),
672  "TOP combined t0 decision", 100, 0,
673  100000);
674  h_topCombinedTimingTop[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions");
675 
676  h_topNSlotsCombinedTimingTop[iskim][histClass] = new TH1I(Form("h_n_slots_%d_%s", histClass, skim_smap[iskim].c_str()),
677  "TOP combined t0 decision: N slots", 17, 0, 17);
678  h_topNSlotsCombinedTimingTop[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N slots");
679 
680  h_topNHitSum[iskim][histClass] = new TH1I(Form("h_n_hit_per_slot_%d_%s", histClass, skim_smap[iskim].c_str()),
681  "TOP combined t0 decision: N hits per slot", 200, 0, 200);
682  h_topNHitSum[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N hits per slot");
683 
684  h_topNHitBestSlot[iskim][histClass] = new TH1I(Form("h_n_hit_best_slot_%d_%s", histClass, skim_smap[iskim].c_str()),
685  "TOP combined t0 decision: N hits best slot", 200, 0, 200);
686  h_topNHitBestSlot[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: N hits best slot");
687 
688  // h_topT0DecisionNumberBestSlot[iskim][histClass] = new TH1I(Form("h_t0_decision_number_best_slot_%d_%s", histClass,
689  // skim_smap[iskim].c_str()),
690  // "TOP combined t0 decision: combined t0 decision number best slot", 5, 1, 6);
691  // h_topT0DecisionNumberBestSlot[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: combined t0 decision number best slot");
692 
693  h_topLogLSum[iskim][histClass] = new TH1I(Form("h_logl_per_slot_%d_%s", histClass, skim_smap[iskim].c_str()),
694  "TOP combined t0 decision: log L per slot", 100, 0, 60000);
695  h_topLogLSum[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG combined t0 decisions: log L per slot");
696 
697  //-------------------------------------------------------------------------------------------------------------------------------------------
698 
699  h_gdl_ecltop_timing_diff_vs_slot_2ns[iskim][histClass] = new TH2I(Form("h_gdl_slot_vs_ecltop_timing_diff_%d_%s", histClass,
700  skim_smap[iskim].c_str()), "slot vs GDL ECL-TOP slot t0 difference", 400, 1400, 2200, 16, 1, 17);
701  h_gdl_ecltop_timing_diff_vs_slot_2ns[iskim][histClass]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
702  h_gdl_ecltop_timing_diff_vs_slot_2ns[iskim][histClass]->GetYaxis()->SetTitle("slot");
703 
704  h_gdl_ecltop_timing_diff_vs_segment_2ns[iskim][histClass] = new TH2I(Form("h_gdl_segment_vs_ecltop_timing_diff_%d_%s", histClass,
705  skim_smap[iskim].c_str()), "segment vs GDL ECL-TOP slot t0 difference", 400, 1400, 2200, 10, 1, 11);
706  h_gdl_ecltop_timing_diff_vs_segment_2ns[iskim][histClass]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
707  h_gdl_ecltop_timing_diff_vs_segment_2ns[iskim][histClass]->GetYaxis()->SetTitle("segment");
708 
709  h_gdl_ecltop_timing_diff_vs_nhits_2ns[iskim][histClass] = new TH2I(Form("h_gdl_nhits_vs_ecltop_timing_diff_%d_%s", histClass,
710  skim_smap[iskim].c_str()), "N hits (for slots) vs GDL ECL-TOP slot t0 difference", 400, 1400, 2200, 200, 0, 200);
711  h_gdl_ecltop_timing_diff_vs_nhits_2ns[iskim][histClass]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
712  h_gdl_ecltop_timing_diff_vs_nhits_2ns[iskim][histClass]->GetYaxis()->SetTitle("N hits");
713 
714  h_gdl_ecltop_timing_diff_vs_logl_2ns[iskim][histClass] = new TH2I(Form("h_gdl_logl_vs_ecltop_timing_diff_%d_%s", histClass,
715  skim_smap[iskim].c_str()), "log L (for slots) vs GDL ECL-TOP slot t0 difference", 400, 1400, 2200, 100, 0, 60000);
716  h_gdl_ecltop_timing_diff_vs_logl_2ns[iskim][histClass]->GetXaxis()->SetTitle("GDL ECL - TOP slot t0 time difference (2ns)");
717  h_gdl_ecltop_timing_diff_vs_logl_2ns[iskim][histClass]->GetYaxis()->SetTitle("log L");
718 
719  //-------------
720 
721  h_top_ecltop_timing_combined_diff_2ns[iskim][histClass] = new TH1I(Form("h_top_ecltop_timing_combined_diff_2ns_%d_%s", histClass,
722  skim_smap[iskim].c_str()),
723  "(GDL ECL)-(TOP TOP) t0 difference (combined decision)", 400, 1400, 2200);
724  h_top_ecltop_timing_combined_diff_2ns[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (2ns)");
725 
726  h_top_ecltop_timing_best_slot_diff_2ns[iskim][histClass] = new TH1I(Form("h_top_ecltop_timing_best_slot_diff_2ns_%d_%s", histClass,
727  skim_smap[iskim].c_str()),
728  "(GDL ECL)-(TOP TOP) t0 difference (best slot decision)", 400, 1400, 2200);
729  h_top_ecltop_timing_best_slot_diff_2ns[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (2ns)");
730 
731  h_gdl_ecltop_timing_diff_vs_toptop[iskim][histClass] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_toptop_%d_%s", histClass,
732  skim_smap[iskim].c_str()),
733  "TOP-TOP vs (GDL ECL)-(GDL TOP) t0 differences", 110, -760, 10240, 110, -760, 10240);
734  h_gdl_ecltop_timing_diff_vs_toptop[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(GDL TOP) (combined) t0 difference (ns, 100ns bins)");
735  h_gdl_ecltop_timing_diff_vs_toptop[iskim][histClass]->GetYaxis()->SetTitle("TOP timing (TOP) - TOP timing (GDL) (ns, 100ns bins)");
736 
737  h_top_ecltop_timing_diff_vs_toptop[iskim][histClass] = new TH2I(Form("h_top_ecltop_timing_diff_vs_toptop_%d_%s", histClass,
738  skim_smap[iskim].c_str()),
739  "TOP-TOP vs (GDL ECL)-(TOP TOP) (combined) t0 differences", 110, -760, 10240, 110, -760, 10240);
740  h_top_ecltop_timing_diff_vs_toptop[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (ns, 100ns bins)");
741  h_top_ecltop_timing_diff_vs_toptop[iskim][histClass]->GetYaxis()->SetTitle("TOP timing (TOP) - TOP timing (GDL) (ns, 100ns bins)");
742 
743  h_gdl_ecltop_timing_diff_vs_ecltop[iskim][histClass] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_ecltop_%d_%s", histClass,
744  skim_smap[iskim].c_str()),
745  "(GDL ECL)-(TOP TOP) vs (GDL ECL)-(GDL TOP) (combined) t0 differences", 110, -760, 10240, 110, -760, 10240);
746  h_gdl_ecltop_timing_diff_vs_ecltop[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(GDL TOP) t0 difference (ns, 100ns bins)");
747  h_gdl_ecltop_timing_diff_vs_ecltop[iskim][histClass]->GetYaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (ns, 100ns bins)");
748 
749  h_gdl_ecltop_timing_diff_vs_ecltop_best_slot[iskim][histClass] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_ecltop_best_slot_%d_%s",
750  histClass, skim_smap[iskim].c_str()),
751  "(GDL ECL)-(TOP TOP) vs (GDL ECL)-(GDL TOP) (best slot) t0 differences", 110, -760, 10240, 110, -760, 10240);
752  h_gdl_ecltop_timing_diff_vs_ecltop_best_slot[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(GDL TOP() best slot) t0 difference (ns, 100ns bins)");
753  h_gdl_ecltop_timing_diff_vs_ecltop_best_slot[iskim][histClass]->GetYaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (ns, 100ns bins)");
754 
755  h_top_ecltop_timing_diff_2ns[iskim][histClass] = new TH1I(Form("h_top_ecltop_timing_diff_2ns_%d_%s", histClass,
756  skim_smap[iskim].c_str()),
757  "(GDL ECL)-(TOP TOP) t0 difference (all decisions)", 400, 1400, 2200);
758  h_top_ecltop_timing_diff_2ns[iskim][histClass]->GetXaxis()->SetTitle("TOPTRG (GDL ECL)-(TOP TOP) t0 difference (2ns)");
759 
760  }
761  }
762 
763  //-----
764 
765  h_topTC2IdVsTC1IdAll[iskim] = new TH2I(Form("h_top_tc2id_vs_tc1id_%s", skim_smap[iskim].c_str()),
766  "Sorted (by energy) TC2 Id vs TC1 Id", 100, 0, 600, 100, 0, 600);
767  h_topTC2IdVsTC1IdAll[iskim]->GetXaxis()->SetTitle("Most energetic TC id");
768  h_topTC2IdVsTC1IdAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC id");
769 
770  h_topTC2EnergyVsTC1EnergyAll[iskim] = new TH2I(Form("h_top_tc2en_vs_tc1en_%s", skim_smap[iskim].c_str()),
771  "Sorted TC2 energy vs TC1 energy", 100, 0, 1000, 100, 0, 1000);
772  h_topTC2EnergyVsTC1EnergyAll[iskim]->GetXaxis()->SetTitle("Most energetic TC energy");
773  h_topTC2EnergyVsTC1EnergyAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC energy");
774 
775  h_topTC2ThetaIdVsTC1ThetaIdAll[iskim] = new TH2I(Form("h_top_tc2thetaid_vs_tc1thetaid_%s", skim_smap[iskim].c_str()),
776  "Sorted by energy TC2 vs TC1 theta ids", 20, 0, 20,
777  20, 0, 20);
778  h_topTC2ThetaIdVsTC1ThetaIdAll[iskim]->GetXaxis()->SetTitle("Most energetic TC theta id");
779  h_topTC2ThetaIdVsTC1ThetaIdAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC theta id");
780 
781  h_topTC2PhiIdVsTC1PhiIdAll[iskim] = new TH2I(Form("h_top_tc2phiid_vs_tc1phiid_%s", skim_smap[iskim].c_str()),
782  "Sorted by energy TC2 vs TC1 phi ids", 36, 1, 37, 36, 1,
783  37);
784  h_topTC2PhiIdVsTC1PhiIdAll[iskim]->GetXaxis()->SetTitle("Most energetic TC phi id");
785  h_topTC2PhiIdVsTC1PhiIdAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC phi id");
786 
787  h_topTCPhiIdVsTCThetaIdAll[iskim] = new TH3I(Form("h_top_tcphiid_vs_tcthetaid_%s", skim_smap[iskim].c_str()),
788  "Sorted by energy TC2 vs TC1 theta vs phi ids", 20, 0, 20,
789  36, 1, 37, 2, 0, 2);
790  h_topTCPhiIdVsTCThetaIdAll[iskim]->GetXaxis()->SetTitle("Most and next to most energetic TCs theta ids");
791  h_topTCPhiIdVsTCThetaIdAll[iskim]->GetYaxis()->SetTitle("Most and next to most energetic TCs phi ids");
792  h_topTCPhiIdVsTCThetaIdAll[iskim]->GetZaxis()->SetTitle("Most and next to most energetic TCs");
793 
794  //-----
795 
796  h_topTC2IdVsTC1IdGRLAll[iskim] = new TH2I(Form("h_top_tc2id_vs_tc1id_grl_%s", skim_smap[iskim].c_str()),
797  "Sorted (by energy) TC2 Id vs TC1 Id", 100, 0, 600, 100, 0, 600);
798  h_topTC2IdVsTC1IdGRLAll[iskim]->GetXaxis()->SetTitle("Most energetic TC id");
799  h_topTC2IdVsTC1IdGRLAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC id");
800 
801  h_topTC2EnergyVsTC1EnergyGRLAll[iskim] = new TH2I(Form("h_top_tc2en_vs_tc1en_grl_%s", skim_smap[iskim].c_str()),
802  "Sorted TC2 energy vs TC1 energy", 100, 0, 1000, 100, 0,
803  1000);
804  h_topTC2EnergyVsTC1EnergyGRLAll[iskim]->GetXaxis()->SetTitle("Most energetic TC energy");
805  h_topTC2EnergyVsTC1EnergyGRLAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC energy");
806 
807  h_topTC2ThetaIdVsTC1ThetaIdGRLAll[iskim] = new TH2I(Form("h_top_tc2thetaid_vs_tc1thetaid_grl_%s", skim_smap[iskim].c_str()),
808  "Sorted by energy TC2 vs TC1 theta ids", 20,
809  0, 20, 20, 0, 20);
810  h_topTC2ThetaIdVsTC1ThetaIdGRLAll[iskim]->GetXaxis()->SetTitle("Most energetic TC theta id");
811  h_topTC2ThetaIdVsTC1ThetaIdGRLAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC theta id");
812 
813  h_topTC2PhiIdVsTC1PhiIdGRLAll[iskim] = new TH2I(Form("h_top_tc2phiid_vs_tc1phiid_grl_%s", skim_smap[iskim].c_str()),
814  "Sorted by energy TC2 vs TC1 phi ids", 36, 1, 37, 36,
815  1, 37);
816  h_topTC2PhiIdVsTC1PhiIdGRLAll[iskim]->GetXaxis()->SetTitle("Most energetic TC phi id");
817  h_topTC2PhiIdVsTC1PhiIdGRLAll[iskim]->GetYaxis()->SetTitle("Next to most energetic TC phi id");
818 
819  h_topTCPhiIdVsTCThetaIdGRLAll[iskim] = new TH3I(Form("h_top_tcphiid_vs_tcthetaid_grl_%s", skim_smap[iskim].c_str()),
820  "Sorted by energy TC2 vs TC1 theta vs phi ids", 20,
821  0, 20, 36, 1, 37, 2, 0, 2);
822  h_topTCPhiIdVsTCThetaIdGRLAll[iskim]->GetXaxis()->SetTitle("Most and next to most energetic TCs theta ids");
823  h_topTCPhiIdVsTCThetaIdGRLAll[iskim]->GetYaxis()->SetTitle("Most and next to most energetic TCs phi ids");
824  h_topTCPhiIdVsTCThetaIdGRLAll[iskim]->GetZaxis()->SetTitle("Most and next to most energetic TCs");
825 
826  //-----
827 
828  h_topTC2IdVsTC1Id[iskim] = new TH2I(Form("h_top_tc2id_vs_tc1id_b2b_%s", skim_smap[iskim].c_str()),
829  "Sorted (by energy) TC2 Id vs TC1 Id", 100, 0, 600, 100, 0, 600);
830  h_topTC2IdVsTC1Id[iskim]->GetXaxis()->SetTitle("Most energetic TC id");
831  h_topTC2IdVsTC1Id[iskim]->GetYaxis()->SetTitle("Next to most energetic TC id");
832 
833  h_topTC2EnergyVsTC1Energy[iskim] = new TH2I(Form("h_top_tc2en_vs_tc1en_b2b_%s", skim_smap[iskim].c_str()),
834  "Sorted TC2 energy vs TC1 energy", 100, 0, 1000, 100, 0, 1000);
835  h_topTC2EnergyVsTC1Energy[iskim]->GetXaxis()->SetTitle("Most energetic TC energy");
836  h_topTC2EnergyVsTC1Energy[iskim]->GetYaxis()->SetTitle("Next to most energetic TC energy");
837 
838  h_topTC2ThetaIdVsTC1ThetaId[iskim] = new TH2I(Form("h_top_tc2thetaid_vs_tc1thetaid_b2b_%s", skim_smap[iskim].c_str()),
839  "Sorted by energy TC2 vs TC1 theta ids", 20, 0, 20, 20, 0,
840  20);
841  h_topTC2ThetaIdVsTC1ThetaId[iskim]->GetXaxis()->SetTitle("Most energetic TC theta id");
842  h_topTC2ThetaIdVsTC1ThetaId[iskim]->GetYaxis()->SetTitle("Next to most energetic TC theta id");
843 
844  h_topTC2PhiIdVsTC1PhiId[iskim] = new TH2I(Form("h_top_tc2phiid_vs_tc1phiid_b2b_%s", skim_smap[iskim].c_str()),
845  "Sorted by energy TC2 vs TC1 phi ids", 36, 1, 37, 36, 1, 37);
846  h_topTC2PhiIdVsTC1PhiId[iskim]->GetXaxis()->SetTitle("Most energetic TC phi id");
847  h_topTC2PhiIdVsTC1PhiId[iskim]->GetYaxis()->SetTitle("Next to most energetic TC phi id");
848 
849  h_topTCPhiIdVsTCThetaId[iskim] = new TH3I(Form("h_top_tcphiid_vs_tcthetaid_b2b_%s", skim_smap[iskim].c_str()),
850  "Sorted by energy TC2 vs TC1 theta vs phi ids", 20, 0, 20, 36, 1,
851  37, 2, 0, 2);
852  h_topTCPhiIdVsTCThetaId[iskim]->GetXaxis()->SetTitle("Most and next to most energetic TCs theta ids");
853  h_topTCPhiIdVsTCThetaId[iskim]->GetYaxis()->SetTitle("Most and next to most energetic TCs phi ids");
854  h_topTCPhiIdVsTCThetaId[iskim]->GetZaxis()->SetTitle("Most and next to most energetic TCs");
855 
856  //-----
857 
858  h_topTC2IdVsTC1IdGRL[iskim] = new TH2I(Form("h_top_tc2id_vs_tc1id_grl_b2b_%s", skim_smap[iskim].c_str()),
859  "Sorted (by energy) TC2 Id vs TC1 Id", 100, 0, 600, 100, 0, 600);
860  h_topTC2IdVsTC1IdGRL[iskim]->GetXaxis()->SetTitle("Most energetic TC id");
861  h_topTC2IdVsTC1IdGRL[iskim]->GetYaxis()->SetTitle("Next to most energetic TC id");
862 
863  h_topTC2EnergyVsTC1EnergyGRL[iskim] = new TH2I(Form("h_top_tc2en_vs_tc1en_grl_b2b_%s", skim_smap[iskim].c_str()),
864  "Sorted TC2 energy vs TC1 energy", 100, 0, 1000, 100, 0, 1000);
865  h_topTC2EnergyVsTC1EnergyGRL[iskim]->GetXaxis()->SetTitle("Most energetic TC energy");
866  h_topTC2EnergyVsTC1EnergyGRL[iskim]->GetYaxis()->SetTitle("Next to most energetic TC energy");
867 
868  h_topTC2ThetaIdVsTC1ThetaIdGRL[iskim] = new TH2I(Form("h_top_tc2thetaid_vs_tc1thetaid_grl_b2b_%s", skim_smap[iskim].c_str()),
869  "Sorted by energy TC2 vs TC1 theta ids", 20, 0, 20,
870  20, 0, 20);
871  h_topTC2ThetaIdVsTC1ThetaIdGRL[iskim]->GetXaxis()->SetTitle("Most energetic TC theta id");
872  h_topTC2ThetaIdVsTC1ThetaIdGRL[iskim]->GetYaxis()->SetTitle("Next to most energetic TC theta id");
873 
874  h_topTC2PhiIdVsTC1PhiIdGRL[iskim] = new TH2I(Form("h_top_tc2phiid_vs_tc1phiid_grl_b2b_%s", skim_smap[iskim].c_str()),
875  "Sorted by energy TC2 vs TC1 phi ids", 36, 1, 37, 36, 1,
876  37);
877  h_topTC2PhiIdVsTC1PhiIdGRL[iskim]->GetXaxis()->SetTitle("Most energetic TC phi id");
878  h_topTC2PhiIdVsTC1PhiIdGRL[iskim]->GetYaxis()->SetTitle("Next to most energetic TC phi id");
879 
880  h_topTCPhiIdVsTCThetaIdGRL[iskim] = new TH3I(Form("h_top_tcphiid_vs_tcthetaid_grl_b2b_%s", skim_smap[iskim].c_str()),
881  "Sorted by energy TC2 vs TC1 theta vs phi ids", 20, 0, 20,
882  36, 1, 37, 2, 0, 2);
883  h_topTCPhiIdVsTCThetaIdGRL[iskim]->GetXaxis()->SetTitle("Most and next to most energetic TCs theta ids");
884  h_topTCPhiIdVsTCThetaIdGRL[iskim]->GetYaxis()->SetTitle("Most and next to most energetic TCs phi ids");
885  h_topTCPhiIdVsTCThetaIdGRL[iskim]->GetZaxis()->SetTitle("Most and next to most energetic TCs");
886 
887  //-------------------------------------------------------------------------------------------------------------------------------------------
888 
889  h_gdl_ecltop_timing_diff_vs_grl_top_l1[iskim] = new TH2I(Form("h_gdl_ecltop_timing_diff_vs_grl_top_l1_%s",
890  skim_smap[iskim].c_str()),
891  "(GDL ECL)-(GDL TOP) vs GRL TOP rvc (relative to GDL L1)", 100, -2000, 0, 110, -760, 10240);
892  h_gdl_ecltop_timing_diff_vs_grl_top_l1[iskim]->GetXaxis()->SetTitle("GRL TOP rvc relative to GDL L1 (rvc)");
893  h_gdl_ecltop_timing_diff_vs_grl_top_l1[iskim]->GetYaxis()->SetTitle("(GDL ECL)-(GDL TOP) t0 difference (ns, 100ns bins)");
894 
895  h_gdl_top_l1_vs_grl_top_l1[iskim] = new TH2I(Form("h_gdl_top_l1_vs_grl_top_l1_%s", skim_smap[iskim].c_str()),
896  "GDL TOP rvc vs GRL TOP rvc (relative to GDL L1)", 100, -2000,
897  0, 128, 0, 1280);
898  h_gdl_top_l1_vs_grl_top_l1[iskim]->GetXaxis()->SetTitle("GRL TOP rvc relative to GDL L1 (rvc)");
899  h_gdl_top_l1_vs_grl_top_l1[iskim]->GetYaxis()->SetTitle("GDL TOP rvc relative to GDL L1 (rvc)");
900 
901  h_grl_ntopslots_vs_ncdcslots[iskim] = new TH2I(Form("h_grl_ntopslots_vs_ncdcslots_%s", skim_smap[iskim].c_str()),
902  "GRL TOP slots vs CDC slots", 10, 0, 10, 10, 0, 10);
903  h_grl_ntopslots_vs_ncdcslots[iskim]->GetXaxis()->SetTitle("GRL CDC slots");
904  h_grl_ntopslots_vs_ncdcslots[iskim]->GetYaxis()->SetTitle("GRL TOP slots");
905 
906  h_grl_ncdctopslots_matched[iskim] = new TH1I(Form("h_grl_ncdctopslots_matched_%s", skim_smap[iskim].c_str()),
907  "GRL Number of matched TOP and CDC slots", 17, 0, 17);
908  h_grl_ncdctopslots_matched[iskim]->GetXaxis()->SetTitle("Number of matched TOP and CDC slots");
909 
910  h_grl_topslots_vs_cdcslots_match[iskim] = new TH2I(Form("h_grl_topslots_vs_cdcslots_match_%s", skim_smap[iskim].c_str()),
911  "GRL TOP slots vs CDC slots matches", 17, 0, 17, 17,
912  0, 17);
913  h_grl_topslots_vs_cdcslots_match[iskim]->GetXaxis()->SetTitle("GRL CDC slot");
914  h_grl_topslots_vs_cdcslots_match[iskim]->GetYaxis()->SetTitle("GRL TOP slot");
915 
916  }
917  //-------------------------------------------------------------------------------------------------------------------------------------------
918 
919  oldDir->cd();
920 
921 }
922 
923 void TRGTOPDQMModule::beginRun()
924 {
925 
926  dirDQM->cd();
927 
928  for (int iskim = start_skim_topdqm; iskim < end_skim_topdqm; iskim++) {
929 
930  h_topSlotAll[iskim]->Reset();
931  h_topSegmentAll[iskim]->Reset();
932  h_topNHitsAll[iskim]->Reset();
933  h_topLogLAll[iskim]->Reset();
934  h_topT0All[iskim]->Reset();
935 
936  for (int slot = 0; slot <= 15; slot++) {
937  h_topSlotSegment[iskim][slot]->Reset();
938  h_topSlotNHits[iskim][slot]->Reset();
939  h_topSlotLogL[iskim][slot]->Reset();
940  h_topSlotT0[iskim][slot]->Reset();
941  }
942 
943  h_topSlotVsSegment[iskim]->Reset();
944 
945  h_topSlotVsNHits[iskim]->Reset();
946  h_topSlotVsLogL[iskim]->Reset();
947  h_topSlotVsT0[iskim]->Reset();
948 
949  h_topSegmentVsNHits[iskim]->Reset();
950  h_topSegmentVsLogL[iskim]->Reset();
951  h_topSegmentVsT0[iskim]->Reset();
952 
953  h_topNHitsVsLogL[iskim]->Reset();
954  h_topNHitsVsT0[iskim]->Reset();
955  h_topLogLVsT0[iskim]->Reset();
956 
957  h_ecl_gdl_top_timing_diff_both[iskim]->Reset();
958  h_ecl_top_top_timing_diff_both[iskim]->Reset();
959 
960  if (m_histLevel > 2) {
961 
962  h_gdl_top_rvc_vs_top_timing[iskim]->Reset();
963 
964  h_gdl_ecltop_rvc_diff[iskim]->Reset();
965  h_gdl_cdctop_rvc_diff[iskim]->Reset();
966 
967  h_gdl_gdltop_rvc_diff_all[iskim]->Reset();
968  h_gdl_comtop_rvc_diff_all[iskim]->Reset();
969 
970  h_topRvcDiff1All[iskim]->Reset();
971  h_topRvcDiff2All[iskim]->Reset();
972  h_topRvcDiff3All[iskim]->Reset();
973  h_topRvcDiff4All[iskim]->Reset();
974 
975  h_topGdlRvcDiff1All[iskim]->Reset();
976  h_topGdlRvcDiff2All[iskim]->Reset();
977  h_topGdlRvcDiff3All[iskim]->Reset();
978 
979  h_decisionNumberVsNumberDecisionsGood[iskim]->Reset();
980 
981  h_ecl_gdl_top_timing_diff_good[iskim]->Reset();
982  h_ecl_top_top_timing_diff_good[iskim]->Reset();
983 
984  h_gdl_ecltop_timing_diff_vs_toptop_good[iskim]->Reset();
985  h_top_ecltop_timing_diff_vs_toptop_good[iskim]->Reset();
986  h_gdl_ecltop_timing_diff_vs_ecltop_good[iskim]->Reset();
987 
988  h_gdl_gdltop_rvc_diff_good[iskim]->Reset();
989  h_gdl_comtop_rvc_diff_good[iskim]->Reset();
990 
991  h_topCombinedTimingTopGood[iskim]->Reset();
992  h_topNSlotsCombinedTimingTopGood[iskim]->Reset();
993  h_topNHitSumGood[iskim]->Reset();
994  h_topLogLSumGood[iskim]->Reset();
995 
996  h_topRvcDiff1Good[iskim]->Reset();
997  h_topRvcDiff2Good[iskim]->Reset();
998  h_topRvcDiff3Good[iskim]->Reset();
999  h_topRvcDiff4Good[iskim]->Reset();
1000 
1001  h_topGdlRvcDiff1Good[iskim]->Reset();
1002  h_topGdlRvcDiff2Good[iskim]->Reset();
1003  h_topGdlRvcDiff3Good[iskim]->Reset();
1004 
1005  h_decisionNumberVsNumberDecisionsBad[iskim]->Reset();
1006 
1007  h_ecl_gdl_top_timing_diff_bad[iskim]->Reset();
1008  h_ecl_top_top_timing_diff_bad[iskim]->Reset();
1009 
1010  h_gdl_ecltop_timing_diff_vs_toptop_bad[iskim]->Reset();
1011  h_top_ecltop_timing_diff_vs_toptop_bad[iskim]->Reset();
1012  h_gdl_ecltop_timing_diff_vs_ecltop_bad[iskim]->Reset();
1013 
1014  h_gdl_gdltop_rvc_diff_bad[iskim]->Reset();
1015  h_gdl_comtop_rvc_diff_bad[iskim]->Reset();
1016 
1017  h_topCombinedTimingTopBad[iskim]->Reset();
1018  h_topNSlotsCombinedTimingTopBad[iskim]->Reset();
1019  h_topNHitSumBad[iskim]->Reset();
1020  h_topLogLSumBad[iskim]->Reset();
1021 
1022  h_topRvcDiff1Bad[iskim]->Reset();
1023  h_topRvcDiff2Bad[iskim]->Reset();
1024  h_topRvcDiff3Bad[iskim]->Reset();
1025  h_topRvcDiff4Bad[iskim]->Reset();
1026 
1027  h_topGdlRvcDiff1Bad[iskim]->Reset();
1028  h_topGdlRvcDiff2Bad[iskim]->Reset();
1029  h_topGdlRvcDiff3Bad[iskim]->Reset();
1030 
1031  }
1032 
1033  h_topCombinedTimingTopAll[iskim]->Reset();
1034  h_topNSlotsCombinedTimingTopAll[iskim]->Reset();
1035  h_topNHitSumAll[iskim]->Reset();
1036  h_topLogLSumAll[iskim]->Reset();
1037 
1038  h_topNSlotsCombinedTimingVsNHitsTopAll[iskim]->Reset();
1039 
1040  h_topTrigType[iskim]->Reset();
1041  h_topTimingResiduals[iskim]->Reset();
1042  h_topTimingVariance[iskim]->Reset();
1043 
1044  h_top_nt0decisions_vs_hist_class[iskim]->Reset();
1045 
1046  h_top_gdl_match_decision_number[iskim]->Reset();
1047 
1048  h_gdl_ecltop_timing_diff_5ns[iskim]->Reset();
1049  h_gdl_cdctop_timing_diff_5ns[iskim]->Reset();
1050 
1051  h_gdl_ecltop_timing_diff_2ns[iskim]->Reset();
1052  h_gdl_ecltop_timing_diff_grl_matched_2ns[iskim]->Reset();
1053  h_gdl_ecltop_timing_diff_no_grl_matched_2ns[iskim]->Reset();
1054  h_gdl_ecltop_timing_diff_no_grl_at_all_2ns[iskim]->Reset();
1055  h_gdl_ecltop_timing_diff_vs_nslots_2ns[iskim]->Reset();
1056  h_top_ecltop_timing_diff_combined_2ns[iskim]->Reset();
1057  h_top_ecltop_timing_diff_best_slot_2ns[iskim]->Reset();
1058  h_gdl_cdctop_timing_diff_2ns[iskim]->Reset();
1059 
1060  for (int histClass = 0; histClass < m_nHistClassesActual; histClass++) {
1061  h_N_decision[iskim][histClass]->Reset();
1062 
1063  h_topNHitVsNhit[iskim][histClass]->Reset();
1064  h_topSlotVsSlot[iskim][histClass]->Reset();
1065  h_topT0VsT0[iskim][histClass]->Reset();
1066  h_topSegmentVsSegment[iskim][histClass]->Reset();
1067  h_topLogLVsLogL[iskim][histClass]->Reset();
1068  }
1069 
1070  if (m_histLevel > 1) {
1071  for (int histClass = 0; histClass < m_nHistClassesActual; histClass++) {
1072  h_topCombinedTimingTop[iskim][histClass]->Reset();
1073  h_topNSlotsCombinedTimingTop[iskim][histClass]->Reset();
1074  h_topNHitSum[iskim][histClass]->Reset();
1075  h_topNHitBestSlot[iskim][histClass]->Reset();
1076  // h_topT0DecisionNumberBestSlot[iskim][histClass]->Reset();
1077  h_topLogLSum[iskim][histClass]->Reset();
1078 
1079  h_gdl_ecltop_timing_diff_vs_slot_2ns[iskim][histClass]->Reset();
1080  h_gdl_ecltop_timing_diff_vs_segment_2ns[iskim][histClass]->Reset();
1081  h_gdl_ecltop_timing_diff_vs_nhits_2ns[iskim][histClass]->Reset();
1082  h_gdl_ecltop_timing_diff_vs_logl_2ns[iskim][histClass]->Reset();
1083 
1084  h_top_ecltop_timing_diff_2ns[iskim][histClass]->Reset();
1085  h_top_ecltop_timing_combined_diff_2ns[iskim][histClass]->Reset();
1086  h_top_ecltop_timing_best_slot_diff_2ns[iskim][histClass]->Reset();
1087 
1088  h_gdl_ecltop_timing_diff_vs_toptop[iskim][histClass]->Reset();
1089  h_top_ecltop_timing_diff_vs_toptop[iskim][histClass]->Reset();
1090 
1091  h_gdl_ecltop_timing_diff_vs_ecltop[iskim][histClass]->Reset();
1092  h_gdl_ecltop_timing_diff_vs_ecltop_best_slot[iskim][histClass]->Reset();
1093  }
1094  }
1095 
1096  h_gdl_ecltop_timing_diff_vs_slot[iskim]->Reset();
1097  h_gdl_ecltop_timing_diff_vs_segment[iskim]->Reset();
1098  h_gdl_ecltop_timing_diff_vs_nhits[iskim]->Reset();
1099  h_gdl_ecltop_timing_diff_vs_logl[iskim]->Reset();
1100 
1101  h_topTC2IdVsTC1IdAll[iskim]->Reset();
1102  h_topTC2EnergyVsTC1EnergyAll[iskim]->Reset();
1103  h_topTC2ThetaIdVsTC1ThetaIdAll[iskim]->Reset();
1104  h_topTC2PhiIdVsTC1PhiIdAll[iskim]->Reset();
1105  h_topTCPhiIdVsTCThetaIdAll[iskim]->Reset();
1106 
1107  h_topTC2IdVsTC1IdGRLAll[iskim]->Reset();
1108  h_topTC2EnergyVsTC1EnergyGRLAll[iskim]->Reset();
1109  h_topTC2ThetaIdVsTC1ThetaIdGRLAll[iskim]->Reset();
1110  h_topTC2PhiIdVsTC1PhiIdGRLAll[iskim]->Reset();
1111  h_topTCPhiIdVsTCThetaIdGRLAll[iskim]->Reset();
1112 
1113  h_topTC2IdVsTC1Id[iskim]->Reset();
1114  h_topTC2EnergyVsTC1Energy[iskim]->Reset();
1115  h_topTC2ThetaIdVsTC1ThetaId[iskim]->Reset();
1116  h_topTC2PhiIdVsTC1PhiId[iskim]->Reset();
1117  h_topTCPhiIdVsTCThetaId[iskim]->Reset();
1118 
1119  h_topTC2IdVsTC1IdGRL[iskim]->Reset();
1120  h_topTC2EnergyVsTC1EnergyGRL[iskim]->Reset();
1121  h_topTC2ThetaIdVsTC1ThetaIdGRL[iskim]->Reset();
1122  h_topTC2PhiIdVsTC1PhiIdGRL[iskim]->Reset();
1123  h_topTCPhiIdVsTCThetaIdGRL[iskim]->Reset();
1124 
1125  h_gdl_ecltop_timing_diff_vs_grl_top_l1[iskim]->Reset();
1126  h_gdl_top_l1_vs_grl_top_l1[iskim]->Reset();
1127 
1128  h_grl_ntopslots_vs_ncdcslots[iskim]->Reset();
1129  h_grl_ncdctopslots_matched[iskim]->Reset();
1130  h_grl_topslots_vs_cdcslots_match[iskim]->Reset();
1131 
1132  }
1133 
1134  oldDir->cd();
1135 }
1136 
1137 void TRGTOPDQMModule::initialize()
1138 {
1139 
1140  if (m_skim == 0) { //no skims
1141  start_skim_topdqm = 0;
1142  end_skim_topdqm = 1;
1143  } else if (m_skim == 1) { //skims
1144  start_skim_topdqm = 1;
1145  end_skim_topdqm = nskim_topdqm;
1146  } else { //no skims + skims
1147  start_skim_topdqm = 0;
1148  end_skim_topdqm = nskim_topdqm;
1149  }
1150 
1151  StoreObjPtr<EventMetaData> bevt;
1152 
1153  m_exp = -1;
1154  m_run = -1;
1155 
1156  if (bevt) {
1157  m_exp = bevt->getExperiment();
1158  m_run = bevt->getRun();
1159  }
1160 
1161  // cout << "TOP L1 DQM: begin run / exp = " << m_exp << endl;
1162  // cout << "TOP L1 DQM: begin run / run = " << m_run << endl;
1163 
1164  // m_ECLCalDigitData.registerInDataStore();
1165  // m_ECLDigitData.registerInDataStore();
1166  // trgeclmap = new TrgEclMapping();
1167 
1168  // calls back the defineHisto() function, but the HistoManager module has to be in the path
1169  REG_HISTOGRAM
1170 
1171  if (m_doGDLCorrelations) {
1172 
1173  for (int i = 0; i < 320; i++) {
1174  gdlLeafBitMap[i] = m_gdlUnpacker->getLeafMap(i);
1175  }
1176  for (int i = 0; i < 320; i++) {
1177  strcpy(gdlLeafNames[i], m_gdlUnpacker->getLeafnames(i));
1178  }
1179 
1180  gdl_e_timtype = 0;
1181  gdl_e_gdll1rvc = 0;
1182  gdl_e_coml1rvc = 0;
1183  gdl_e_toptiming = 0;
1184  gdl_e_ecltiming = 0;
1185  gdl_e_cdctiming = 0;
1186  gdl_e_toprvc = 0;
1187  gdl_e_eclrvc = 0;
1188  gdl_e_cdcrvc = 0;
1189 
1190  for (int i = 0; i < 320; i++) {
1191  if (strcmp(gdlLeafNames[i], "timtype") == 0) gdl_e_timtype = gdlLeafBitMap[i];
1192  if (strcmp(gdlLeafNames[i], "gdll1rvc") == 0) gdl_e_gdll1rvc = gdlLeafBitMap[i];
1193  if (strcmp(gdlLeafNames[i], "coml1rvc") == 0) gdl_e_coml1rvc = gdlLeafBitMap[i];
1194  if (strcmp(gdlLeafNames[i], "toptiming") == 0) gdl_e_toptiming = gdlLeafBitMap[i];
1195  if (strcmp(gdlLeafNames[i], "ecltiming") == 0) gdl_e_ecltiming = gdlLeafBitMap[i];
1196  if (strcmp(gdlLeafNames[i], "cdctiming") == 0) gdl_e_cdctiming = gdlLeafBitMap[i];
1197  if (strcmp(gdlLeafNames[i], "toprvc") == 0) gdl_e_toprvc = gdlLeafBitMap[i];
1198  if (strcmp(gdlLeafNames[i], "eclrvc") == 0) gdl_e_eclrvc = gdlLeafBitMap[i];
1199  if (strcmp(gdlLeafNames[i], "cdcrvc") == 0) gdl_e_cdcrvc = gdlLeafBitMap[i];
1200  }
1201  }
1202 
1203  // trgeclHitArray.registerInDataStore();
1204 
1205 }
1206 
1207 void TRGTOPDQMModule::endRun()
1208 {
1209  // implement saving a postscript file (for some histograms) here
1210  // use ROOT scripts as a template
1211 }
1212 
1213 void TRGTOPDQMModule::event()
1214 {
1215 
1216  StoreArray<TRGTOPUnpackerStore> trgtopCombinedTimingArray("TRGTOPUnpackerStores");
1217 
1218  if (!trgtopCombinedTimingArray) return;
1219  if (!trgtopCombinedTimingArray.getEntries()) return;
1220 
1221  // prepare histograms according to HLT decisions
1222  skim.clear();
1223 
1224  //Get skim type from SoftwareTriggerResult
1225  for (int iskim = start_skim_topdqm; iskim < end_skim_topdqm; iskim++) {
1226  if (iskim == 0) skim.push_back(iskim);
1227  }
1228 
1229  StoreObjPtr<SoftwareTriggerResult> result_soft;
1230  if (result_soft.isValid()) {
1231  const std::map<std::string, int>& skim_map = result_soft->getResults();
1232  for (int iskim = start_skim_topdqm; iskim < end_skim_topdqm; iskim++) {
1233  if (iskim == 0);
1234  else if (skim_map.find(skim_menu[iskim]) != skim_map.end()) {
1235  const bool accepted = (result_soft->getResult(skim_menu[iskim]) == SoftwareTriggerCutResult::c_accept);
1236  if (accepted) skim.push_back(iskim);
1237  }
1238  }
1239  }
1240 
1241  bool gdlInfoAvailable = false;
1242  bool grlInfoAvailable = false;
1243 
1244  // investigate GRL-TOP correlations if asked to do so
1245 
1246  int grlTOPL1 = -1;
1247 
1248  bool grlCDCSlots[16];
1249  bool grlTOPSlots[16];
1250 
1251  bool grlCDCTOPSlotsMatch[16];
1252 
1253  if (m_doGRLCorrelations) {
1254 
1255  StoreObjPtr<TRGGRLUnpackerStore> grlEventInfo("TRGGRLUnpackerStore");
1256 
1257  // make sure first that GDL information could be retrieved
1258  if (grlEventInfo) {
1259 
1260  grlInfoAvailable = true;
1261 
1262  int grlTimeL1 = grlEventInfo->m_coml1 - grlEventInfo->m_revoclk;
1263 
1264  grlTOPL1 = (grlEventInfo->m_TOPL1_count + grlTimeL1 - 0.5) * (-clk127To1ns);
1265 
1266  // Slot number -> phi (11.25 + i * 22.5)
1267  // 16 slots @ 22.5 deg = 360 deg
1268  for (int i = 0; i < 16; i++) {
1269  grlCDCSlots[i] = false;
1270  if (grlEventInfo->m_slot_CDC[i]) {
1271  grlCDCSlots[i] = true;
1272  }
1273  grlTOPSlots[i] = false;
1274  if (grlEventInfo->m_slot_TOP[i]) {
1275  grlTOPSlots[i] = true;
1276  }
1277  }
1278  }
1279  }
1280 
1281  // investigate GRL-TOP
1282  int nCDCSlotsGRL = 0;
1283  int nTOPSlotsGRL = 0;
1284  int nCDCTOPSlotsMatchedGRL = 0;
1285 
1286  if (grlInfoAvailable) {
1287  for (int i = 0; i < 16; i++) {
1288  if (grlCDCSlots[i]) nCDCSlotsGRL++;
1289  if (grlTOPSlots[i]) nTOPSlotsGRL++;
1290  grlCDCTOPSlotsMatch[i] = false;
1291  if (grlCDCSlots[i] && grlTOPSlots[i]) {
1292  nCDCTOPSlotsMatchedGRL++;
1293  grlCDCTOPSlotsMatch[i] = true;
1294  }
1295  }
1296  }
1297 
1298  // StoreArray<TRGECLUnpackerStore> trgeclHitArray;
1299 
1300  if (trgeclHitArray) {
1301 
1302  if (m_doECLCorrelations) {
1303 
1304  bool barrelEcl = false;
1305  bool barrelEclB2B = false;
1306 
1307  tcEclList.clear();
1308 
1309  // TrgEclMapping* trgEclMap = new TrgEclMapping();
1310  TrgEclMapping trgEclMap;
1311 
1312  for (int ii = 0; ii < trgeclHitArray.getEntries(); ii++) {
1313 
1314  TRGECLUnpackerStore* aTRGECLUnpackerStore = trgeclHitArray[ii];
1315  int TCID = (aTRGECLUnpackerStore->getTCId());
1316 
1317  int hit_win = aTRGECLUnpackerStore -> getHitWin();
1318  double HitEnergy = aTRGECLUnpackerStore -> getTCEnergy();
1319  double HitTiming = aTRGECLUnpackerStore ->getTCTime();
1320 
1321  if (TCID < 1 || TCID > 576 || HitEnergy == 0) {continue;}
1322  if (!(hit_win == 3 || hit_win == 4)) {continue;}
1323 
1324  tcEcl tcEclThis;
1325  tcEclThis.tcId = TCID;
1326  tcEclThis.tcEnergy = HitEnergy;
1327  tcEclThis.tcTiming = HitTiming;
1328  tcEclThis.tcThetaId = trgEclMap.getTCThetaIdFromTCId(TCID);
1329  tcEclThis.tcPhiId = trgEclMap.getTCPhiIdFromTCId(TCID);
1330  tcEclList.push_back(tcEclThis);
1331  }
1332 
1333  // sort TCs according to their energies
1334  sort(tcEclList.begin(), tcEclList.end(), largestEnergy());
1335 
1336  // Barrel TCID map:
1337  // https://confluence.desy.de/display/BI/TRGECL+Meeting?preview=%2F43899281%2F58924075%2F170630yjkim.pdf
1338  if (tcEclList.size() >= 2) {
1339  vector<tcEcl>::const_iterator it = tcEclList.begin();
1340  const tcEcl& tc1 = *it;
1341  ++it;
1342  const tcEcl& tc2 = *it;
1343  int tcId1 = tc1.tcId;
1344  int tcId2 = tc2.tcId;
1345 
1346  int tcThetaId1 = tc1.tcThetaId;
1347  int tcPhiId1 = tc1.tcPhiId;
1348 
1349  int tcThetaId2 = tc2.tcThetaId;
1350  int tcPhiId2 = tc2.tcPhiId;
1351 
1352  // poor physicist's barrel b2b
1353  // if (tcId1 >= 81 && tcId1 <= 512) {
1354  // if (tcId2 >= 81 && tcId2 <= 512) {
1355  // if (abs(tcId2-tcId1-220) <= 50) {
1356 
1357  if (tcThetaId1 >= 4 && tcThetaId1 <= 15) {
1358  barrelEcl = true;
1359  if (tcThetaId2 >= 4 && tcThetaId2 <= 15) {
1360  if (abs(tcPhiId1 - tcPhiId2) >= 12 && abs(tcPhiId1 - tcPhiId2) <= 24) {
1361  barrelEclB2B = true;
1362  }
1363  }
1364  }
1365 
1366  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1367 
1368  h_topTC2IdVsTC1IdAll[skim[ifill]]->Fill(tcId1, tcId2);
1369  h_topTC2EnergyVsTC1EnergyAll[skim[ifill]]->Fill(tc1.tcEnergy, tc2.tcEnergy);
1370  h_topTC2ThetaIdVsTC1ThetaIdAll[skim[ifill]]->Fill(tcThetaId1, tcThetaId2);
1371  h_topTC2PhiIdVsTC1PhiIdAll[skim[ifill]]->Fill(tcPhiId1, tcPhiId2);
1372  h_topTCPhiIdVsTCThetaIdAll[skim[ifill]]->Fill(tcThetaId1, tcPhiId1, 0);
1373  h_topTCPhiIdVsTCThetaIdAll[skim[ifill]]->Fill(tcThetaId2, tcPhiId2, 1);
1374 
1375  if (nCDCSlotsGRL > 0) {
1376  h_topTC2IdVsTC1IdGRLAll[skim[ifill]]->Fill(tcId1, tcId2);
1377  h_topTC2EnergyVsTC1EnergyGRLAll[skim[ifill]]->Fill(tc1.tcEnergy, tc2.tcEnergy);
1378  h_topTC2ThetaIdVsTC1ThetaIdGRLAll[skim[ifill]]->Fill(tcThetaId1, tcThetaId2);
1379  h_topTC2PhiIdVsTC1PhiIdGRLAll[skim[ifill]]->Fill(tcPhiId1, tcPhiId2);
1380  h_topTCPhiIdVsTCThetaIdGRLAll[skim[ifill]]->Fill(tcThetaId1, tcPhiId1, 0);
1381  h_topTCPhiIdVsTCThetaIdGRLAll[skim[ifill]]->Fill(tcThetaId2, tcPhiId2, 1);
1382  }
1383 
1384  if (barrelEclB2B) {
1385 
1386  h_topTC2IdVsTC1Id[skim[ifill]]->Fill(tcId1, tcId2);
1387  h_topTC2EnergyVsTC1Energy[skim[ifill]]->Fill(tc1.tcEnergy, tc2.tcEnergy);
1388  h_topTC2ThetaIdVsTC1ThetaId[skim[ifill]]->Fill(tcThetaId1, tcThetaId2);
1389  h_topTC2PhiIdVsTC1PhiId[skim[ifill]]->Fill(tcPhiId1, tcPhiId2);
1390  h_topTCPhiIdVsTCThetaId[skim[ifill]]->Fill(tcThetaId1, tcPhiId1, 0);
1391  h_topTCPhiIdVsTCThetaId[skim[ifill]]->Fill(tcThetaId2, tcPhiId2, 1);
1392  if (nCDCSlotsGRL > 0) {
1393  h_topTC2IdVsTC1IdGRL[skim[ifill]]->Fill(tcId1, tcId2);
1394  h_topTC2EnergyVsTC1EnergyGRL[skim[ifill]]->Fill(tc1.tcEnergy, tc2.tcEnergy);
1395  h_topTC2ThetaIdVsTC1ThetaIdGRL[skim[ifill]]->Fill(tcThetaId1, tcThetaId2);
1396  h_topTC2PhiIdVsTC1PhiIdGRL[skim[ifill]]->Fill(tcPhiId1, tcPhiId2);
1397  h_topTCPhiIdVsTCThetaIdGRL[skim[ifill]]->Fill(tcThetaId1, tcPhiId1, 0);
1398  h_topTCPhiIdVsTCThetaIdGRL[skim[ifill]]->Fill(tcThetaId2, tcPhiId2, 1);
1399  }
1400  }
1401  }
1402  }
1403 
1404  if (m_requireEclBarrel) {
1405  if (!barrelEcl) return;
1406  }
1407  if (m_requireEclBarrelB2B) {
1408  if (!barrelEclB2B) return;
1409  }
1410  }
1411 
1412  }
1413 
1414  if (m_doGRLCorrelations && grlInfoAvailable) {
1415  if (m_requireCDC2DTrack) {
1416  if (nCDCSlotsGRL <= 0) return;
1417  }
1418  }
1419 
1420  if (grlInfoAvailable) {
1421 
1422  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1423 
1424  h_grl_ntopslots_vs_ncdcslots[skim[ifill]]->Fill(nCDCSlotsGRL, nTOPSlotsGRL);
1425 
1426  h_grl_ncdctopslots_matched[skim[ifill]]->Fill(nCDCTOPSlotsMatchedGRL);
1427 
1428  for (int i = 0; i < 16; i++) {
1429  if (grlCDCTOPSlotsMatch[i]) {
1430  h_grl_topslots_vs_cdcslots_match[skim[ifill]]->Fill(i + 1, i + 1);
1431  } else if (grlCDCSlots[i]) {
1432  h_grl_topslots_vs_cdcslots_match[skim[ifill]]->Fill(i + 1, 0.);
1433  } else if (grlTOPSlots[i]) {
1434  h_grl_topslots_vs_cdcslots_match[skim[ifill]]->Fill(0., i + 1);
1435  }
1436  }
1437  }
1438  }
1439 
1440  // normally this should not be happening
1441  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1442  if (nCDCSlotsGRL == 0 && nTOPSlotsGRL == 0) h_grl_topslots_vs_cdcslots_match[skim[ifill]]->Fill(0., 0.);
1443  }
1444 
1445  /*
1446  cout << "DEBUG---------------------------------------------------------------------------------------------------------------------" << endl;
1447  int j=0;
1448  for ( vector<tcEcl>::const_iterator it = tcEclList.begin(); it != tcEclList.end(); ++it) {
1449  j++;
1450  const tcEcl& tc = *it;
1451  cout << "DEBUG index, tcId, tcEnergy, tcTiming = " << j << ", " << tc.tcId << ", " << tc.tcEnergy << ", " << tc.tcTiming << endl;
1452  }
1453  cout << "DEBUG---------------------------------------------------------------------------------------------------------------------" << endl;
1454  */
1455 
1456  // investigate GDL-TOP correlations if asked to do so
1457 
1458  // There are 5 values of revolution counter which could be obtained from GDL L1 data packet
1459  // Most important (from TOP L1 perspective) are gdll1rvc and toprvc
1460  int gdl_gdll1rvc = -1;
1461  int gdl_coml1rvc = -1;
1462  int gdl_toprvc = -1;
1463  int gdl_eclrvc = -1;
1464  int gdl_cdcrvc = -1;
1465 
1466  int gdl_top_timing = -1;
1467  int gdl_ecl_timing = -1;
1468  int gdl_cdc_timing = -1;
1469 
1470  // obtain various important information about GDL decision from the database
1471  if (m_doGDLCorrelations) {
1472 
1473  // make sure first that GDL information could be retrieved
1474  if (m_gdlUnpacker) {
1475 
1476  /*
1477  int N_track = evtinfo->getEventIdL1();
1478  int bin = h_N_track->GetBinContent(N_track + 1);
1479  h_N_track->SetBinContent(N_track + 1, bin + 1);
1480  */
1481 
1482  int n_leafs = m_gdlUnpacker->getnLeafs();
1483  int n_leafsExtra = m_gdlUnpacker->getnLeafsExtra();
1484  int n_clocks = m_gdlUnpacker->getnClks();
1485  // int nconf = m_gdlUnpacker->getconf();
1486 
1487  // int nword_input = m_gdlUnpacker->get_nword_input();
1488  // int nword_output = m_gdlUnpacker->get_nword_output();
1489 
1490  StoreArray<TRGGDLUnpackerStore> entAry;
1491  if (entAry && entAry.getEntries()) {
1492 
1493  m_evtno = 0;
1494 
1495  //prepare entAry address
1496  int clk_map = 0;
1497  for (int i = 0; i < 320; i++) {
1498  if (strcmp(entAry[0]->m_unpackername[i], "evt") == 0) m_evtno = entAry[0]->m_unpacker[i];
1499  if (strcmp(entAry[0]->m_unpackername[i], "clk") == 0) clk_map = i;
1500  }
1501 
1502  // cout << "TOP L1 DQM GDL event number = " << m_evtno << endl;
1503 
1504  std::vector<std::vector<int> > _data(n_leafs + n_leafsExtra);
1505  for (int leaf = 0; leaf < n_leafs + n_leafsExtra; leaf++) {
1506  std::vector<int> _v(n_clocks);
1507  _data[leaf] = _v;
1508  }
1509 
1510  // fill "bit vs clk" for the event
1511  for (int ii = 0; ii < entAry.getEntries(); ii++) {
1512  std::vector<int*> Bits(n_leafs + n_leafsExtra);
1513  //set pointer
1514  for (int i = 0; i < 320; i++) {
1515  if (gdlLeafBitMap[i] != -1) {
1516  Bits[gdlLeafBitMap[i]] = &(entAry[ii]->m_unpacker[i]);
1517  }
1518  }
1519  for (int leaf = 0; leaf < n_leafs + n_leafsExtra; leaf++) {
1520  _data[leaf][entAry[ii]->m_unpacker[clk_map]] = *Bits[leaf];
1521  }
1522 
1523  }
1524 
1525  gdl_gdll1rvc = _data[gdl_e_gdll1rvc][n_clocks - 1];
1526  gdl_coml1rvc = _data[gdl_e_coml1rvc][n_clocks - 1];
1527  gdl_toprvc = _data[gdl_e_toprvc][n_clocks - 1];
1528  gdl_eclrvc = _data[gdl_e_eclrvc][n_clocks - 1];
1529  gdl_cdcrvc = _data[gdl_e_cdcrvc][n_clocks - 1];
1530  gdl_top_timing = _data[gdl_e_toptiming][n_clocks - 1];
1531  gdl_ecl_timing = _data[gdl_e_ecltiming][n_clocks - 1];
1532  gdl_cdc_timing = _data[gdl_e_cdctiming][n_clocks - 1];
1533 
1534  gdlInfoAvailable = true;
1535 
1536  /*
1537  if (begin_run) {
1538  B2DEBUG(20, "nconf(" << nconf
1539  << "), n_clocks(" << n_clocks
1540  << "), n_leafs(" << n_leafs
1541  << "), n_leafsExtra(" << n_leafsExtra
1542  << ")");
1543  begin_run = false;
1544  }
1545  */
1546 
1547  /*
1548  cout << " " << endl;
1549  cout << "TOP L1 DQM gdl L1 rvc = " << gdl_gdll1rvc << endl;
1550  cout << "TOP L1 DQM com L1 rvc = " << gdl_coml1rvc << endl;
1551  cout << "TOP L1 DQM top L1 rvc = " << gdl_toprvc << endl;
1552  cout << "TOP L1 DQM ecl L1 rvc = " << gdl_eclrvc << endl;
1553  cout << "TOP L1 DQM cdc L1 rvc = " << gdl_cdcrvc << endl;
1554  */
1555 
1556  }
1557  }
1558  }
1559 
1560  //
1561  //--------------------------------------------- actual histogramming starts here ----------------------------------------------------
1562  //
1563  // Very generally, many (but not all) TOP L1 DQM histograms could be separated into three mutually exclusive classes according to
1564  // the agreement between TOP information in GDL data packet and TOP information in TOP L1 data packet (i.e. circular buffer (CB)):
1565  //
1566  // 1) class 0: TOP information at GDL and at TOP (in the FIRST decision stored in TOP L1 CB) is the same
1567  // 2) class 1: There are NO TOP combined decision in TOP L1 CB that agree with TOP information at GDL
1568  // 3) class 2: TOP information at GDL and at TOP is different for all but one combined decision (but not first),
1569  // there could be more than one such combined t0 decision in TOP L1 CB
1570  //
1571  // When GDL information is unavailable (is NEVER supposed to happen!), all events are labeled as class 1 (just to be safe)
1572  //
1573  // Histograms for different types of events (according to software trigger) are prepared for each of the three classes.
1574  // In addition to these histograms there are also a number of other histograms which are prepared for all combined decisions in TOP L1 CB
1575  // or/and for GDL TOP information (and for TOP-ECL, TOP-GRL and TOP-GDL correlations).
1576  //
1577 
1578  // info from GDL
1579 
1580  int ecl_top_timing_diff = -1;
1581  int cdc_top_timing_diff = -1;
1582 
1583  int gdl_top_rvc_diff = -1;
1584  int com_top_rvc_diff = -1;
1585  int ecl_top_rvc_diff = -1;
1586  int cdc_top_rvc_diff = -1;
1587 
1588  if (gdlInfoAvailable) {
1589 
1590  ecl_top_timing_diff = gdl_ecl_timing >= gdl_top_timing ? gdl_ecl_timing - gdl_top_timing : gdl_ecl_timing - gdl_top_timing +
1591  10240;
1592  cdc_top_timing_diff = gdl_cdc_timing >= gdl_top_timing ? gdl_cdc_timing - gdl_top_timing : gdl_cdc_timing - gdl_top_timing +
1593  10240;
1594 
1595  gdl_top_rvc_diff = gdl_gdll1rvc >= gdl_toprvc ? gdl_gdll1rvc - gdl_toprvc : gdl_gdll1rvc - gdl_toprvc + 1280;
1596  com_top_rvc_diff = gdl_coml1rvc >= gdl_toprvc ? gdl_coml1rvc - gdl_toprvc : gdl_coml1rvc - gdl_toprvc + 1280;
1597  ecl_top_rvc_diff = gdl_eclrvc >= gdl_toprvc ? gdl_eclrvc - gdl_toprvc : gdl_eclrvc - gdl_toprvc + 1280;
1598  cdc_top_rvc_diff = gdl_cdcrvc >= gdl_toprvc ? gdl_cdcrvc - gdl_toprvc : gdl_cdcrvc - gdl_toprvc + 1280;
1599 
1600  }
1601 
1602  int histClass = 1;
1603 
1604  // retrieve TOP L1 information
1605 
1606  int nT0Decisions = trgtopCombinedTimingArray.getEntries();
1607 
1608  int t0DecisionNumber = 0;
1609 
1610  if (gdlInfoAvailable) {
1611 
1612  int nInTime = 0;
1613 
1614  for (const auto& t0Decision : trgtopCombinedTimingArray) {
1615  int topCombinedTimingTop = t0Decision.getCombinedTimingTop();
1616  int top_top_timing = (topCombinedTimingTop % 10240);
1617 
1618  if (gdl_top_timing == top_top_timing) {
1619  nInTime++;
1620  if (t0DecisionNumber == 0) {
1621  histClass = 0;
1622  } else if (histClass != 0) {
1623  histClass = 2;
1624  }
1625  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1626  h_top_gdl_match_decision_number[skim[ifill]]->Fill(t0DecisionNumber + 1);
1627  }
1628  }
1629  t0DecisionNumber++;
1630  }
1631 
1632  // classification of events according to the three classes described previously
1633  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1634  h_top_nt0decisions_vs_hist_class[skim[ifill]]->Fill(histClass, nT0Decisions);
1635  }
1636 
1637  // ALL TOP t0 decisions made within the last us before GDL L1 decision are out of time with GDL L1!
1638  if (nInTime == 0) {
1639  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1640  h_top_gdl_match_decision_number[skim[ifill]]->Fill(0);
1641  }
1642  }
1643  }
1644 
1645  // in such case we do NOT distinguish among the three classes
1646  if (m_nHistClassesActual == 1) histClass = 0;
1647 
1648  // when histClass==2 is not requested, combined it with histClass==1
1649  if (m_nHistClassesActual == 2 && histClass == 2) histClass = 1;
1650 
1651  // prepare histograms for TOP alone
1652  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1653  h_N_decision[skim[ifill]][histClass]->Fill(nT0Decisions);
1654  }
1655 
1656  // info from GDL
1657 
1658  if (gdlInfoAvailable) {
1659 
1660  // const double clkTo1ns = 0.5 / .508877;
1661  // Feb. 23, 2020 ecltopdiff = (int) ( (double) ecltopdiff * clkTo1ns);
1662 
1663  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1664 
1665  if (m_histLevel > 2) {
1666 
1667  int gdl_top_timing_1280 = gdl_top_timing >> 3;
1668  h_gdl_top_rvc_vs_top_timing[skim[ifill]]->Fill(gdl_top_timing_1280, gdl_toprvc);
1669 
1670  h_gdl_ecltop_rvc_diff[skim[ifill]]->Fill(ecl_top_rvc_diff);
1671  h_gdl_cdctop_rvc_diff[skim[ifill]]->Fill(cdc_top_rvc_diff);
1672 
1673  h_gdl_gdltop_rvc_diff_all[skim[ifill]]->Fill(gdl_top_rvc_diff);
1674  h_gdl_comtop_rvc_diff_all[skim[ifill]]->Fill(com_top_rvc_diff);
1675  }
1676 
1677  if (grlInfoAvailable) {
1678  h_gdl_ecltop_timing_diff_vs_grl_top_l1[skim[ifill]]->Fill(grlTOPL1, ecl_top_timing_diff);
1679  }
1680 
1681  h_gdl_ecltop_timing_diff_5ns[skim[ifill]]->Fill(ecl_top_timing_diff);
1682  h_gdl_cdctop_timing_diff_5ns[skim[ifill]]->Fill(cdc_top_timing_diff);
1683 
1684  h_gdl_ecltop_timing_diff_2ns[skim[ifill]]->Fill(ecl_top_timing_diff);
1685 
1686  if (nCDCTOPSlotsMatchedGRL > 0) {
1687  h_gdl_ecltop_timing_diff_grl_matched_2ns[skim[ifill]]->Fill(ecl_top_timing_diff);
1688  } else if (nCDCSlotsGRL > 0) {
1689  h_gdl_ecltop_timing_diff_no_grl_matched_2ns[skim[ifill]]->Fill(ecl_top_timing_diff);
1690  } else {
1691  h_gdl_ecltop_timing_diff_no_grl_at_all_2ns[skim[ifill]]->Fill(ecl_top_timing_diff);
1692  }
1693  h_gdl_cdctop_timing_diff_2ns[skim[ifill]]->Fill(cdc_top_timing_diff);
1694 
1695  }
1696  }
1697 
1698  // note that now we are going to inspect all decisions in 1us TOP CB, however, most of the time we will be interested in the first decision only
1699 
1700  t0DecisionNumber = 0;
1701 
1702  for (const auto& t0Decision : trgtopCombinedTimingArray) {
1703 
1704  bool top_timing_same = false;
1705  if (gdlInfoAvailable) {
1706  int topCombinedTimingTop = t0Decision.getCombinedTimingTop();
1707  int top_top_timing = (topCombinedTimingTop % 10240);
1708  if (top_top_timing == gdl_top_timing) {
1709  top_timing_same = true;
1710  }
1711  }
1712 
1713  // not possible const vector<Belle2::TRGTOPSlotTiming> t0DecisionSlots = t0Decision.getSlotTimingDecisions();
1714  const vector<Belle2::TRGTOPSlotTiming> t0DecisionSlots = trgtopCombinedTimingArray[t0DecisionNumber]->getSlotTimingDecisions();
1715 
1716  slotDecisionList.clear();
1717 
1718  if (t0DecisionNumber == 0) {
1719 
1720  for (const auto& t0DecisionSlot : t0DecisionSlots) {
1721 
1722  int slot = t0DecisionSlot.getSlotId();
1723  int segment = t0DecisionSlot.getSlotSegment();
1724  int nHits = t0DecisionSlot.getSlotNHits();
1725  int logL = t0DecisionSlot.getSlotLogL();
1726  int t0 = t0DecisionSlot.getSlotTiming();
1727 
1728  // Note that slotDecisionList is prepared for all TOP combined t0 decisions
1729  slotDecision slotDecisionThis;
1730  slotDecisionThis.slot = slot;
1731  slotDecisionThis.segment = segment;
1732  slotDecisionThis.nHits = nHits;
1733  slotDecisionThis.logL = logL;
1734  slotDecisionThis.t0 = t0;
1735  slotDecisionList.push_back(slotDecisionThis);
1736 
1737  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1738 
1739  h_topSlotAll[skim[ifill]]->Fill(slot);
1740  h_topSegmentAll[skim[ifill]]->Fill(segment);
1741  h_topNHitsAll[skim[ifill]]->Fill(nHits);
1742  h_topLogLAll[skim[ifill]]->Fill(logL);
1743  h_topT0All[skim[ifill]]->Fill(t0);
1744 
1745  // note that the histograms in this section are for ALL combined decisions from 1us circular buffer
1746  if (gdlInfoAvailable) {
1747  int top_top_timing_slot = (t0 % 10240);
1748  int top_gdl_timing_diff_slot = gdl_ecl_timing >= top_top_timing_slot ? gdl_ecl_timing - top_top_timing_slot : gdl_ecl_timing -
1749  top_top_timing_slot + 10240;
1750 
1751  h_gdl_ecltop_timing_diff_vs_slot[skim[ifill]]->Fill(top_gdl_timing_diff_slot, slot);
1752  h_gdl_ecltop_timing_diff_vs_segment[skim[ifill]]->Fill(top_gdl_timing_diff_slot, segment);
1753  h_gdl_ecltop_timing_diff_vs_nhits[skim[ifill]]->Fill(top_gdl_timing_diff_slot, nHits);
1754  h_gdl_ecltop_timing_diff_vs_logl[skim[ifill]]->Fill(top_gdl_timing_diff_slot, logL);
1755 
1756  if (m_histLevel > 1) {
1757  h_gdl_ecltop_timing_diff_vs_slot_2ns[skim[ifill]][histClass]->Fill(top_gdl_timing_diff_slot, slot);
1758  h_gdl_ecltop_timing_diff_vs_segment_2ns[skim[ifill]][histClass]->Fill(top_gdl_timing_diff_slot, segment);
1759  h_gdl_ecltop_timing_diff_vs_nhits_2ns[skim[ifill]][histClass]->Fill(top_gdl_timing_diff_slot, nHits);
1760  h_gdl_ecltop_timing_diff_vs_logl_2ns[skim[ifill]][histClass]->Fill(top_gdl_timing_diff_slot, logL);
1761  }
1762  }
1763 
1764  if (slot >= 1 && slot <= 16) {
1765  if (segment >= 1 && segment <= 10) {
1766  h_topSlotSegment[skim[ifill]][slot - 1]->Fill(segment);
1767  h_topSlotNHits[skim[ifill]][slot - 1]->Fill(nHits);
1768  h_topSlotLogL[skim[ifill]][slot - 1]->Fill(logL);
1769  h_topSlotT0[skim[ifill]][slot - 1]->Fill(t0);
1770 
1771  h_topSlotVsSegment[skim[ifill]]->Fill(segment, slot);
1772 
1773  h_topSlotVsNHits[skim[ifill]]->Fill(nHits, slot);
1774  h_topSlotVsLogL[skim[ifill]]->Fill(logL, slot);
1775  h_topSlotVsT0[skim[ifill]]->Fill(t0, slot);
1776 
1777  h_topSegmentVsNHits[skim[ifill]]->Fill(nHits, segment);
1778  h_topSegmentVsLogL[skim[ifill]]->Fill(logL, segment);
1779  h_topSegmentVsT0[skim[ifill]]->Fill(t0, segment);
1780 
1781  h_topNHitsVsLogL[skim[ifill]]->Fill(logL, nHits);
1782  h_topNHitsVsT0[skim[ifill]]->Fill(t0, nHits);
1783  h_topLogLVsT0[skim[ifill]]->Fill(t0, logL);
1784 
1785  }
1786  }
1787  }
1788  }
1789  }
1790 
1791  //
1792  // This is the complete information from the slot with the largest N hits
1793  // associated with the TOP combined t0 decision within 1us before GDL L1
1794  // where TOP timing in TOP data packet is the same as TOP timing in GDL data packet
1795  //
1796 
1797  int nHitsSlotBest = 0;
1798  int t0SlotBest = -1;
1799 
1800  // slotDecisionList should always be available
1801  if (slotDecisionList.size() > 0) {
1802 
1803  int slotSlotBest = 0;
1804  int segmentSlotBest = 0;
1805  int logLSlotBest = 0;
1806 
1807  // sort slots according to their nHits
1808  sort(slotDecisionList.begin(), slotDecisionList.end(), largestNHits());
1809 
1810  vector<slotDecision>::const_iterator it = slotDecisionList.begin();
1811  const slotDecision& slotDecisionBest = *it;
1812 
1813  slotSlotBest = slotDecisionBest.slot;
1814  segmentSlotBest = slotDecisionBest.segment;
1815  logLSlotBest = slotDecisionBest.logL;
1816  nHitsSlotBest = slotDecisionBest.nHits;
1817  t0SlotBest = slotDecisionBest.t0;
1818 
1819  if (slotDecisionList.size() > 1) {
1820  ++it;
1821  const slotDecision& slotDecisionBest2 = *it;
1822 
1823  int slotSlotBest2 = slotDecisionBest2.slot;
1824  int segmentSlotBest2 = slotDecisionBest2.segment;
1825  int logLSlotBest2 = slotDecisionBest2.logL;
1826  int nHitsSlotBest2 = slotDecisionBest2.nHits;
1827  int t0SlotBest2 = slotDecisionBest2.t0;
1828 
1829  if (t0DecisionNumber == 0) {
1830  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1831  h_topNHitVsNhit[skim[ifill]][histClass]->Fill(nHitsSlotBest, nHitsSlotBest2);
1832  h_topSlotVsSlot[skim[ifill]][histClass]->Fill(slotSlotBest, slotSlotBest2);
1833  h_topT0VsT0[skim[ifill]][histClass]->Fill(t0SlotBest, t0SlotBest2);
1834  h_topSegmentVsSegment[skim[ifill]][histClass]->Fill(segmentSlotBest, segmentSlotBest2);
1835  h_topLogLVsLogL[skim[ifill]][histClass]->Fill(logLSlotBest, logLSlotBest2);
1836  }
1837  }
1838  }
1839  }
1840 
1841 
1842  // if (slotDecisionList.size() > 1) {
1843  //
1844  // cout << "DEBUG: more than one slot: " << slotDecisionList.size() <<endl;
1845  // cout << "DEBUG: nHitsSlotBest: " << nHitsSlotBest << endl;
1846  //
1847  // for ( vector<slotDecision>::const_iterator it = slotDecisionList.begin(); it != slotDecisionList.end(); ++it) {
1848  // const slotDecision& slotDecisionThis = *it;
1849  // cout << "DEBUG slotDecisionThis nHits = " << slotDecisionThis.nHits << endl;
1850  // }
1851  //
1852  // }
1853 
1854  // int topEventIdL1 = t0Decision.getEventIdL1();
1855  // int topEventIdTOP = t0Decision.getEventIdTOP();
1856  // int topWindowIdTOP = t0Decision.getWindowIdTOP();
1857 
1858  // There are 5 values of revolution counter available for each TOP L1 combined t0 decision
1859  // timestamp when received L1 from GDL
1860  int topRvcL1 = t0Decision.getRvcB2L();
1861  // timestamp of the circular buffer window containing given combined t0 decision (this is the "NOW" time)
1862  int topRvcWindow = t0Decision.getRvcWindow();
1863  // timestamp of PREVIOUS combined t0 decision
1864  int topRvcTopTimingDecisionPrev = t0Decision.getRvcTopTimingDecisionPrev();
1865  // timestamp of the current combined t0 decision (i.e. decision in the current window)
1866  int topRvcTopTimingDecisionNow = t0Decision.getRvcTopTimingDecisionNow();
1867  // timestamp of when the current combined t0 decision was posted to GDL
1868  int topRvcTopTimingDecisionNowGdl = t0Decision.getRvcTopTimingDecisionNowGdl();
1869 
1870  // int trigType = t0Decision.getTrigType();
1871  // cout << "DEBUG trigType = " << trigType << endl;
1872 
1873  int topCombinedTimingTop = t0Decision.getCombinedTimingTop();
1874 
1875  int topNSlotsCombinedTimingTop = t0Decision.getNSlotsCombinedTimingTop();
1876  int topCombinedTimingTopResidual = t0Decision.getCombinedTimingTopResidual();
1877  // int topNErrorsMinor = t0Decision.getNErrorsMinor();
1878  // int topNErrorsMajor = t0Decision.getNErrorsMajor();
1879  int topTrigType = t0Decision.getTrigType();
1880  int topNHitSum = t0Decision.getNHitSum();
1881  int topLogLSum = t0Decision.getLogLSum();
1882  // int topLogLVar = t0Decision.getLogLVar();
1883  int topTimingVar = t0Decision.getTimingVar();
1884 
1885  float hitsPerSlot = topNHitSum / max(1, topNSlotsCombinedTimingTop);
1886  float logLPerSlot = topLogLSum / max(1, topNSlotsCombinedTimingTop);
1887 
1888  int topRvcDiff1 = topRvcTopTimingDecisionNowGdl - topRvcTopTimingDecisionNow;
1889  int topRvcDiff2 = topRvcTopTimingDecisionNow >= topRvcTopTimingDecisionPrev ? topRvcTopTimingDecisionNow -
1890  topRvcTopTimingDecisionPrev : topRvcTopTimingDecisionNow - topRvcTopTimingDecisionPrev + 1280;
1891  int topRvcDiff3 = topRvcWindow >= topRvcTopTimingDecisionNow ? topRvcWindow - topRvcTopTimingDecisionNow : topRvcWindow -
1892  topRvcTopTimingDecisionNow + 1280;
1893  int topRvcDiff4 = topRvcL1 >= topRvcTopTimingDecisionNow ? topRvcL1 - topRvcTopTimingDecisionNow : topRvcL1 -
1894  topRvcTopTimingDecisionNow + 1280;
1895 
1896  if (t0DecisionNumber == 0) {
1897 
1898  if (grlInfoAvailable) {
1899  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1900  h_gdl_top_l1_vs_grl_top_l1[skim[ifill]]->Fill(grlTOPL1, topRvcDiff4);
1901  }
1902  }
1903 
1904  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1905 
1906  h_topCombinedTimingTopAll[skim[ifill]]->Fill(topCombinedTimingTop);
1907  h_topNSlotsCombinedTimingTopAll[skim[ifill]]->Fill(topNSlotsCombinedTimingTop);
1908  h_topNHitSumAll[skim[ifill]]->Fill((int) hitsPerSlot);
1909  h_topLogLSumAll[skim[ifill]]->Fill((int) logLPerSlot);
1910 
1911  h_topNSlotsCombinedTimingVsNHitsTopAll[skim[ifill]]->Fill(topNHitSum, topNSlotsCombinedTimingTop);
1912 
1913  h_topTrigType[skim[ifill]]->Fill(topTrigType);
1914  h_topTimingResiduals[skim[ifill]]->Fill(topCombinedTimingTopResidual);
1915  h_topTimingVariance[skim[ifill]]->Fill(topTimingVar);
1916 
1917  if (m_histLevel > 2) {
1918  h_topRvcDiff1All[skim[ifill]]->Fill(topRvcDiff1);
1919  h_topRvcDiff2All[skim[ifill]]->Fill(topRvcDiff2);
1920  h_topRvcDiff3All[skim[ifill]]->Fill(topRvcDiff3);
1921  h_topRvcDiff4All[skim[ifill]]->Fill(topRvcDiff4);
1922  }
1923  }
1924  }
1925 
1926  int topGdlRvcDiff1 = gdl_gdll1rvc >= topRvcL1 ? gdl_gdll1rvc - topRvcL1 : gdl_gdll1rvc - topRvcL1 + 1280;
1927  int topGdlRvcDiff2 = gdl_toprvc >= topRvcTopTimingDecisionNow ? gdl_toprvc - topRvcTopTimingDecisionNow : gdl_toprvc -
1928  topRvcTopTimingDecisionNow + 1280;
1929  int topGdlRvcDiff3 = gdl_toprvc >= topRvcTopTimingDecisionPrev ? gdl_toprvc - topRvcTopTimingDecisionPrev : gdl_toprvc -
1930  topRvcTopTimingDecisionPrev + 1280;
1931 
1932  int ecl_gdl_top_timing_combined_diff = -1;
1933 
1934  int top_top_timing_combined_diff = -1;
1935 
1936  int ecl_top_top_timing_combined_diff = -1;
1937  int ecl_top_top_timing_best_slot_diff = -1;
1938 
1939  if (gdlInfoAvailable) {
1940 
1941  int top_top_timing_combined = -1;
1942  int top_top_timing_best_slot = -1;
1943 
1944  ecl_gdl_top_timing_combined_diff = gdl_ecl_timing >= gdl_top_timing ? gdl_ecl_timing - gdl_top_timing : gdl_ecl_timing -
1945  gdl_top_timing + 10240;
1946 
1947  top_top_timing_combined = (topCombinedTimingTop % 10240);
1948  top_top_timing_best_slot = (t0SlotBest % 10240);
1949 
1950  top_top_timing_combined_diff = top_top_timing_combined >= gdl_top_timing ? top_top_timing_combined - gdl_top_timing :
1951  top_top_timing_combined - gdl_top_timing + 10240;
1952 
1953  ecl_top_top_timing_combined_diff = gdl_ecl_timing >= top_top_timing_combined ? gdl_ecl_timing - top_top_timing_combined :
1954  gdl_ecl_timing - top_top_timing_combined + 10240;
1955  ecl_top_top_timing_best_slot_diff = gdl_ecl_timing >= top_top_timing_best_slot ? gdl_ecl_timing - top_top_timing_best_slot :
1956  gdl_ecl_timing - top_top_timing_best_slot + 10240;
1957 
1958  if (t0DecisionNumber == 0) {
1959  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1960  if (m_histLevel > 2) {
1961  h_topGdlRvcDiff1All[skim[ifill]]->Fill(topGdlRvcDiff1);
1962  h_topGdlRvcDiff2All[skim[ifill]]->Fill(topGdlRvcDiff2);
1963  h_topGdlRvcDiff3All[skim[ifill]]->Fill(topGdlRvcDiff3);
1964  }
1965 
1966  h_ecl_gdl_top_timing_diff_both[skim[ifill]]->Fill(ecl_gdl_top_timing_combined_diff);
1967  h_ecl_top_top_timing_diff_both[skim[ifill]]->Fill(ecl_top_top_timing_combined_diff);
1968  }
1969  }
1970 
1971  if (m_histLevel > 2) {
1972 
1973  // something odd is going on...
1974  if (top_top_timing_combined_diff == 0) {
1975 
1976  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
1977 
1978  h_decisionNumberVsNumberDecisionsGood[skim[ifill]]->Fill(nT0Decisions, t0DecisionNumber + 1);
1979 
1980  if (t0DecisionNumber == 0) {
1981 
1982  h_ecl_gdl_top_timing_diff_good[skim[ifill]]->Fill(ecl_gdl_top_timing_combined_diff);
1983  h_ecl_top_top_timing_diff_good[skim[ifill]]->Fill(ecl_top_top_timing_combined_diff);
1984 
1985  h_gdl_ecltop_timing_diff_vs_toptop_good[skim[ifill]]->Fill(ecl_gdl_top_timing_combined_diff, top_top_timing_combined_diff);
1986  h_top_ecltop_timing_diff_vs_toptop_good[skim[ifill]]->Fill(ecl_top_top_timing_combined_diff, top_top_timing_combined_diff);
1987  h_gdl_ecltop_timing_diff_vs_ecltop_good[skim[ifill]]->Fill(ecl_gdl_top_timing_combined_diff, ecl_top_top_timing_combined_diff);
1988 
1989  h_topCombinedTimingTopGood[skim[ifill]]->Fill(topCombinedTimingTop);
1990  h_topNSlotsCombinedTimingTopGood[skim[ifill]]->Fill(topNSlotsCombinedTimingTop);
1991  h_topNHitSumGood[skim[ifill]]->Fill((int) hitsPerSlot);
1992  h_topLogLSumGood[skim[ifill]]->Fill((int) logLPerSlot);
1993 
1994  h_topRvcDiff1Good[skim[ifill]]->Fill(topRvcDiff1);
1995  h_topRvcDiff2Good[skim[ifill]]->Fill(topRvcDiff2);
1996  h_topRvcDiff3Good[skim[ifill]]->Fill(topRvcDiff3);
1997  h_topRvcDiff4Good[skim[ifill]]->Fill(topRvcDiff4);
1998 
1999  h_topGdlRvcDiff1Good[skim[ifill]]->Fill(topGdlRvcDiff1);
2000  h_topGdlRvcDiff2Good[skim[ifill]]->Fill(topGdlRvcDiff2);
2001  h_topGdlRvcDiff3Good[skim[ifill]]->Fill(topGdlRvcDiff3);
2002 
2003  h_gdl_gdltop_rvc_diff_good[skim[ifill]]->Fill(gdl_top_rvc_diff);
2004  h_gdl_comtop_rvc_diff_good[skim[ifill]]->Fill(com_top_rvc_diff);
2005  }
2006  }
2007  } else {
2008 
2009  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
2010 
2011  h_decisionNumberVsNumberDecisionsBad[skim[ifill]]->Fill(nT0Decisions, t0DecisionNumber + 1);
2012 
2013  if (t0DecisionNumber == 0) {
2014  h_ecl_gdl_top_timing_diff_bad[skim[ifill]]->Fill(ecl_gdl_top_timing_combined_diff);
2015  h_ecl_top_top_timing_diff_bad[skim[ifill]]->Fill(ecl_top_top_timing_combined_diff);
2016 
2017  h_gdl_ecltop_timing_diff_vs_toptop_bad[skim[ifill]]->Fill(ecl_gdl_top_timing_combined_diff, top_top_timing_combined_diff);
2018  h_top_ecltop_timing_diff_vs_toptop_bad[skim[ifill]]->Fill(ecl_top_top_timing_combined_diff, top_top_timing_combined_diff);
2019  h_gdl_ecltop_timing_diff_vs_ecltop_bad[skim[ifill]]->Fill(ecl_gdl_top_timing_combined_diff, ecl_top_top_timing_combined_diff);
2020 
2021  h_topCombinedTimingTopBad[skim[ifill]]->Fill(topCombinedTimingTop);
2022  h_topNSlotsCombinedTimingTopBad[skim[ifill]]->Fill(topNSlotsCombinedTimingTop);
2023  h_topNHitSumBad[skim[ifill]]->Fill((int) hitsPerSlot);
2024  h_topLogLSumBad[skim[ifill]]->Fill((int) logLPerSlot);
2025 
2026  h_topRvcDiff1Bad[skim[ifill]]->Fill(topRvcDiff1);
2027  h_topRvcDiff2Bad[skim[ifill]]->Fill(topRvcDiff2);
2028  h_topRvcDiff3Bad[skim[ifill]]->Fill(topRvcDiff3);
2029  h_topRvcDiff4Bad[skim[ifill]]->Fill(topRvcDiff4);
2030 
2031  h_topGdlRvcDiff1Bad[skim[ifill]]->Fill(topGdlRvcDiff1);
2032  h_topGdlRvcDiff2Bad[skim[ifill]]->Fill(topGdlRvcDiff2);
2033  h_topGdlRvcDiff3Bad[skim[ifill]]->Fill(topGdlRvcDiff3);
2034 
2035  h_gdl_gdltop_rvc_diff_bad[skim[ifill]]->Fill(gdl_top_rvc_diff);
2036  h_gdl_comtop_rvc_diff_bad[skim[ifill]]->Fill(com_top_rvc_diff);
2037  }
2038  }
2039  }
2040  }
2041  }
2042 
2043  if (t0DecisionNumber == 0) {
2044  for (unsigned ifill = 0; ifill < skim.size(); ifill++) {
2045 
2046  if (m_histLevel > 1) {
2047  if (gdlInfoAvailable) {
2048  h_gdl_ecltop_timing_diff_vs_toptop[skim[ifill]][histClass]->Fill(ecl_gdl_top_timing_combined_diff, top_top_timing_combined_diff);
2049  h_top_ecltop_timing_diff_vs_toptop[skim[ifill]][histClass]->Fill(ecl_top_top_timing_combined_diff, top_top_timing_combined_diff);
2050  h_gdl_ecltop_timing_diff_vs_ecltop[skim[ifill]][histClass]->Fill(ecl_gdl_top_timing_combined_diff,
2051  ecl_top_top_timing_combined_diff);
2052  h_gdl_ecltop_timing_diff_vs_ecltop_best_slot[skim[ifill]][histClass]->Fill(ecl_gdl_top_timing_combined_diff,
2053  ecl_top_top_timing_best_slot_diff);
2054 
2055  h_top_ecltop_timing_diff_2ns[skim[ifill]][histClass]->Fill(ecl_top_top_timing_combined_diff);
2056 
2057  // these histograms are (presumably) for just ONE decision from circular buffer (past 1us) unless there are more than one TOP t0 decision with exactly same timing
2058  if (top_timing_same) {
2059  h_top_ecltop_timing_combined_diff_2ns[skim[ifill]][histClass]->Fill(ecl_top_top_timing_combined_diff);
2060  h_top_ecltop_timing_best_slot_diff_2ns[skim[ifill]][histClass]->Fill(ecl_top_top_timing_best_slot_diff);
2061  h_topNHitBestSlot[skim[ifill]][histClass]->Fill(nHitsSlotBest);
2062  // h_topT0DecisionNumberBestSlot[skim[ifill]][histClass]->Fill(t0DecisionNumber + 1);
2063  }
2064  }
2065 
2066  h_topCombinedTimingTop[skim[ifill]][histClass]->Fill(topCombinedTimingTop);
2067  h_topNSlotsCombinedTimingTop[skim[ifill]][histClass]->Fill(topNSlotsCombinedTimingTop);
2068  h_topNHitSum[skim[ifill]][histClass]->Fill((int) hitsPerSlot);
2069  h_topLogLSum[skim[ifill]][histClass]->Fill((int) logLPerSlot);
2070  }
2071 
2072  h_gdl_ecltop_timing_diff_vs_nslots_2ns[skim[ifill]]->Fill(ecl_top_timing_diff, topNSlotsCombinedTimingTop);
2073  h_top_ecltop_timing_diff_combined_2ns[skim[ifill]]->Fill(ecl_top_top_timing_combined_diff);
2074  h_top_ecltop_timing_diff_best_slot_2ns[skim[ifill]]->Fill(ecl_top_top_timing_best_slot_diff);
2075 
2076  }
2077  }
2078 
2079  t0DecisionNumber++;
2080  }
2081 
2082 }
2083 
Belle2::TRGTOPDQMModule::defineHisto
virtual void defineHisto() override
Define Histogram.
Definition: TRGTOPDQMModule.cc:90
Belle2::TRGECLUnpackerStore
Example Detector.
Definition: TRGECLUnpackerStore.h:25
Belle2::TRGTOPDQMModule::event
virtual void event() override
Event.
Definition: TRGTOPDQMModule.cc:1213
Belle2::TRGTOPDQMModule::trgeclHitArray
StoreArray< TRGECLUnpackerStore > trgeclHitArray
Trg ECL Unpacker TC output.
Definition: TRGTOPDQMModule.h:310
Belle2::Module::setDescription
void setDescription(const std::string &description)
Sets the description of the module.
Definition: Module.cc:216
REG_MODULE
#define REG_MODULE(moduleName)
Register the given module (without 'Module' suffix) with the framework.
Definition: Module.h:652
Belle2::Module::c_ParallelProcessingCertified
@ c_ParallelProcessingCertified
This module can be run in parallel processing mode safely (All I/O must be done through the data stor...
Definition: Module.h:82
Belle2::TRGTOPDQMModule::largestEnergy
Definition: TRGTOPDQMModule.h:322
Belle2::TRGTOPDQMModule::h_N_decision
TH1I * h_N_decision[nskim_topdqm][nHistClasses]
Number of TOP L1 decisions.
Definition: TRGTOPDQMModule.h:97
skim
Definition: __init__.py:1
Belle2::TRGECLUnpackerStore::getTCId
int getTCId() const
The method to get cell id.
Definition: TRGECLUnpackerStore.h:80
Belle2::TrgEclMapping::getTCPhiIdFromTCId
int getTCPhiIdFromTCId(int)
get [TC Phi ID] from [TC ID]
Definition: TrgEclMapping.cc:227
Belle2::TrgEclMapping
A class of TC Mapping.
Definition: TrgEclMapping.h:31
Belle2::SoftwareTriggerCutResult::c_accept
@ c_accept
Accept this event.
Belle2::TRGTOPDQMModule::tcEcl
Definition: TRGTOPDQMModule.h:312
Belle2::Module::setPropertyFlags
void setPropertyFlags(unsigned int propertyFlags)
Sets the flags for the module properties.
Definition: Module.cc:210
Belle2::TRGTOPDQMModule::endRun
virtual void endRun() override
End Run.
Definition: TRGTOPDQMModule.cc:1207
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::StoreObjPtr
Type-safe access to single objects in the data store.
Definition: ParticleList.h:33
Belle2::TRGTOPDQMModule::h_topSlotSegment
TH1I * h_topSlotSegment[nskim_topdqm][16]
Combined t0 decisions: all, the earliest and second best.
Definition: TRGTOPDQMModule.h:101
Belle2::TRGECLUnpackerStore::getTCTime
int getTCTime() const
The method to get hit average time.
Definition: TRGECLUnpackerStore.h:83
Belle2::Module::addParam
void addParam(const std::string &name, T &paramVariable, const std::string &description, const T &defaultValue)
Adds a new parameter to the module.
Definition: Module.h:562
Belle2::TRGTOPDQMModule::dirDQM
TDirectory * dirDQM
TDirectory.
Definition: TRGTOPDQMModule.h:76
Belle2::TRGTOPDQMModule::slotDecision
Definition: TRGTOPDQMModule.h:333
Belle2::TRGTOPDQMModule::beginRun
virtual void beginRun() override
begin Run
Definition: TRGTOPDQMModule.cc:923
Belle2::TrgEclMapping::getTCThetaIdFromTCId
int getTCThetaIdFromTCId(int)
get [TC Theta ID] from [TC ID]
Definition: TrgEclMapping.cc:200
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::TRGTOPDQMModule::oldDir
TDirectory * oldDir
TDirectory.
Definition: TRGTOPDQMModule.h:74
Belle2::TRGTOPDQMModule::largestNHits
Definition: TRGTOPDQMModule.h:343
Belle2::StoreArray::getEntries
int getEntries() const
Get the number of objects in the array.
Definition: StoreArray.h:226
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::TRGTOPDQMModule::initialize
virtual void initialize() override
initialize
Definition: TRGTOPDQMModule.cc:1137
Belle2::StoreObjPtr::isValid
bool isValid() const
Check whether the object was created.
Definition: StoreObjPtr.h:120