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