CbmRoot
Loading...
Searching...
No Matches
CbmMcbm2018MonitorMcbmPulser.cxx
Go to the documentation of this file.
1/* Copyright (C) 2019-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Pierre-Alain Loizeau [committer] */
4
5// -----------------------------------------------------------------------------
6// ----- -----
7// ----- CbmMcbm2018MonitorMcbmPulser -----
8// ----- Created 20/02/19 by P.-A. Loizeau -----
9// ----- -----
10// -----------------------------------------------------------------------------
11
12#include "CbmMcbm2018MonitorMcbmPulser.h"
13
14// Data
15
16// CbmRoot
17#include "CbmMcbm2018StsPar.h"
18#include "CbmMcbm2018TofPar.h"
19
20// FairRoot
21#include "FairRootManager.h"
22#include "FairRun.h"
23#include "FairRunOnline.h"
24#include "FairRuntimeDb.h"
25#include <Logger.h>
26
27// Root
28#include "TClonesArray.h"
29#include "TF1.h"
30#include "THttpServer.h"
31#include "TMath.h"
32#include "TROOT.h"
33#include "TRandom.h"
34#include "TString.h"
35#include "TStyle.h"
36#include <TFile.h>
37
38// C++11
39
40// C/C++
41#include <cstdint>
42#include <iomanip>
43#include <iostream>
44
45Bool_t bMcbm2018ResetPulser = kFALSE;
46Bool_t bMcbm2018WritePulser = kFALSE;
47/*
48Bool_t bMcbm2018ResetPulser = kFALSE;
49Bool_t bMcbm2018WritePulser = kFALSE;
50*/
51/*
52Bool_t bMcbm2018SyncResetHistosTof = kFALSE;
53Bool_t bMcbm2018SyncSaveHistosTof = kFALSE;
54Bool_t bMcbm2018SyncUpdateZoomedFit = kFALSE;
55*/
56
57CbmMcbm2018MonitorMcbmPulser::CbmMcbm2018MonitorMcbmPulser()
58 : CbmMcbmUnpack()
59 , fvMsComponentsListSts()
60 , fvMsComponentsListTof()
61 , fuNbCoreMsPerTs(0)
62 , fuNbOverMsPerTs(0)
63 , fbIgnoreOverlapMs(kFALSE)
64 , fUnpackParSts(nullptr)
65 , fuStsNrOfDpbs(0)
66 , fmStsDpbIdIndexMap()
67 , fuMuchDpbIdx(1)
68 , fUnpackParTof(nullptr)
69 , fuTofNrOfDpbs(0)
70 , fmTofDpbIdIndexMap()
71 , fuDiamondDpbIdx(2)
72 , fuTotalNrOfDpb(0)
73 , fdStsTofOffsetNs(0.0)
74 , fdMuchTofOffsetNs(0.0)
75 , fbUseBestPair(kFALSE)
76 , fbTsLevelAna(kFALSE)
77 , fsHistoFileFullname("data/mCBMsyncHistos.root")
78 , fbPrintMessages(kFALSE)
79 , fPrintMessCtrlSts(stsxyter::MessagePrintMask::msg_print_Human)
80 , fulCurrentTsIdx(0)
81 , fulCurrentMsIdx(0)
82 , fmMsgCounter()
83 , fuCurrentEquipmentId(0)
84 , fuCurrDpbId(0)
85 , fuCurrDpbIdx(0)
86 , fiRunStartDateTimeSec(-1)
87 , fiBinSizeDatePlots(-1)
88 , fvulStsCurrentTsMsb()
89 , fvuStsCurrentTsMsbCycle()
90 , fvmStsSdpbHitsInMs()
91 , fvmStsSdpbHitsInTs()
92 , fulTofCurrentTsIndex(0)
93 , fuTofCurrentMs(0)
94 , fdTofMsIndex(0)
95 , fuTofGdpbId(0)
96 , fuTofGdpbNr(0)
97 , fiTofEquipmentId(0)
98 , fviTofMsgCounter(1 + gdpbv100::MSG_STAR_TRI_D, 0)
99 , fvulTofCurrentEpoch()
100 , fvulTofCurrentEpochCycle()
101 , fvulTofCurrentEpochFull()
102 , fulTofCurrentEpochTime(0)
103 , fvmTofEpSupprBuffer()
104 , fvmTofGdpbHitsInMs()
105 , fvmTofGdpbHitsInTs()
106 , fhMcbmHitsNbPerMs()
107 , fvhMcbmTimeDiffToSelDpb()
108 , fvhMcbmTimeDiffToSelDpbWide()
109 , fvhMcbmTimeDiffToSelDpbTs()
110 , fvhMcbmTimeDiffToDiamondEvoDpb()
111 , fvhMcbmTimeDiffToDiamondWideEvoDpb()
112 , fvhMcbmTimeDiffToDiamondTsEvoDpb()
113 , fvhMcbmTimeDiffToTofEvoDpb()
114 , fvhMcbmTimeDiffToTofWideEvoDpb()
115 , fvhMcbmTimeDiffToTofTsEvoDpb()
116{
117}
118
119CbmMcbm2018MonitorMcbmPulser::~CbmMcbm2018MonitorMcbmPulser() {}
120
121Bool_t CbmMcbm2018MonitorMcbmPulser::Init()
122{
123 LOG(info) << "Initializing flib StsXyter unpacker for STS";
124
125 FairRootManager* ioman = FairRootManager::Instance();
126 if (ioman == nullptr) { LOG(fatal) << "No FairRootManager instance"; }
127
128 return kTRUE;
129}
130
131void CbmMcbm2018MonitorMcbmPulser::SetParContainers()
132{
133 LOG(info) << "Setting parameter containers for " << GetName();
134 fUnpackParSts = (CbmMcbm2018StsPar*) (FairRun::Instance()->GetRuntimeDb()->getContainer("CbmMcbm2018StsPar"));
135 fUnpackParTof = (CbmMcbm2018TofPar*) (FairRun::Instance()->GetRuntimeDb()->getContainer("CbmMcbm2018TofPar"));
136}
137
138
139Bool_t CbmMcbm2018MonitorMcbmPulser::InitContainers()
140{
141 LOG(info) << "Init parameter containers for " << GetName();
142
143 Bool_t bReInit = ReInitContainers();
144 CreateStsHistograms();
145 CreateTofHistograms();
146 CreateMcbmHistograms();
147
148 return bReInit;
149}
150
151Bool_t CbmMcbm2018MonitorMcbmPulser::ReInitContainers()
152{
153 LOG(info) << "ReInit parameter containers for " << GetName();
154
155 /***************** STS parameters *************************************/
156 fuStsNrOfDpbs = fUnpackParSts->GetNrOfDpbs();
157 LOG(info) << "Nr. of STS DPBs: " << fuStsNrOfDpbs;
158
159 fmStsDpbIdIndexMap.clear();
160 for (UInt_t uDpb = 0; uDpb < fuStsNrOfDpbs; ++uDpb) {
161 fmStsDpbIdIndexMap[fUnpackParSts->GetDpbId(uDpb)] = uDpb;
162 LOG(info) << "Eq. ID for DPB #" << std::setw(2) << uDpb << " = 0x" << std::setw(4) << std::hex
163 << fUnpackParSts->GetDpbId(uDpb) << std::dec << " => "
164 << fmStsDpbIdIndexMap[fUnpackParSts->GetDpbId(uDpb)];
165 } // for( UInt_t uDpb = 0; uDpb < fuStsNrOfDpbs; ++uDpb )
166
167 fvulStsCurrentTsMsb.resize(fuStsNrOfDpbs, 0);
168 fvuStsCurrentTsMsbCycle.resize(fuStsNrOfDpbs, 0);
169 fvmStsSdpbHitsInMs.resize(fuStsNrOfDpbs);
170 fvmStsSdpbHitsInTs.resize(fuStsNrOfDpbs);
171 /***************** STS parameters *************************************/
172
173 /***************** TOF parameters *************************************/
174 fuTofNrOfDpbs = fUnpackParTof->GetNrOfGdpbs();
175 LOG(info) << "Nr. of Tof GDPBs: " << fuTofNrOfDpbs;
176
177 fmTofDpbIdIndexMap.clear();
178 for (UInt_t i = 0; i < fuTofNrOfDpbs; ++i) {
179 fmTofDpbIdIndexMap[fUnpackParTof->GetGdpbId(i)] = i;
180 LOG(info) << "GDPB Id of TOF " << i << " : " << std::hex << fUnpackParTof->GetGdpbId(i) << std::dec;
181 } // for( UInt_t i = 0; i < fuTofNrOfDpbs; ++i )
182
184 fvulTofCurrentEpoch.resize(fuTofNrOfDpbs, 0);
185 fvulTofCurrentEpochCycle.resize(fuTofNrOfDpbs, 0);
186 fvulTofCurrentEpochFull.resize(fuTofNrOfDpbs, 0);
187 fvmTofEpSupprBuffer.resize(fuTofNrOfDpbs);
188 fvmTofGdpbHitsInMs.resize(fuTofNrOfDpbs);
189 fvmTofGdpbHitsInTs.resize(fuTofNrOfDpbs);
190 /***************** TOF parameters *************************************/
191
192 return kTRUE;
193}
194
195void CbmMcbm2018MonitorMcbmPulser::AddMsComponentToList(size_t component, UShort_t usDetectorId)
196{
197 switch (usDetectorId) {
198 case 0x10: //fles::Subsystem::STS:
199 {
200 AddMsComponentToListSts(component);
201 break;
202 } // case 0x10:
203 case 0x60: //fles::Subsystem::TOF:
204 {
205 AddMsComponentToListTof(component);
206 break;
207 } // case 0x60:
208 default: {
209 LOG(warning) << "CbmMcbm2018MonitorStsSync::AddMsComponentToList => "
210 << "Ignore component " << component << " as detector id " << usDetectorId
211 << " is not supported by this unpacker.";
212 break;
213 } // default:
214 } // switch( iDetectorId )
215}
216void CbmMcbm2018MonitorMcbmPulser::AddMsComponentToListSts(size_t component)
217{
219 for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsListSts.size(); ++uCompIdx)
220 if (component == fvMsComponentsListSts[uCompIdx]) return;
221
223 fvMsComponentsListSts.push_back(component);
224}
225void CbmMcbm2018MonitorMcbmPulser::AddMsComponentToListTof(size_t component)
226{
228 for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsListTof.size(); ++uCompIdx)
229 if (component == fvMsComponentsListTof[uCompIdx]) return;
230
232 fvMsComponentsListTof.push_back(component);
233}
234void CbmMcbm2018MonitorMcbmPulser::SetNbMsInTs(size_t uCoreMsNb, size_t uOverlapMsNb)
235{
236 fuNbCoreMsPerTs = uCoreMsNb;
237 fuNbOverMsPerTs = uOverlapMsNb;
238
239 // UInt_t uNbMsTotal = fuNbCoreMsPerTs + fuNbOverMsPerTs;
240}
241
242/***************** STS Histograms *************************************/
243void CbmMcbm2018MonitorMcbmPulser::CreateStsHistograms()
244{
245 TString sHistName {""};
246 TString title {""};
247 /*
248 sHistName = "hPulserMessageType";
249 title = "Nb of message for each type; Type";
250 fhStsMessType = new TH1I(sHistName, title, 5, 0., 5.);
251 fhStsMessType->GetXaxis()->SetBinLabel( 1, "Dummy");
252 fhStsMessType->GetXaxis()->SetBinLabel( 2, "Hit");
253 fhStsMessType->GetXaxis()->SetBinLabel( 3, "TsMsb");
254 fhStsMessType->GetXaxis()->SetBinLabel( 4, "Epoch");
255 fhStsMessType->GetXaxis()->SetBinLabel( 5, "Empty");
256
257 // Online histo browser commands
258#ifdef USE_HTTP_SERVER
259 THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
260 if( server )
261 {
262 server->Register("/StsRaw", fhStsMessType );
263
264 server->RegisterCommand("/Reset_All_Pulser", "bMcbm2018ResetPulser=kTRUE");
265 server->RegisterCommand("/Write_All_Pulser", "bMcbm2018WritePulser=kTRUE");
266
267 server->Restrict("/Reset_All_Pulser", "allow=admin");
268 server->Restrict("/Write_All_Pulser", "allow=admin");
269 } // if( server )
270#endif
271*/
273 /*
274 Double_t w = 10;
275 Double_t h = 10;
276
277 // Summary per StsXyter
278 for( UInt_t uXyterIdx = 0; uXyterIdx < fuStsNbStsXyters; ++uXyterIdx )
279 {
280 TCanvas* cStsSumm = new TCanvas( Form("cStsSum_%03u", uXyterIdx ),
281 Form("Summary plots for StsXyter %03u", uXyterIdx ),
282 w, h);
283 cStsSumm->Divide( 2, 2 );
284
285 cStsSumm->cd(1);
286 gPad->SetLogy();
287 fhStsChanCntRaw[ uXyterIdx ]->Draw();
288
289 cStsSumm->cd(2);
290 gPad->SetLogz();
291 fhStsChanAdcRaw[ uXyterIdx ]->Draw( "colz" );
292
293 cStsSumm->cd(3);
294 gPad->SetLogz();
295 fhStsChanHitRateEvo[ uXyterIdx ]->Draw( "colz" );
296
297 cStsSumm->cd(4);
298// gPad->SetLogy();
299 fhStsChanAdcRawProf[ uXyterIdx ]->Draw();
300 } // for( UInt_t uXyterIdx = 0; uXyterIdx < fuStsNbStsXyters; ++uXyterIdx )
301
302//====================================================================//
303*/
304 /*****************************/
305 LOG(info) << "Done Creating STS Histograms";
306}
307/***************** STS Histograms *************************************/
308
309/***************** TOF Histograms *************************************/
310void CbmMcbm2018MonitorMcbmPulser::CreateTofHistograms()
311{
312 TString sHistName {""};
313 TString title {""};
314
315 /*******************************************************************/
316 /*
317
318 sHistName = "hMessageType";
319 title = "Nb of message for each type; Type";
320 // Test Big Data readout with plotting
321 fhTofMessType = new TH1I(sHistName, title, 1 + gdpbv100::MSG_STAR_TRI_A, 0., 1 + gdpbv100::MSG_STAR_TRI_A);
322 fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_HIT, "HIT");
323 fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_EPOCH, "EPOCH");
324 fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SLOWC, "SLOWC");
325 fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SYST, "SYST");
326 fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_A, "MSG_STAR_TRI");
327*/
328 /*******************************************************************/
329 /*
330#ifdef USE_HTTP_SERVER
331 THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
332 if( server )
333 {
334 server->Register("/TofRaw", fhTofMessType );
335
336 server->RegisterCommand("/Reset_All_TOF", "bMcbm2018SyncResetHistosTof=kTRUE");
337 server->RegisterCommand("/Save_All_Tof", "bMcbm2018SyncSaveHistosTof=kTRUE");
338 server->RegisterCommand("/Update_PulsFit", "bMcbm2018SyncUpdateZoomedFit=kTRUE");
339
340 server->Restrict("/Reset_All_Tof", "allow=admin");
341 server->Restrict("/Save_All_Tof", "allow=admin");
342 server->Restrict("/Update_PulsFit", "allow=admin");
343 } // if( server )
344#endif
345*/
347 /*
348 Double_t w = 10;
349 Double_t h = 10;
350 TCanvas* cSummary = new TCanvas("cSummary", "gDPB Monitoring Summary", w, h);
351 cSummary->Divide(2, 3);
352
353 // 1st Column: Messages types
354 cSummary->cd(1);
355 gPad->SetLogy();
356 fhTofMessType->Draw();
357
358 cSummary->cd(2);
359 gPad->SetLogy();
360 fhTofSysMessType->Draw();
361
362 cSummary->cd(3);
363 gPad->SetLogz();
364 fhTofGet4MessType->Draw("colz");
365
366 // 2nd Column: GET4 Errors + Epoch flags + SCm
367 cSummary->cd(4);
368 gPad->SetLogz();
369 fhTofGet4ChanErrors->Draw("colz");
370
371 cSummary->cd(5);
372 gPad->SetLogz();
373 fhTofGet4EpochFlags->Draw("colz");
374
375 cSummary->cd(6);
376 fhTofGet4ChanScm->Draw("colz");
377*/
378 /*****************************/
379
380 LOG(info) << "Done Creating TOF Histograms";
381}
382/***************** TOF Histograms *************************************/
383
384/***************** mCBM Histograms ************************************/
385void CbmMcbm2018MonitorMcbmPulser::CreateMcbmHistograms()
386{
387 TString sHistName {""};
388 TString sHistTitle {""};
389
390 fuTotalNrOfDpb = fuStsNrOfDpbs + fuTofNrOfDpbs;
391
392 sHistName = "hMcbmHitsNbPerMs";
393 sHistTitle = "Nb of hits per DPB; Nb of hits []; DPB []";
394 fhMcbmHitsNbPerMs = new TH2D(sHistName, sHistTitle, 1000.0, 0., 1000., fuTotalNrOfDpb, 0., fuTotalNrOfDpb);
395
396 for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
397 sHistName = Form("hMcbmTimeDiffToDpb%02u", uDpb);
398 sHistTitle = Form("Time difference for STS and TOF hits, per DPB, against "
399 "any hits in DPB %02u; <tn - tRef> [ns]; DPB []",
400 uDpb);
401 fvhMcbmTimeDiffToSelDpb.push_back(new TH2D(sHistName, sHistTitle, 1001, -500.5 * stsxyter::kdClockCycleNs,
402 500.5 * stsxyter::kdClockCycleNs, fuTotalNrOfDpb, 0., fuTotalNrOfDpb));
403 sHistName = Form("hMcbmTimeDiffToDpb%02uWide", uDpb);
404 sHistTitle = Form("Time difference for STS and TOF hits, per DPB, against any hits in "
405 "DPB %02u, wide range; <tn - tRef> [us]; DPB []",
406 uDpb);
407 fvhMcbmTimeDiffToSelDpbWide.push_back(
408 new TH2D(sHistName, sHistTitle, 6000.0, -300., 300., fuTotalNrOfDpb, 0., fuTotalNrOfDpb));
409 sHistName = Form("hMcbmTimeDiffToDpb%02uTs", uDpb);
410 sHistTitle = Form("Time difference for STS and TOF hits, per DPB, against any hits in "
411 "DPB %02u, TS range; <tn - tRef> [ms]; DPB []",
412 uDpb);
413 fvhMcbmTimeDiffToSelDpbTs.push_back(
414 new TH2D(sHistName, sHistTitle, 2000.0, -10., 10., fuTotalNrOfDpb, 0., fuTotalNrOfDpb));
415
416 sHistName = Form("hMcbmTimeDiffToDiamondEvoDpb%02u", uDpb);
417 sHistTitle = Form("Evolution of time difference for STS or TOF hits from DPB %02u "
418 "against any Diamond hit; TS []; <tn - tDia> [ns]",
419 uDpb);
420 fvhMcbmTimeDiffToDiamondEvoDpb.push_back(new TH2D(sHistName, sHistTitle, 2000.0, 0., 200000., 1001,
421 -500.5 * stsxyter::kdClockCycleNs,
422 500.5 * stsxyter::kdClockCycleNs));
423
424 sHistName = Form("hMcbmTimeDiffToDiamondWideEvoDpb%02u", uDpb);
425 sHistTitle = Form("Evolution of time difference for STS or TOF hits from DPB %02u "
426 "against any Diamond hit, wide range; TS []; <tn - tDia> [us]",
427 uDpb);
428 fvhMcbmTimeDiffToDiamondWideEvoDpb.push_back(
429 new TH2D(sHistName, sHistTitle, 2000.0, 0., 200000., 4000.0, -200., 200.));
430
431 sHistName = Form("hMcbmTimeDiffToDiamondTsEvoDpb%02u", uDpb);
432 sHistTitle = Form("Evolution of time difference for STS or TOF hits from DPB %02u "
433 "against any Diamond hit, TS range; TS []; <tn - tDia> [ms]",
434 uDpb);
435 fvhMcbmTimeDiffToDiamondTsEvoDpb.push_back(new TH2D(sHistName, sHistTitle, 2000.0, 0., 200000., 200.0, -10., 10.));
436
437 sHistName = Form("hMcbmTimeDiffToTofEvoDpb%02u", uDpb);
438 sHistTitle = Form("Evolution of time difference for STS or TOF hits from "
439 "DPB %02u against any Tof hit; TS []; <tn - tTof> [ns]",
440 uDpb);
441 fvhMcbmTimeDiffToTofEvoDpb.push_back(new TH2D(sHistName, sHistTitle, 2000.0, 0., 200000., 1001,
442 -500.5 * stsxyter::kdClockCycleNs, 500.5 * stsxyter::kdClockCycleNs));
443
444 sHistName = Form("hMcbmTimeDiffToTofWideEvoDpb%02u", uDpb);
445 sHistTitle = Form("Evolution of time difference for STS or TOF hits from DPB %02u "
446 "against any Tof hit, wide range; TS []; <tn - tTof> [us]",
447 uDpb);
448 fvhMcbmTimeDiffToTofWideEvoDpb.push_back(new TH2D(sHistName, sHistTitle, 2000.0, 0., 200000., 4000.0, -200., 200.));
449
450 sHistName = Form("hMcbmTimeDiffToTofTsEvoDpb%02u", uDpb);
451 sHistTitle = Form("Evolution of time difference for STS or TOF hits from DPB %02u "
452 "against any Tof hit, TS range; TS []; <tn - tTof> [ms]",
453 uDpb);
454 fvhMcbmTimeDiffToTofTsEvoDpb.push_back(new TH2D(sHistName, sHistTitle, 2000.0, 0., 200000., 200.0, -10., 10.));
455 } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
456#ifdef USE_HTTP_SERVER
457 THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
458 if (server) {
459 server->Register("/mCbmDt", fhMcbmHitsNbPerMs);
460
461 for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
462 server->Register("/mCbmDt", fvhMcbmTimeDiffToSelDpb[uDpb]);
463 server->Register("/mCbmDt", fvhMcbmTimeDiffToSelDpbWide[uDpb]);
464 server->Register("/mCbmDt", fvhMcbmTimeDiffToSelDpbTs[uDpb]);
465
466 server->Register("/mCbmDt", fvhMcbmTimeDiffToDiamondEvoDpb[uDpb]);
467 server->Register("/mCbmDt", fvhMcbmTimeDiffToDiamondWideEvoDpb[uDpb]);
468 server->Register("/mCbmDt", fvhMcbmTimeDiffToDiamondTsEvoDpb[uDpb]);
469
470 server->Register("/mCbmDt", fvhMcbmTimeDiffToTofEvoDpb[uDpb]);
471 server->Register("/mCbmDt", fvhMcbmTimeDiffToTofWideEvoDpb[uDpb]);
472 server->Register("/mCbmDt", fvhMcbmTimeDiffToTofTsEvoDpb[uDpb]);
473 } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
474
475 server->RegisterCommand("/Reset_All", "bMcbm2018ResetPulser=kTRUE");
476 server->RegisterCommand("/Save_All", "bMcbm2018WritePulser=kTRUE");
477
478 server->Restrict("/Reset_All", "allow=admin");
479 server->Restrict("/Save_All", "allow=admin");
480 } // if( server )
481#endif
482
483 Double_t w = 10;
484 Double_t h = 10;
486 for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
487 TCanvas* cSyncMcbmDpb = new TCanvas(Form("cSyncMcbmDpb%02u", uDpb),
488 Form("Time difference for STS and TOF hits, per DPB, against "
489 "any DPB %02u hit",
490 uDpb),
491 w, h);
492 cSyncMcbmDpb->Divide(3);
493
494 cSyncMcbmDpb->cd(1);
495 gPad->SetGridx();
496 gPad->SetGridy();
497 gPad->SetLogz();
498 fvhMcbmTimeDiffToSelDpb[uDpb]->Draw("colz");
499
500 cSyncMcbmDpb->cd(2);
501 gPad->SetGridx();
502 gPad->SetGridy();
503 gPad->SetLogz();
504 fvhMcbmTimeDiffToSelDpbWide[uDpb]->Draw("colz");
505
506 cSyncMcbmDpb->cd(3);
507 gPad->SetGridx();
508 gPad->SetGridy();
509 gPad->SetLogz();
510 fvhMcbmTimeDiffToSelDpbTs[uDpb]->Draw("colz");
511 } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
512 /*****************************/
513
514 LOG(info) << "Done Creating mCBM Histograms";
515}
516/***************** mCBM Histograms ************************************/
517
518Bool_t CbmMcbm2018MonitorMcbmPulser::DoUnpack(const fles::Timeslice& ts, size_t component)
519{
521 if (bMcbm2018ResetPulser) {
522 ResetAllHistos();
523 bMcbm2018ResetPulser = kFALSE;
524 } // if( bMcbm2018ResetPulser )
525 if (bMcbm2018WritePulser) {
526 SaveAllHistos(fsHistoFileFullname);
527 bMcbm2018WritePulser = kFALSE;
528 } // if( bMcbm2018WritePulser )
529
530 LOG(debug) << "Timeslice contains " << ts.num_microslices(component) << "microslices.";
531 fulCurrentTsIdx = ts.index();
532
534 if (0 == fulCurrentTsIdx) return kTRUE;
535
536 if (fulCurrentTsIdx < 30) LOG(info) << Form("TS %2llu", fulCurrentTsIdx);
537
538 // Ignore overlap ms if flag set by user
539 UInt_t uNbMsLoop = fuNbCoreMsPerTs;
540 if (kFALSE == fbIgnoreOverlapMs) uNbMsLoop += fuNbOverMsPerTs;
541
542 // Loop over core microslices (and overlap ones if chosen)
543 for (UInt_t uMsIdx = 0; uMsIdx < uNbMsLoop; uMsIdx++) {
544 // Loop over registered STS components
545 for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsListSts.size(); ++uMsCompIdx) {
546 UInt_t uMsComp = fvMsComponentsListSts[uMsCompIdx];
547
548 if (kFALSE == ProcessStsMs(ts, uMsComp, uMsIdx)) return kFALSE;
549 } // for( UInt_t uMsComp = 0; uMsComp < fvMsComponentsListSts.size(); ++uMsComp )
550
551 // Loop over registered TOF components
552 for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsListTof.size(); ++uMsCompIdx) {
553 UInt_t uMsComp = fvMsComponentsListTof[uMsCompIdx];
554
555 if (kFALSE == ProcessTofMs(ts, uMsComp, uMsIdx)) return kFALSE;
556 } // for( UInt_t uMsComp = 0; uMsComp < fvMsComponentsListSts.size(); ++uMsComp )
557
558
559 /****************** STS Sync ******************************************/
561 for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb)
562 std::sort(fvmStsSdpbHitsInMs[uSdpb].begin(), fvmStsSdpbHitsInMs[uSdpb].end());
563 /****************** STS Sync ******************************************/
564
565 /****************** TOF Sync ******************************************/
567 for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb)
568 std::sort(fvmTofGdpbHitsInMs[uGdpb].begin(), fvmTofGdpbHitsInMs[uGdpb].end());
569 /****************** TOF Sync ******************************************/
570
571 /****************** mCBM Sync *****************************************/
573 for (UInt_t uRefSdpb = 0; uRefSdpb < fuStsNrOfDpbs; ++uRefSdpb) {
574 UInt_t uNbRefHits = fvmStsSdpbHitsInMs[uRefSdpb].size();
575 for (UInt_t uHitRef = 0; uHitRef < uNbRefHits; uHitRef++) {
576 Double_t dRefTime = stsxyter::kdClockCycleNs * fvmStsSdpbHitsInMs[uRefSdpb][uHitRef].GetTs();
577 if (fuMuchDpbIdx == uRefSdpb) dRefTime -= fdMuchTofOffsetNs;
578 else
579 dRefTime -= fdStsTofOffsetNs;
580
581 for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
582 UInt_t uNbHits = fvmStsSdpbHitsInMs[uSdpb].size();
583 Double_t dBestDt = 1e9;
584 // UInt_t uBestAdc = 0;
585 UInt_t uNbIncrDt = 0;
586
587 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
588 if (uRefSdpb == uSdpb && uHitRef == uHit) continue;
589
590 Double_t dHitTime = stsxyter::kdClockCycleNs * fvmStsSdpbHitsInMs[uSdpb][uHit].GetTs();
591 if (fuMuchDpbIdx == uSdpb) dHitTime -= fdMuchTofOffsetNs;
592 else
593 dHitTime -= fdStsTofOffsetNs;
594
595 Double_t dDt = dHitTime - dRefTime;
596
597 if (kTRUE == fbUseBestPair) {
599 if (TMath::Abs(dDt) < TMath::Abs(dBestDt)) {
600 dBestDt = dDt;
601 // uBestAdc = fvmStsSdpbHitsInMs[ uSdpb ][ uHit ].GetAdc();
602 } // if( TMath::Abs( dDt ) < TMath::Abs( dBestDt ) )
603 else if (dBestDt < dDt)
604 uNbIncrDt++;
605
607 if (5 == dBestDt) break;
608 } // if( kTRUE == fbUseBestPair )
609 else {
610 fvhMcbmTimeDiffToSelDpb[uRefSdpb]->Fill(dDt, uSdpb);
611 fvhMcbmTimeDiffToSelDpbWide[uRefSdpb]->Fill(dDt / 1000.0, uSdpb);
612 } // else of if( kTRUE == fbUseBestPair )
613 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
614
615 if (kTRUE == fbUseBestPair) {
616 fvhMcbmTimeDiffToSelDpb[uRefSdpb]->Fill(dBestDt, uSdpb);
617 fvhMcbmTimeDiffToSelDpbWide[uRefSdpb]->Fill(dBestDt / 1000.0, uSdpb);
618 } // if( kTRUE == fbUseBestPair )
619 } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
620
621 for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
622 UInt_t uNbHits = fvmTofGdpbHitsInMs[uGdpb].size();
623 Double_t dBestDt = 1e9;
624 UInt_t uNbIncrDt = 0;
625
626 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
627 Double_t dHitTime = fvmTofGdpbHitsInMs[uGdpb][uHit].GetFullTimeNs();
628
629 Double_t dDt = dHitTime - dRefTime;
630
631 if (kTRUE == fbUseBestPair) {
633 if (TMath::Abs(dDt) < TMath::Abs(dBestDt)) dBestDt = dDt;
634 else if (dBestDt < dDt)
635 uNbIncrDt++;
636
638 if (5 == dBestDt) break;
639 } // if( kTRUE == fbUseBestPair )
640 else {
641 fvhMcbmTimeDiffToSelDpb[uRefSdpb]->Fill(dDt, uGdpb + fuStsNrOfDpbs);
642 fvhMcbmTimeDiffToSelDpbWide[uRefSdpb]->Fill(dDt / 1000.0, uGdpb + fuStsNrOfDpbs);
643 } // else of if( kTRUE == fbUseBestPair )
644 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
645
646 if (kTRUE == fbUseBestPair) {
647 fvhMcbmTimeDiffToSelDpb[uRefSdpb]->Fill(dBestDt, uGdpb + fuStsNrOfDpbs);
648 fvhMcbmTimeDiffToSelDpbWide[uRefSdpb]->Fill(dBestDt / 1000.0, uGdpb + fuStsNrOfDpbs);
649 } // if( kTRUE == fbUseBestPair )
650 } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
651 } // for( UInt_t uHitRef = 0; uHitRef < uNbRefHits; uHitRef++)
652 } // for( UInt_t uRefSdpb = 0; uRefSdpb < fuStsNrOfDpbs; ++uRefSdpb )
653
655 for (UInt_t uRefGdpb = 0; uRefGdpb < fuTofNrOfDpbs; ++uRefGdpb) {
656 UInt_t uNbRefHits = fvmTofGdpbHitsInMs[uRefGdpb].size();
657 for (UInt_t uHitRef = 0; uHitRef < uNbRefHits; uHitRef++) {
658 Double_t dRefTime = fvmTofGdpbHitsInMs[uRefGdpb][uHitRef].GetFullTimeNs();
659
660 for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
661 UInt_t uNbHits = fvmStsSdpbHitsInMs[uSdpb].size();
662 Double_t dBestDt = 1e9;
663 UInt_t uNbIncrDt = 0;
664
665 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
666 Double_t dHitTime = stsxyter::kdClockCycleNs * fvmStsSdpbHitsInMs[uSdpb][uHit].GetTs();
667 if (fuMuchDpbIdx == uSdpb) dHitTime -= fdMuchTofOffsetNs;
668 else
669 dHitTime -= fdStsTofOffsetNs;
670
671 Double_t dDt = dHitTime - dRefTime;
672
673 if (kTRUE == fbUseBestPair) {
675 if (TMath::Abs(dDt) < TMath::Abs(dBestDt)) dBestDt = dDt;
676 else if (dBestDt < dDt)
677 uNbIncrDt++;
678
680 if (5 == dBestDt) break;
681 } // if( kTRUE == fbUseBestPair )
682 else {
683 fvhMcbmTimeDiffToSelDpb[uRefGdpb + fuStsNrOfDpbs]->Fill(dDt, uSdpb);
684 fvhMcbmTimeDiffToSelDpbWide[uRefGdpb + fuStsNrOfDpbs]->Fill(dDt / 1000.0, uSdpb);
685
686 if (fuDiamondDpbIdx == uRefGdpb) {
687 fvhMcbmTimeDiffToDiamondEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dDt);
688 fvhMcbmTimeDiffToDiamondWideEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dDt / 1000.0);
689 } // if( fuDiamondDpbIdx == uRefGdpb )
690 else {
691 fvhMcbmTimeDiffToTofEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dDt);
692 fvhMcbmTimeDiffToTofWideEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dDt / 1000.0);
693 } // else of if( fuDiamondDpbIdx == uRefGdpb )
694
695 } // else of if( kTRUE == fbUseBestPair )
696 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
697
698 if (kTRUE == fbUseBestPair) {
699 fvhMcbmTimeDiffToSelDpb[uRefGdpb + fuStsNrOfDpbs]->Fill(dBestDt, uSdpb);
700 fvhMcbmTimeDiffToSelDpbWide[uRefGdpb + fuStsNrOfDpbs]->Fill(dBestDt / 1000.0, uSdpb);
701
702 if (fuDiamondDpbIdx == uRefGdpb) {
703 fvhMcbmTimeDiffToDiamondEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dBestDt);
704 fvhMcbmTimeDiffToDiamondWideEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dBestDt / 1000.0);
705 } // if( fuDiamondDpbIdx == uRefGdpb )
706 else {
707 fvhMcbmTimeDiffToTofEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dBestDt);
708 fvhMcbmTimeDiffToTofWideEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dBestDt / 1000.0);
709 } // else of if( fuDiamondDpbIdx == uRefGdpb )
710 } // if( kTRUE == fbUseBestPair )
711 } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
712
713 for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
714 UInt_t uNbHits = fvmTofGdpbHitsInMs[uGdpb].size();
715 Double_t dBestDt = 1e9;
716 UInt_t uNbIncrDt = 0;
717
718 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
719
720 if (uRefGdpb == uGdpb && uHitRef == uHit) continue;
721
722 Double_t dHitTime = fvmTofGdpbHitsInMs[uGdpb][uHit].GetFullTimeNs();
723
724 Double_t dDt = dHitTime - dRefTime;
725
726 if (kTRUE == fbUseBestPair) {
728 if (TMath::Abs(dDt) < TMath::Abs(dBestDt)) dBestDt = dDt;
729 else if (dBestDt < dDt)
730 uNbIncrDt++;
731
733 if (5 == dBestDt) break;
734 } // if( kTRUE == fbUseBestPair )
735 else {
736 fvhMcbmTimeDiffToSelDpb[uRefGdpb + fuStsNrOfDpbs]->Fill(dDt, uGdpb + fuStsNrOfDpbs);
737 fvhMcbmTimeDiffToSelDpbWide[uRefGdpb + fuStsNrOfDpbs]->Fill(dDt / 1000.0, uGdpb + fuStsNrOfDpbs);
738
739 if (fuDiamondDpbIdx == uRefGdpb) {
740 fvhMcbmTimeDiffToDiamondEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dDt);
741 fvhMcbmTimeDiffToDiamondWideEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dDt / 1000.0);
742 } // if( fuDiamondDpbIdx == uRefGdpb )
743 else {
744 fvhMcbmTimeDiffToTofEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dDt);
745 fvhMcbmTimeDiffToTofWideEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dDt / 1000.0);
746 } // else of if( fuDiamondDpbIdx == uRefGdpb )
747 } // else of if( kTRUE == fbUseBestPair )
748 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
749
750 if (kTRUE == fbUseBestPair) {
751 fvhMcbmTimeDiffToSelDpb[uRefGdpb + fuStsNrOfDpbs]->Fill(dBestDt, uGdpb + fuStsNrOfDpbs);
752 fvhMcbmTimeDiffToSelDpbWide[uRefGdpb + fuStsNrOfDpbs]->Fill(dBestDt / 1000.0, uGdpb + fuStsNrOfDpbs);
753
754 if (fuDiamondDpbIdx == uRefGdpb) {
755 fvhMcbmTimeDiffToDiamondEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dBestDt);
756 fvhMcbmTimeDiffToDiamondWideEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dBestDt / 1000.0);
757 } // if( fuDiamondDpbIdx == uRefGdpb )
758 else {
759 fvhMcbmTimeDiffToTofEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dBestDt);
760 fvhMcbmTimeDiffToTofWideEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dBestDt / 1000.0);
761 } // else of if( fuDiamondDpbIdx == uRefGdpb )
762 } // if( kTRUE == fbUseBestPair )
763 } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
764 } // for( UInt_t uHitDia = 0; uHitDia < uNbRefHits; uHitDia++)
765 } // for( UInt_t uRefGdpb = 0; uRefGdpb < fuTofNrOfDpbs; ++uRefGdpb )
766
768 for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
769 fhMcbmHitsNbPerMs->Fill(fvmStsSdpbHitsInMs[uSdpb].size(), uSdpb);
770
771 if (fbTsLevelAna)
772 fvmStsSdpbHitsInTs[uSdpb].insert(fvmStsSdpbHitsInTs[uSdpb].end(), fvmStsSdpbHitsInMs[uSdpb].begin(),
773 fvmStsSdpbHitsInMs[uSdpb].end());
774
775 fvmStsSdpbHitsInMs[uSdpb].clear();
776 } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
777 for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
778 fhMcbmHitsNbPerMs->Fill(fvmTofGdpbHitsInMs[uGdpb].size(), uGdpb + fuStsNrOfDpbs);
779
780 if (fbTsLevelAna)
781 fvmTofGdpbHitsInTs[uGdpb].insert(fvmTofGdpbHitsInTs[uGdpb].end(), fvmTofGdpbHitsInMs[uGdpb].begin(),
782 fvmTofGdpbHitsInMs[uGdpb].end());
783
784 fvmTofGdpbHitsInMs[uGdpb].clear();
785 } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
786 /****************** mCBM Sync *****************************************/
787
788 } // for( UInt_t uMsIdx = 0; uMsIdx < uNbMsLoop; uMsIdx ++ )
789
790 /****************** mCBM Sync *****************************************/
792 for (UInt_t uRefSdpb = 0; uRefSdpb < fuStsNrOfDpbs; ++uRefSdpb) {
793 UInt_t uNbRefHits = fvmStsSdpbHitsInTs[uRefSdpb].size();
794 for (UInt_t uHitRef = 0; uHitRef < uNbRefHits; uHitRef++) {
795 Double_t dRefTime = stsxyter::kdClockCycleNs * fvmStsSdpbHitsInTs[fuMuchDpbIdx][uHitRef].GetTs();
796 if (fuMuchDpbIdx == uRefSdpb) dRefTime -= fdMuchTofOffsetNs;
797 else
798 dRefTime -= fdStsTofOffsetNs;
799
800 for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
801 UInt_t uNbHits = fvmStsSdpbHitsInTs[uSdpb].size();
802 // Double_t dBestDt = 1e9;
803 // UInt_t uBestAdc = 0;
804 // UInt_t uNbIncrDt = 0;
805
806 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
807 if (uRefSdpb == uSdpb && uHitRef == uHit) continue;
808
809 Double_t dHitTime = stsxyter::kdClockCycleNs * fvmStsSdpbHitsInTs[uSdpb][uHit].GetTs();
810 if (fuMuchDpbIdx == uSdpb) dHitTime -= fdMuchTofOffsetNs;
811 else
812 dHitTime -= fdStsTofOffsetNs;
813
814 Double_t dDt = dHitTime - dRefTime;
815
817 if (300e3 < dDt) break;
818
819 fvhMcbmTimeDiffToSelDpbTs[uRefSdpb]->Fill(dDt / 1e6, uSdpb);
820 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
821 } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
822
823 for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
824 UInt_t uNbHits = fvmTofGdpbHitsInTs[uGdpb].size();
825 // Double_t dBestDt = 1e9;
826 // UInt_t uNbIncrDt = 0;
827
828 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
829 Double_t dHitTime = fvmTofGdpbHitsInTs[uGdpb][uHit].GetFullTimeNs();
830
831 Double_t dDt = dHitTime - dRefTime;
832
834 if (300e3 < dDt) break;
835
836 fvhMcbmTimeDiffToSelDpbTs[uRefSdpb]->Fill(dDt / 1e6, uGdpb + fuStsNrOfDpbs);
837 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
838 } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
839 } // for( UInt_t uHitRef = 0; uHitRef < uNbRefHits; uHitRef++)
840 } // for( UInt_t uRefSdpb = 0; uRefSdpb < fuStsNrOfDpbs; ++uRefSdpb )
841
843 for (UInt_t uRefGdpb = 0; uRefGdpb < fuTofNrOfDpbs; ++uRefGdpb) {
844 UInt_t uNbRefHits = fvmTofGdpbHitsInTs[uRefGdpb].size();
845 for (UInt_t uHitRef = 0; uHitRef < uNbRefHits; uHitRef++) {
846 Double_t dRefTime = fvmTofGdpbHitsInTs[uRefGdpb][uHitRef].GetFullTimeNs();
847
848 for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
849 UInt_t uNbHits = fvmStsSdpbHitsInTs[uSdpb].size();
850 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
851 Double_t dHitTime = stsxyter::kdClockCycleNs * fvmStsSdpbHitsInTs[uSdpb][uHit].GetTs();
852
853 Double_t dDt = dHitTime - dRefTime;
854
856 if (300e3 < dDt) break;
857
858 fvhMcbmTimeDiffToSelDpbTs[uRefGdpb + fuStsNrOfDpbs]->Fill(dDt / 1e6, uSdpb);
859
860 if (fuDiamondDpbIdx == uRefGdpb) fvhMcbmTimeDiffToDiamondTsEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dDt / 1e6);
861 else
862 fvhMcbmTimeDiffToTofTsEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dDt / 1e6);
863 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
864 } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
865
866 for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
867 UInt_t uNbHits = fvmTofGdpbHitsInTs[uGdpb].size();
868 for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
869 if (uRefGdpb == uGdpb && uHitRef == uHit) continue;
870
871 Double_t dHitTime = fvmTofGdpbHitsInTs[uGdpb][uHit].GetFullTimeNs();
872
873 Double_t dDt = dHitTime - dRefTime;
874
876 if (300e3 < dDt) break;
877
878 fvhMcbmTimeDiffToSelDpbTs[uRefGdpb + fuStsNrOfDpbs]->Fill(dDt / 1e6, uGdpb + fuStsNrOfDpbs);
879
880 if (fuDiamondDpbIdx == uRefGdpb)
881 fvhMcbmTimeDiffToDiamondTsEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dDt / 1e6);
882 else
883 fvhMcbmTimeDiffToTofTsEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(fulCurrentTsIdx, dDt / 1e6);
884 } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
885 } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
886 } // for( UInt_t uHitRef = 0; uHitRef < uNbRefHits; uHitRef++)
887 } // for( UInt_t uRefGdpb = 0; uRefGdpb < fuTofNrOfDpbs; ++uRefGdpb )
888
890 for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
891 fvmStsSdpbHitsInTs[uSdpb].clear();
892 } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
893 for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
894 fvmTofGdpbHitsInTs[uGdpb].clear();
895 } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
896
897 /****************** mCBM Sync *****************************************/
898
899 if (0 == ts.index() % 1000) {
900 LOG(info) << "End of TS " << std::setw(7) << ts.index();
901 } // if( 0 == ts.index() % 1000 )
902
903 return kTRUE;
904}
905
906/****************** STS Sync ******************************************/
907Bool_t CbmMcbm2018MonitorMcbmPulser::ProcessStsMs(const fles::Timeslice& ts, size_t uMsComp, UInt_t uMsIdx)
908{
909 auto msDescriptor = ts.descriptor(uMsComp, uMsIdx);
910 fuCurrentEquipmentId = msDescriptor.eq_id;
911 const uint8_t* msContent = reinterpret_cast<const uint8_t*>(ts.content(uMsComp, uMsIdx));
912
913 uint32_t uSize = msDescriptor.size;
914 fulCurrentMsIdx = msDescriptor.idx;
915 // Double_t dMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
916 LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex << fuCurrentEquipmentId << std::dec
917 << " has size: " << uSize;
918
919 fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
920 fuCurrDpbIdx = fmStsDpbIdIndexMap[fuCurrDpbId];
921
923 UInt_t uTsMsbCycleHeader = std::floor(fulCurrentMsIdx / (stsxyter::kulTsCycleNbBins * stsxyter::kdClockCycleNs));
924
925 if (0 == uMsIdx) {
926 fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
927 fvulStsCurrentTsMsb[fuCurrDpbIdx] = 0;
928 } // if( 0 == uMsIdx )
929 else if (uTsMsbCycleHeader != fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] && 4194303 != fvulStsCurrentTsMsb[fuCurrDpbIdx]) {
930 LOG(warning) << "TS MSB cycle from MS header does not match current cycle from data "
931 << "for TS " << std::setw(12) << fulCurrentTsIdx << " MS " << std::setw(12) << fulCurrentMsIdx
932 << " MsInTs " << std::setw(3) << uMsIdx << " ====> " << fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] << " VS "
933 << uTsMsbCycleHeader;
934 fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
935 }
936
937 // If not integer number of message in input buffer, print warning/error
938 if (0 != (uSize % kuStsBytesPerMessage))
939 LOG(error) << "The input microslice buffer does NOT "
940 << "contain only complete nDPB messages!";
941
942 // Compute the number of complete messages in the input microslice buffer
943 uint32_t uNbMessages = (uSize - (uSize % kuStsBytesPerMessage)) / kuStsBytesPerMessage;
944
945 // Prepare variables for the loop on contents
946 const uint32_t* pInBuff = reinterpret_cast<const uint32_t*>(msContent);
947
948 for (uint32_t uIdx = 0; uIdx < uNbMessages; ++uIdx) {
949 // Fill message
950 uint32_t ulData = static_cast<uint32_t>(pInBuff[uIdx]);
951
952 stsxyter::Message mess(static_cast<uint32_t>(ulData & 0xFFFFFFFF));
953
954 // Print message if requested
955 if (fbPrintMessages) mess.PrintMess(std::cout, fPrintMessCtrlSts);
956
957 stsxyter::MessType typeMess = mess.GetMessType();
958 fmMsgCounter[typeMess]++;
959
960 switch (typeMess) {
961 case stsxyter::MessType::Hit: {
962
963 FillStsHitInfo(mess, uMsIdx);
964 break;
965 } // case stsxyter::MessType::Hit :
966 case stsxyter::MessType::TsMsb: {
967 FillStsTsMsbInfo(mess, uIdx, uMsIdx);
968 break;
969 } // case stsxyter::MessType::TsMsb :
970 case stsxyter::MessType::Epoch: {
971 // The first message in the TS is a special ones: EPOCH
972 FillStsEpochInfo(mess);
973
974 if (0 < uIdx)
975 LOG(info) << "CbmMcbm2018MonitorMcbmPulser::DoUnpack => "
976 << "EPOCH message at unexpected position in MS: message " << uIdx << " VS message 0 expected!";
977 break;
978 } // case stsxyter::MessType::TsMsb :
979 case stsxyter::MessType::Status:
980 case stsxyter::MessType::Empty:
981 case stsxyter::MessType::Dummy: {
982 break;
983 } // case stsxyter::MessType::Dummy / ReadDataAck / Ack :
984 default: {
985 LOG(fatal) << "CbmMcbm2018MonitorMcbmPulser::DoUnpack => "
986 << "Unknown message type, should never happen, stopping here!";
987 }
988 } // switch( mess.GetMessType() )
989 } // for( uint32_t uIdx = 0; uIdx < uNbMessages; ++uIdx )
990 return kTRUE;
991}
992
993void CbmMcbm2018MonitorMcbmPulser::FillStsHitInfo(stsxyter::Message mess, const UInt_t& /*uMsIdx*/)
994{
995 UShort_t usChan = mess.GetHitChannel();
996 UShort_t usRawAdc = mess.GetHitAdc();
997 // UShort_t usFullTs = mess.GetHitTimeFull();
998 // UShort_t usTsOver = mess.GetHitTimeOver();
999 UShort_t usRawTs = mess.GetHitTime();
1000
1001 UInt_t uAsicIdx = 0;
1002
1003 if (fuCurrDpbIdx == fuMuchDpbIdx) {
1005 switch (usChan) {
1006 case 101:
1007 case 99:
1008 case 91:
1009 case 89:
1010 case 88:
1011 case 86:
1012 case 84:
1013 case 83:
1014 case 80:
1015 case 78:
1016 case 76:
1017 case 50:
1018 case 39:
1019 case 37:
1020 case 35:
1021 case 20: {
1022 return;
1023 break;
1024 } // if bad channel
1025 default: break;
1026 } // switch( usChan )
1027 } // if( fuCurrDpbIdx == fuMuchDpbIdx )
1028 else {
1030 if (usRawAdc < 15) return;
1031
1033 uAsicIdx = fUnpackParSts->ElinkIdxToAsicIdx(kFALSE, mess.GetLinkIndex());
1034 UInt_t uChanIdx = usChan + fUnpackParSts->GetNbChanPerAsic() * uAsicIdx;
1035 switch (uChanIdx) {
1036 case 781:
1037 case 270:
1038 case 411:
1039 case 518: {
1040 return;
1041 break;
1042 } // if bad channel
1043 default: break;
1044 } // switch( mess.GetLinkIndex() )
1045 if ((0 == uChanIdx % 2) && (543 < uChanIdx) && (uChanIdx < 633)) { return; } // if bad channel
1046 } // else of if( fuCurrDpbIdx == fuMuchDpbIdx )
1047
1048 // Compute the Full time stamp
1049 // Use TS w/o overlap bits as they will anyway come from the TS_MSB
1050 Long64_t ulStsHitTime = usRawTs;
1051
1052 ulStsHitTime +=
1053 static_cast<ULong64_t>(stsxyter::kuHitNbTsBins) * static_cast<ULong64_t>(fvulStsCurrentTsMsb[fuCurrDpbIdx])
1054 + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBins)
1055 * static_cast<ULong64_t>(fvuStsCurrentTsMsbCycle[fuCurrDpbIdx]);
1056
1057 // Convert the Hit time in bins to Hit time in ns
1058 // Double_t dHitTimeNs = ulStsHitTime * stsxyter::kdClockCycleNs;
1059
1060
1061 // Pulser and MS
1062 fvmStsSdpbHitsInMs[fuCurrDpbIdx].push_back(stsxyter::FinalHit(ulStsHitTime, usRawAdc, uAsicIdx, usChan));
1063}
1064
1065void CbmMcbm2018MonitorMcbmPulser::FillStsTsMsbInfo(stsxyter::Message mess, UInt_t uMessIdx, UInt_t uMsIdx)
1066{
1067 UInt_t uVal = mess.GetTsMsbVal();
1068
1069 // Update Status counters
1070 if (uVal < fvulStsCurrentTsMsb[fuCurrDpbIdx]) {
1071
1072 LOG(info) << " TS " << std::setw(12) << fulCurrentTsIdx << " MS " << std::setw(12) << fulCurrentMsIdx << " DPB "
1073 << std::setw(2) << fuCurrDpbIdx << " Old TsMsb " << std::setw(5) << fvulStsCurrentTsMsb[fuCurrDpbIdx]
1074 << " Old MsbCy " << std::setw(5) << fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] << " new TsMsb " << std::setw(5)
1075 << uVal;
1076
1077 fvuStsCurrentTsMsbCycle[fuCurrDpbIdx]++;
1078 } // if( uVal < fvulStsCurrentTsMsb[fuCurrDpbIdx] )
1079 if (uVal != fvulStsCurrentTsMsb[fuCurrDpbIdx] + 1 && 0 != uVal && 4194303 != fvulStsCurrentTsMsb[fuCurrDpbIdx]
1080 && 1 != uMessIdx) {
1081 LOG(info) << "TS MSb Jump in "
1082 << " TS " << std::setw(12) << fulCurrentTsIdx << " MS " << std::setw(12) << fulCurrentMsIdx << " MS Idx "
1083 << std::setw(4) << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx << " DPB " << std::setw(2)
1084 << fuCurrDpbIdx << " => Old TsMsb " << std::setw(5) << fvulStsCurrentTsMsb[fuCurrDpbIdx] << " new TsMsb "
1085 << std::setw(5) << uVal;
1086 } // if( uVal + 1 != fvulStsCurrentTsMsb[fuCurrDpbIdx] && 4194303 != uVal && 0 != fvulStsCurrentTsMsb[fuCurrDpbIdx] )
1087 fvulStsCurrentTsMsb[fuCurrDpbIdx] = uVal;
1088 /*
1089 ULong64_t ulNewTsMsbTime = static_cast< ULong64_t >( stsxyter::kuHitNbTsBins )
1090 * static_cast< ULong64_t >( fvulStsCurrentTsMsb[fuCurrDpbIdx])
1091 + static_cast< ULong64_t >( stsxyter::kulTsCycleNbBins )
1092 * static_cast< ULong64_t >( fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] );
1093*/
1094}
1095
1096void CbmMcbm2018MonitorMcbmPulser::FillStsEpochInfo(stsxyter::Message /*mess*/)
1097{
1098 // UInt_t uVal = mess.GetTsMsbVal();
1099}
1100/****************** STS Sync ******************************************/
1101
1102/****************** TOF Sync ******************************************/
1103
1104Bool_t CbmMcbm2018MonitorMcbmPulser::ProcessTofMs(const fles::Timeslice& ts, size_t uMsComp, UInt_t uMsIdx)
1105{
1106 auto msDescriptor = ts.descriptor(uMsComp, uMsIdx);
1107 fuCurrentEquipmentId = msDescriptor.eq_id;
1108 fdTofMsIndex = static_cast<double>(msDescriptor.idx);
1109 const uint8_t* msContent = reinterpret_cast<const uint8_t*>(ts.content(uMsComp, uMsIdx));
1110
1111 uint32_t size = msDescriptor.size;
1112 // fulLastMsIdx = msDescriptor.idx;
1113 if (size > 0) LOG(debug) << "Microslice: " << msDescriptor.idx << " has size: " << size;
1114
1115 Int_t messageType = -111;
1116
1117 // If not integer number of message in input buffer, print warning/error
1118 if (0 != (size % kuTofBytesPerMessage))
1119 LOG(error) << "The input microslice buffer does NOT "
1120 << "contain only complete nDPB messages!";
1121
1122 // Compute the number of complete messages in the input microslice buffer
1123 uint32_t uNbMessages = (size - (size % kuTofBytesPerMessage)) / kuTofBytesPerMessage;
1124
1125 // Get the gDPB ID from the MS header
1126 fuTofGdpbId = fuCurrentEquipmentId;
1127 fuTofGdpbNr = fmTofDpbIdIndexMap[fuTofGdpbId];
1128
1129 // Prepare variables for the loop on contents
1130 const uint64_t* pInBuff = reinterpret_cast<const uint64_t*>(msContent);
1131 for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
1132 // Fill message
1133 uint64_t ulData = static_cast<uint64_t>(pInBuff[uIdx]);
1134 gdpbv100::Message mess(ulData);
1135
1137 if (0 == uIdx) {
1138 FillTofEpochCycle(ulData);
1139 continue;
1140 } // if( 0 == uIdx )
1141
1142 if (fair::Logger::Logging(fair::Severity::debug2)) {
1143 mess.printDataCout();
1144 } // if (fair::Logger::Logging( fair::Severity::debug2 ))
1145
1146 // Increment counter for different message types
1147 // and fill the corresponding histogram
1148 messageType = mess.getMessageType();
1149 fviTofMsgCounter[messageType]++;
1150
1151 switch (messageType) {
1152 case gdpbv100::MSG_HIT: {
1153 if (!mess.getGdpbHitIs24b()) { fvmTofEpSupprBuffer[fuTofGdpbNr].push_back(mess); } // if( !getGdpbHitIs24b() )
1154 break;
1155 } // case gdpbv100::MSG_HIT:
1156 case gdpbv100::MSG_EPOCH: {
1157 if (gdpbv100::kuChipIdMergedEpoch == mess.getGdpbGenChipId()) {
1158 FillTofEpochInfo(mess);
1159 } // if this epoch message is a merged one valiud for all chips
1160 else
1161 LOG(fatal) << "Bad epoch: " << mess.getGdpbGenChipId();
1162 break;
1163 } // case gdpbv100::MSG_EPOCH:
1164 case gdpbv100::MSG_SLOWC:
1165 case gdpbv100::MSG_SYST:
1166 case gdpbv100::MSG_STAR_TRI_A:
1167 case gdpbv100::MSG_STAR_TRI_B:
1168 case gdpbv100::MSG_STAR_TRI_C:
1169 case gdpbv100::MSG_STAR_TRI_D: break;
1170 default:
1171 LOG(error) << "Message type " << std::hex << std::setw(2) << static_cast<uint16_t>(messageType)
1172 << " not included in Get4 unpacker.";
1173 } // switch( mess.getMessageType() )
1174 } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
1175
1176 return kTRUE;
1177}
1178
1179void CbmMcbm2018MonitorMcbmPulser::FillTofEpochCycle(uint64_t ulCycleData)
1180{
1181 uint64_t ulEpochCycleVal = ulCycleData & gdpbv100::kulEpochCycleFieldSz;
1182 fvulTofCurrentEpochCycle[fuTofGdpbNr] = ulEpochCycleVal;
1183
1184 return;
1185}
1186
1187void CbmMcbm2018MonitorMcbmPulser::FillTofHitInfo(gdpbv100::Message mess)
1188{
1189 // UInt_t uChannel = mess.getGdpbHitChanId();
1190 // UInt_t uTot = mess.getGdpbHit32Tot();
1191 // UInt_t uFts = mess.getGdpbHitFineTs();
1192
1193 ULong64_t ulCurEpochGdpbGet4 = fvulTofCurrentEpochFull[fuTofGdpbNr];
1194
1195 // In Ep. Suppr. Mode, receive following epoch instead of previous
1196 if (0 < ulCurEpochGdpbGet4) ulCurEpochGdpbGet4--;
1197 else
1198 ulCurEpochGdpbGet4 = gdpbv100::kuEpochCounterSz; // Catch epoch cycle!
1199
1200 // ULong_t ulHitTime = mess.getMsgFullTime(ulCurEpochGdpbGet4);
1201 // Double_t dHitTime = mess.getMsgFullTimeD(ulCurEpochGdpbGet4);
1202
1203 // In 32b mode the coarse counter is already computed back to 112 FTS bins
1204 // => need to hide its contribution from the Finetime
1205 // => FTS = Fullt TS modulo 112
1206 // uFts = mess.getGdpbHitFullTs() % 112;
1207
1209 fvmTofGdpbHitsInMs[fuTofGdpbNr].push_back(gdpbv100::FullMessage(mess, ulCurEpochGdpbGet4));
1210}
1211
1212void CbmMcbm2018MonitorMcbmPulser::FillTofEpochInfo(gdpbv100::Message mess)
1213{
1214 ULong64_t ulEpochNr = mess.getGdpbEpEpochNb();
1215
1216 fvulTofCurrentEpoch[fuTofGdpbNr] = ulEpochNr;
1217 fvulTofCurrentEpochFull[fuTofGdpbNr] =
1218 ulEpochNr + gdpbv100::kulEpochCycleBins * fvulTofCurrentEpochCycle[fuTofGdpbNr];
1219
1220 fulTofCurrentEpochTime = mess.getMsgFullTime(ulEpochNr);
1221
1224 if (0 < ulEpochNr) mess.setGdpbEpEpochNb(ulEpochNr - 1);
1225 else
1226 mess.setGdpbEpEpochNb(gdpbv100::kuEpochCounterSz);
1227
1228 Int_t iBufferSize = fvmTofEpSupprBuffer[fuTofGdpbNr].size();
1229 if (0 < iBufferSize) {
1230 LOG(debug) << "Now processing stored messages for for gDPB " << fuTofGdpbNr << " with epoch number "
1231 << (fvulTofCurrentEpoch[fuTofGdpbNr] - 1);
1232
1235 std::stable_sort(fvmTofEpSupprBuffer[fuTofGdpbNr].begin(), fvmTofEpSupprBuffer[fuTofGdpbNr].begin());
1236
1237 for (Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++) {
1238 FillTofHitInfo(fvmTofEpSupprBuffer[fuTofGdpbNr][iMsgIdx]);
1239 } // for( Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++ )
1240
1241 fvmTofEpSupprBuffer[fuTofGdpbNr].clear();
1242 } // if( 0 < fvmTofEpSupprBuffer[fuTofGdpbNr] )
1243}
1244/****************** TOF Sync ******************************************/
1245
1246/****************** STS histos ****************************************/
1247/****************** STS histos ****************************************/
1248
1249/****************** TOF histos ****************************************/
1250/****************** TOF Histos ****************************************/
1251
1252void CbmMcbm2018MonitorMcbmPulser::Reset() {}
1253
1254void CbmMcbm2018MonitorMcbmPulser::Finish()
1255{
1256 /*
1257 LOG(info) << "-------------------------------------";
1258 LOG(info) << "CbmMcbm2018MonitorMcbmPulser statistics are ";
1259 LOG(info) << " Hit messages: " << fmMsgCounter[ stsxyter::MessType::Hit ] << "\n"
1260 << " Ts MSB messages: " << fmMsgCounter[ stsxyter::MessType::TsMsb ] << "\n"
1261 << " Dummy messages: " << fmMsgCounter[ stsxyter::MessType::Dummy ] << "\n"
1262 << " Epoch messages: " << fmMsgCounter[ stsxyter::MessType::Epoch ] << "\n"
1263 << " Empty messages: " << fmMsgCounter[ stsxyter::MessType::Empty ];
1264*/
1265 LOG(info) << "-------------------------------------";
1266
1267 SaveAllHistos(fsHistoFileFullname);
1268 SaveAllHistos();
1269}
1270
1271
1272void CbmMcbm2018MonitorMcbmPulser::SaveAllHistos(TString sFileName)
1273{
1275 TFile* oldFile = gFile;
1276 TDirectory* oldDir = gDirectory;
1277
1278 TFile* histoFile = nullptr;
1279 if ("" != sFileName) {
1280 // open separate histo file in recreate mode
1281 histoFile = new TFile(sFileName, "RECREATE");
1282 histoFile->cd();
1283 } // if( "" != sFileName )
1284
1285 /****************** STS Sync ******************************************/
1286 /****************** STS Sync ******************************************/
1287
1288 /****************** MUCH Sync *****************************************/
1289 /****************** MUCH Sync *****************************************/
1290
1291 /****************** TOF Sync ******************************************/
1292 /****************** TOF Sync ******************************************/
1293
1294 /****************** mCBM Sync *****************************************/
1295 gDirectory->mkdir("mcbmDt");
1296 gDirectory->cd("mcbmDt");
1297
1298 for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
1299 fvhMcbmTimeDiffToSelDpb[uDpb]->Reset();
1300 fvhMcbmTimeDiffToSelDpbWide[uDpb]->Reset();
1301 fvhMcbmTimeDiffToSelDpbTs[uDpb]->Reset();
1302
1303 fvhMcbmTimeDiffToDiamondEvoDpb[uDpb]->Write();
1304 fvhMcbmTimeDiffToDiamondWideEvoDpb[uDpb]->Write();
1305 fvhMcbmTimeDiffToDiamondTsEvoDpb[uDpb]->Write();
1306
1307 fvhMcbmTimeDiffToTofEvoDpb[uDpb]->Write();
1308 fvhMcbmTimeDiffToTofWideEvoDpb[uDpb]->Write();
1309 fvhMcbmTimeDiffToTofTsEvoDpb[uDpb]->Write();
1310 } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
1311
1312 gDirectory->cd("..");
1313 /****************** mCBM Sync *****************************************/
1314
1315 if ("" != sFileName) {
1316 // Restore original directory position
1317 histoFile->Close();
1318 } // if( "" != sFileName )
1319
1321 gFile = oldFile;
1322 gDirectory = oldDir;
1323}
1324void CbmMcbm2018MonitorMcbmPulser::ResetAllHistos()
1325{
1326 /****************** STS Sync ******************************************/
1327 /****************** STS Sync ******************************************/
1328
1329 /****************** MUCH Sync *****************************************/
1330 /****************** MUCH Sync *****************************************/
1331
1332 /****************** TOF Sync ******************************************/
1333 /****************** TOF Sync ******************************************/
1334
1335
1336 /****************** mCBM Sync *****************************************/
1337 for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
1338 fvhMcbmTimeDiffToSelDpb[uDpb]->Reset();
1339 fvhMcbmTimeDiffToSelDpbWide[uDpb]->Reset();
1340 fvhMcbmTimeDiffToSelDpbTs[uDpb]->Reset();
1341
1342 fvhMcbmTimeDiffToDiamondEvoDpb[uDpb]->Reset();
1343 fvhMcbmTimeDiffToDiamondWideEvoDpb[uDpb]->Reset();
1344 fvhMcbmTimeDiffToDiamondTsEvoDpb[uDpb]->Reset();
1345
1346 fvhMcbmTimeDiffToTofEvoDpb[uDpb]->Reset();
1347 fvhMcbmTimeDiffToTofWideEvoDpb[uDpb]->Reset();
1348 fvhMcbmTimeDiffToTofTsEvoDpb[uDpb]->Reset();
1349 } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
1350 /****************** mCBM Sync *****************************************/
1351}
1352
1353ClassImp(CbmMcbm2018MonitorMcbmPulser)
ClassImp
ClassImp(CbmConverterManager)
bMcbm2018WritePulser
Bool_t bMcbm2018WritePulser
Definition CbmMcbm2018MonitorMcbmPulser.cxx:46
bMcbm2018ResetPulser
Bool_t bMcbm2018ResetPulser
Definition CbmMcbm2018MonitorMcbmPulser.cxx:45
size
static constexpr size_t size()
Definition KfSimdPseudo.h:2
Int_t
int Int_t
Definition RootTypesDef.h:16
Bool_t
bool Bool_t
Definition RootTypesDef.h:15
CbmMcbm2018MonitorMcbmPulser::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition CbmMcbm2018MonitorMcbmPulser.h:124
CbmMcbm2018MonitorMcbmPulser::fvmStsSdpbHitsInTs
std::vector< std::vector< stsxyter::FinalHit > > fvmStsSdpbHitsInTs
All hits (time in bins, ADC in bins, asic, channel) in last TS, sorted with "<" operator.
Definition CbmMcbm2018MonitorMcbmPulser.h:137
CbmMcbm2018MonitorMcbmPulser::ProcessTofMs
Bool_t ProcessTofMs(const fles::Timeslice &ts, size_t uMsComp, UInt_t uMsIdx)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:1104
CbmMcbm2018MonitorMcbmPulser::fiRunStartDateTimeSec
Int_t fiRunStartDateTimeSec
Index of the DPB from which the MS currently unpacked is coming.
Definition CbmMcbm2018MonitorMcbmPulser.h:125
CbmMcbm2018MonitorMcbmPulser::fmStsDpbIdIndexMap
std::map< UInt_t, UInt_t > fmStsDpbIdIndexMap
Total number of Sts DPBs in system.
Definition CbmMcbm2018MonitorMcbmPulser.h:93
CbmMcbm2018MonitorMcbmPulser::fvuStsCurrentTsMsbCycle
std::vector< UInt_t > fvuStsCurrentTsMsbCycle
Current TS MSB for each DPB.
Definition CbmMcbm2018MonitorMcbmPulser.h:131
CbmMcbm2018MonitorMcbmPulser::fvmTofEpSupprBuffer
std::vector< std::vector< gdpbv100::Message > > fvmTofEpSupprBuffer
Buffer for suppressed epoch processing.
Definition CbmMcbm2018MonitorMcbmPulser.h:173
CbmMcbm2018MonitorMcbmPulser::SetNbMsInTs
virtual void SetNbMsInTs(size_t uCoreMsNb, size_t uOverlapMsNb)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:234
CbmMcbm2018MonitorMcbmPulser::FillStsEpochInfo
void FillStsEpochInfo(stsxyter::Message mess)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:1096
CbmMcbm2018MonitorMcbmPulser::fvmTofGdpbHitsInMs
std::vector< std::vector< gdpbv100::FullMessage > > fvmTofGdpbHitsInMs
Buffer for system sync check.
Definition CbmMcbm2018MonitorMcbmPulser.h:176
CbmMcbm2018MonitorMcbmPulser::fulTofCurrentTsIndex
uint64_t fulTofCurrentTsIndex
Running indices.
Definition CbmMcbm2018MonitorMcbmPulser.h:152
CbmMcbm2018MonitorMcbmPulser::fvhMcbmTimeDiffToDiamondTsEvoDpb
std::vector< TH2 * > fvhMcbmTimeDiffToDiamondTsEvoDpb
Definition CbmMcbm2018MonitorMcbmPulser.h:198
CbmMcbm2018MonitorMcbmPulser::fvmStsSdpbHitsInMs
std::vector< std::vector< stsxyter::FinalHit > > fvmStsSdpbHitsInMs
Current TS MSB cycle for DPB.
Definition CbmMcbm2018MonitorMcbmPulser.h:135
CbmMcbm2018MonitorMcbmPulser::fuMuchDpbIdx
UInt_t fuMuchDpbIdx
Map of DPB Identifier to DPB index.
Definition CbmMcbm2018MonitorMcbmPulser.h:94
CbmMcbm2018MonitorMcbmPulser::AddMsComponentToList
virtual void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:195
CbmMcbm2018MonitorMcbmPulser::FillStsTsMsbInfo
void FillStsTsMsbInfo(stsxyter::Message mess, UInt_t uMessIdx=0, UInt_t uMsIdx=0)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:1065
CbmMcbm2018MonitorMcbmPulser::fPrintMessCtrlSts
stsxyter::MessagePrintMask fPrintMessCtrlSts
Definition CbmMcbm2018MonitorMcbmPulser.h:116
CbmMcbm2018MonitorMcbmPulser::fvulStsCurrentTsMsb
std::vector< ULong64_t > fvulStsCurrentTsMsb
Bin size in s for the plots with date as X axis.
Definition CbmMcbm2018MonitorMcbmPulser.h:130
CbmMcbm2018MonitorMcbmPulser::fUnpackParTof
CbmMcbm2018TofPar * fUnpackParTof
Unpacking and mapping parameters for TOF.
Definition CbmMcbm2018MonitorMcbmPulser.h:96
CbmMcbm2018MonitorMcbmPulser::fvulTofCurrentEpochFull
std::vector< ULong64_t > fvulTofCurrentEpochFull
Definition CbmMcbm2018MonitorMcbmPulser.h:168
CbmMcbm2018MonitorMcbmPulser::fmTofDpbIdIndexMap
std::map< UInt_t, UInt_t > fmTofDpbIdIndexMap
Total number of GDPBs in the system.
Definition CbmMcbm2018MonitorMcbmPulser.h:98
CbmMcbm2018MonitorMcbmPulser::fvulTofCurrentEpochCycle
std::vector< ULong64_t > fvulTofCurrentEpochCycle
Definition CbmMcbm2018MonitorMcbmPulser.h:167
CbmMcbm2018MonitorMcbmPulser::fmMsgCounter
std::map< stsxyter::MessType, UInt_t > fmMsgCounter
Definition CbmMcbm2018MonitorMcbmPulser.h:121
CbmMcbm2018MonitorMcbmPulser::kuTofBytesPerMessage
static const UInt_t kuTofBytesPerMessage
TODO => move to the message class!!
Definition CbmMcbm2018MonitorMcbmPulser.h:109
CbmMcbm2018MonitorMcbmPulser::CreateStsHistograms
void CreateStsHistograms()
All hits (time in bins, ADC in bins, asic, channel) in last TS, sorted with "<" operator.
Definition CbmMcbm2018MonitorMcbmPulser.cxx:243
CbmMcbm2018MonitorMcbmPulser::fvmTofGdpbHitsInTs
std::vector< std::vector< gdpbv100::FullMessage > > fvmTofGdpbHitsInTs
Definition CbmMcbm2018MonitorMcbmPulser.h:177
CbmMcbm2018MonitorMcbmPulser::fvhMcbmTimeDiffToDiamondWideEvoDpb
std::vector< TH2 * > fvhMcbmTimeDiffToDiamondWideEvoDpb
Definition CbmMcbm2018MonitorMcbmPulser.h:197
CbmMcbm2018MonitorMcbmPulser::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition CbmMcbm2018MonitorMcbmPulser.h:123
CbmMcbm2018MonitorMcbmPulser::FillStsHitInfo
void FillStsHitInfo(stsxyter::Message mess, const UInt_t &uMsIdx)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:993
CbmMcbm2018MonitorMcbmPulser::fiBinSizeDatePlots
Int_t fiBinSizeDatePlots
Start of run time since "epoch" in s, for the plots with date as X axis.
Definition CbmMcbm2018MonitorMcbmPulser.h:126
CbmMcbm2018MonitorMcbmPulser::ProcessStsMs
Bool_t ProcessStsMs(const fles::Timeslice &ts, size_t uMsComp, UInt_t uMsIdx)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:907
CbmMcbm2018MonitorMcbmPulser::DoUnpack
virtual Bool_t DoUnpack(const fles::Timeslice &ts, size_t component)
Definition CbmMcbm2018MonitorMcbmPulser.cxx:518
h
Data class with information on a STS local track.
gdpbv100::Message::getGdpbHitIs24b
uint16_t getGdpbHitIs24b() const
Definition gDpbMessv100.h:219
gdpbv100::Message::getGdpbEpEpochNb
uint32_t getGdpbEpEpochNb() const
Definition gDpbMessv100.h:232
gdpbv100::Message::setGdpbEpEpochNb
void setGdpbEpEpochNb(uint32_t v)
Definition gDpbMessv100.h:282
gdpbv100::Message::getGdpbGenChipId
uint16_t getGdpbGenChipId() const
Definition gDpbMessv100.h:215
gdpbv100::Message::printDataCout
void printDataCout(unsigned kind=msg_print_Prefix|msg_print_Data, uint32_t epoch=0) const
Print message in human readable format to cout.
Definition gDpbMessv100.cxx:165
gdpbv100::Message::getMessageType
uint8_t getMessageType() const
Returns the message type. Valid for all message types. 4 bit.
Definition gDpbMessv100.h:207
gdpbv100::Message::getMsgFullTime
uint64_t getMsgFullTime(uint64_t epoch) const
Returns expanded and adjusted time of message (in ns)
Definition gDpbMessv100.cxx:95
stsxyter::Message::GetHitAdc
XPU_D uint16_t GetHitAdc() const
For Hit data: Returns ADC value (5 bit field)
Definition StsXyterMessage.h:267
stsxyter::Message::GetHitChannel
XPU_D uint16_t GetHitChannel() const
For Hit data: Returns StsXYTER channel number (7 bit field)
Definition StsXyterMessage.h:264
stsxyter::Message::PrintMess
bool PrintMess(std::ostream &os, MessagePrintMask ctrl=MessagePrintMask::msg_print_Human, bool bBinning=true) const
Definition StsXyterMessage.cxx:22
stsxyter::Message::GetLinkIndex
XPU_D uint16_t GetLinkIndex() const
For all data: Returns the (global) index of the eLink on which the message was received (n bit field)
Definition StsXyterMessage.h:242
stsxyter::Message::GetMessType
XPU_D MessType GetMessType() const
Returns the message type, see enum MessType.
Definition StsXyterMessage.h:250
stsxyter::Message::GetHitTime
XPU_D uint16_t GetHitTime() const
For Hit data: Returns timestamp (8 bit field, 2 MSB bits overlap removed)
Definition StsXyterMessage.h:276
stsxyter::Message::GetTsMsbVal
XPU_D uint32_t GetTsMsbVal() const
For TS MSB data: Returns the TS MSB 22 bit field)
Definition StsXyterMessage.h:325
gdpbv100::kulEpochCycleBins
const uint64_t kulEpochCycleBins
Definition gDpbMessv100.h:45
gdpbv100::kuChipIdMergedEpoch
const uint32_t kuChipIdMergedEpoch
Definition gDpbMessv100.h:52
gdpbv100::kuEpochCounterSz
const uint32_t kuEpochCounterSz
Definition gDpbMessv100.h:43
gdpbv100::kulEpochCycleFieldSz
const uint64_t kulEpochCycleFieldSz
Definition gDpbMessv100.h:50
stsxyter::kulTsCycleNbBins
static constexpr uint64_t kulTsCycleNbBins
Definition StsXyterMessage.h:158
stsxyter::kuHitNbTsBins
static constexpr uint32_t kuHitNbTsBins
Definition StsXyterMessage.h:155
stsxyter::kdClockCycleNs
static constexpr double kdClockCycleNs
Definition StsXyterMessage.h:163
stsxyter::MessType
MessType
Message types.
Definition StsXyterMessage.h:35