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