CbmRoot
CbmMcbm2018MonitorMcbmSync.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018MonitorMcbmSync -----
4 // ----- Created 11/05/18 by P.-A. Loizeau -----
5 // ----- -----
6 // -----------------------------------------------------------------------------
7 
8 #include "CbmMcbm2018MonitorMcbmSync.h"
9 
10 // Data
11 
12 // CbmRoot
13 #include "CbmMcbm2018StsPar.h"
14 #include "CbmMcbm2018TofPar.h"
15 
16 // FairRoot
17 #include "FairLogger.h"
18 #include "FairRootManager.h"
19 #include "FairRun.h"
20 #include "FairRunOnline.h"
21 #include "FairRuntimeDb.h"
22 
23 // Root
24 #include "TClonesArray.h"
25 #include "TF1.h"
26 #include "THttpServer.h"
27 #include "TMath.h"
28 #include "TROOT.h"
29 #include "TRandom.h"
30 #include "TString.h"
31 #include "TStyle.h"
32 #include <TFile.h>
33 
34 // C++11
35 
36 // C/C++
37 #include <iomanip>
38 #include <iostream>
39 #include <stdint.h>
40 
41 Bool_t bMcbm2018ResetSync = kFALSE;
42 Bool_t bMcbm2018WriteSync = kFALSE;
43 /*
44 Bool_t bMcbm2018ResetSync = kFALSE;
45 Bool_t bMcbm2018WriteSync = kFALSE;
46 */
47 /*
48 Bool_t bMcbm2018SyncResetHistosTof = kFALSE;
49 Bool_t bMcbm2018SyncSaveHistosTof = kFALSE;
50 Bool_t bMcbm2018SyncUpdateZoomedFit = kFALSE;
51 */
52 
53 CbmMcbm2018MonitorMcbmSync::CbmMcbm2018MonitorMcbmSync()
54  : CbmMcbmUnpack()
55  , fvMsComponentsListSts()
56  , fvMsComponentsListTof()
57  , fuNbCoreMsPerTs(0)
58  , fuNbOverMsPerTs(0)
59  , fbIgnoreOverlapMs(kFALSE)
60  , fUnpackParSts(nullptr)
61  , fuStsNrOfDpbs(0)
62  , fmStsDpbIdIndexMap()
63  , fuMuchDpbIdx(1)
64  , fUnpackParTof(nullptr)
65  , fuTofNrOfDpbs(0)
66  , fmTofDpbIdIndexMap()
67  , fuDiamondDpbIdx(2)
68  , fuTotalNrOfDpb(0)
69  , fdStsTofOffsetNs(0.0)
70  , fdMuchTofOffsetNs(0.0)
71  , fbUseBestPair(kFALSE)
72  , fbTsLevelAna(kFALSE)
73  , fsHistoFileFullname("data/mCBMsyncHistos.root")
74  , fbPrintMessages(kFALSE)
75  , fPrintMessCtrlSts(stsxyter::MessagePrintMask::msg_print_Human)
76  , fulCurrentTsIdx(0)
77  , fulCurrentMsIdx(0)
78  , fmMsgCounter()
79  , fuCurrentEquipmentId(0)
80  , fuCurrDpbId(0)
81  , fuCurrDpbIdx(0)
82  , fiRunStartDateTimeSec(-1)
83  , fiBinSizeDatePlots(-1)
84  , fvulStsCurrentTsMsb()
85  , fvuStsCurrentTsMsbCycle()
86  , fvmStsSdpbHitsInMs()
87  , fvmStsSdpbHitsInTs()
88  , fulTofCurrentTsIndex(0)
89  , fuTofCurrentMs(0)
90  , fdTofMsIndex(0)
91  , fuTofGdpbId(0)
92  , fuTofGdpbNr(0)
93  , fiTofEquipmentId(0)
94  , fviTofMsgCounter(1 + gdpbv100::MSG_STAR_TRI_D, 0)
95  , fvulTofCurrentEpoch()
96  , fvulTofCurrentEpochCycle()
97  , fvulTofCurrentEpochFull()
98  , fulTofCurrentEpochTime(0)
99  , fvmTofEpSupprBuffer()
100  , fvmTofGdpbHitsInMs()
101  , fvmTofGdpbHitsInTs()
102  , fhMcbmHitsNbPerMs()
103  , fhMcbmTimeDiffToDiamond()
104  , fhMcbmTimeDiffToDiamondWide()
105  , fhMcbmTimeDiffToDiamondTs()
106  , fhMcbmTimeDiffToMuch()
107  , fhMcbmTimeDiffToMuchWide()
108  , fhMcbmTimeDiffToMuchTs()
109  , fhMcbmStsTimeDiffToMuchVsAdc()
110  , fhMcbmStsTimeDiffToMuchWideVsAdc()
111  , fhMcbmStsTimeDiffToMuchTsVsAdc()
112  , fvhMcbmTimeDiffToDiamondEvoDpb()
113  , fvhMcbmTimeDiffToDiamondWideEvoDpb()
114  , fvhMcbmTimeDiffToDiamondTsEvoDpb()
115  , fdSpillStartA(0.0)
116  , fdSpillStartB(0.0)
117  , fdSpillStartC(-1.0)
118  , fvhHitsTimeEvoSpillA()
119  , fvhHitsTimeEvoSpillB()
120  , fvhMcbmTimeDiffToDiamondEvoSpillA()
121  , fvhMcbmTimeDiffToDiamondEvoSpillB()
122  , fvhMcbmTimeDiffToMuchEvoSpillA()
123  , fvhMcbmTimeDiffToMuchEvoSpillB() {}
124 
125 CbmMcbm2018MonitorMcbmSync::~CbmMcbm2018MonitorMcbmSync() {}
126 
127 Bool_t CbmMcbm2018MonitorMcbmSync::Init() {
128  LOG(info) << "Initializing flib StsXyter unpacker for STS";
129 
130  FairRootManager* ioman = FairRootManager::Instance();
131  if (ioman == nullptr) { LOG(fatal) << "No FairRootManager instance"; }
132 
133  return kTRUE;
134 }
135 
136 void CbmMcbm2018MonitorMcbmSync::SetParContainers() {
137  LOG(info) << "Setting parameter containers for " << GetName();
138  fUnpackParSts =
139  (CbmMcbm2018StsPar*) (FairRun::Instance()->GetRuntimeDb()->getContainer(
140  "CbmMcbm2018StsPar"));
141  fUnpackParTof =
142  (CbmMcbm2018TofPar*) (FairRun::Instance()->GetRuntimeDb()->getContainer(
143  "CbmMcbm2018TofPar"));
144 }
145 
146 
147 Bool_t CbmMcbm2018MonitorMcbmSync::InitContainers() {
148  LOG(info) << "Init parameter containers for " << GetName();
149 
150  Bool_t bReInit = ReInitContainers();
151  CreateStsHistograms();
152  CreateTofHistograms();
153  CreateMcbmHistograms();
154 
155  return bReInit;
156 }
157 
158 Bool_t CbmMcbm2018MonitorMcbmSync::ReInitContainers() {
159  LOG(info) << "ReInit parameter containers for " << GetName();
160 
161  /***************** STS parameters *************************************/
162  fuStsNrOfDpbs = fUnpackParSts->GetNrOfDpbs();
163  LOG(info) << "Nr. of STS DPBs: " << fuStsNrOfDpbs;
164 
165  fmStsDpbIdIndexMap.clear();
166  for (UInt_t uDpb = 0; uDpb < fuStsNrOfDpbs; ++uDpb) {
167  fmStsDpbIdIndexMap[fUnpackParSts->GetDpbId(uDpb)] = uDpb;
168  LOG(info) << "Eq. ID for DPB #" << std::setw(2) << uDpb << " = 0x"
169  << std::setw(4) << std::hex << fUnpackParSts->GetDpbId(uDpb)
170  << std::dec << " => "
171  << fmStsDpbIdIndexMap[fUnpackParSts->GetDpbId(uDpb)];
172  } // for( UInt_t uDpb = 0; uDpb < fuStsNrOfDpbs; ++uDpb )
173 
174  fvulStsCurrentTsMsb.resize(fuStsNrOfDpbs, 0);
175  fvuStsCurrentTsMsbCycle.resize(fuStsNrOfDpbs, 0);
176  fvmStsSdpbHitsInMs.resize(fuStsNrOfDpbs);
177  fvmStsSdpbHitsInTs.resize(fuStsNrOfDpbs);
178  /***************** STS parameters *************************************/
179 
180  /***************** TOF parameters *************************************/
181  fuTofNrOfDpbs = fUnpackParTof->GetNrOfGdpbs();
182  LOG(info) << "Nr. of Tof GDPBs: " << fuTofNrOfDpbs;
183 
184  fmTofDpbIdIndexMap.clear();
185  for (UInt_t i = 0; i < fuTofNrOfDpbs; ++i) {
186  fmTofDpbIdIndexMap[fUnpackParTof->GetGdpbId(i)] = i;
187  LOG(info) << "GDPB Id of TOF " << i << " : " << std::hex
188  << fUnpackParTof->GetGdpbId(i) << std::dec;
189  } // for( UInt_t i = 0; i < fuTofNrOfDpbs; ++i )
190 
192  fvulTofCurrentEpoch.resize(fuTofNrOfDpbs, 0);
193  fvulTofCurrentEpochCycle.resize(fuTofNrOfDpbs, 0);
194  fvulTofCurrentEpochFull.resize(fuTofNrOfDpbs, 0);
195  fvmTofEpSupprBuffer.resize(fuTofNrOfDpbs);
196  fvmTofGdpbHitsInMs.resize(fuTofNrOfDpbs);
197  fvmTofGdpbHitsInTs.resize(fuTofNrOfDpbs);
198  /***************** TOF parameters *************************************/
199 
200  return kTRUE;
201 }
202 
203 void CbmMcbm2018MonitorMcbmSync::AddMsComponentToList(size_t component,
204  UShort_t usDetectorId) {
205  switch (usDetectorId) {
206  case 0x10: //fles::SubsystemIdentifier::STS:
207  {
208  AddMsComponentToListSts(component);
209  break;
210  } // case 0x10:
211  case 0x60: //fles::SubsystemIdentifier::RPC:
212  {
213  AddMsComponentToListTof(component);
214  break;
215  } // case 0x60:
216  default: {
217  LOG(warning) << "CbmMcbm2018MonitorStsSync::AddMsComponentToList => "
218  << "Ignore component " << component << " as detector id "
219  << usDetectorId << " is not supported by this unpacker.";
220  break;
221  } // default:
222  } // switch( iDetectorId )
223 }
224 void CbmMcbm2018MonitorMcbmSync::AddMsComponentToListSts(size_t component) {
226  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsListSts.size(); ++uCompIdx)
227  if (component == fvMsComponentsListSts[uCompIdx]) return;
228 
230  fvMsComponentsListSts.push_back(component);
231 }
232 void CbmMcbm2018MonitorMcbmSync::AddMsComponentToListTof(size_t component) {
234  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsListTof.size(); ++uCompIdx)
235  if (component == fvMsComponentsListTof[uCompIdx]) return;
236 
238  fvMsComponentsListTof.push_back(component);
239 }
240 void CbmMcbm2018MonitorMcbmSync::SetNbMsInTs(size_t uCoreMsNb,
241  size_t uOverlapMsNb) {
242  fuNbCoreMsPerTs = uCoreMsNb;
243  fuNbOverMsPerTs = uOverlapMsNb;
244 
245  // UInt_t uNbMsTotal = fuNbCoreMsPerTs + fuNbOverMsPerTs;
246 }
247 
248 /***************** STS Histograms *************************************/
249 void CbmMcbm2018MonitorMcbmSync::CreateStsHistograms() {
250  TString sHistName {""};
251  TString title {""};
252  /*
253  sHistName = "hPulserMessageType";
254  title = "Nb of message for each type; Type";
255  fhStsMessType = new TH1I(sHistName, title, 5, 0., 5.);
256  fhStsMessType->GetXaxis()->SetBinLabel( 1, "Dummy");
257  fhStsMessType->GetXaxis()->SetBinLabel( 2, "Hit");
258  fhStsMessType->GetXaxis()->SetBinLabel( 3, "TsMsb");
259  fhStsMessType->GetXaxis()->SetBinLabel( 4, "Epoch");
260  fhStsMessType->GetXaxis()->SetBinLabel( 5, "Empty");
261 
262  // Online histo browser commands
263  THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
264  if( server )
265  {
266  server->Register("/StsRaw", fhStsMessType );
267 
268  server->RegisterCommand("/Reset_All_Pulser", "bMcbm2018ResetSync=kTRUE");
269  server->RegisterCommand("/Write_All_Pulser", "bMcbm2018WriteSync=kTRUE");
270 
271  server->Restrict("/Reset_All_Pulser", "allow=admin");
272  server->Restrict("/Write_All_Pulser", "allow=admin");
273  } // if( server )
274 */
276  /*
277  Double_t w = 10;
278  Double_t h = 10;
279 
280  // Summary per StsXyter
281  for( UInt_t uXyterIdx = 0; uXyterIdx < fuStsNbStsXyters; ++uXyterIdx )
282  {
283  TCanvas* cStsSumm = new TCanvas( Form("cStsSum_%03u", uXyterIdx ),
284  Form("Summary plots for StsXyter %03u", uXyterIdx ),
285  w, h);
286  cStsSumm->Divide( 2, 2 );
287 
288  cStsSumm->cd(1);
289  gPad->SetLogy();
290  fhStsChanCntRaw[ uXyterIdx ]->Draw();
291 
292  cStsSumm->cd(2);
293  gPad->SetLogz();
294  fhStsChanAdcRaw[ uXyterIdx ]->Draw( "colz" );
295 
296  cStsSumm->cd(3);
297  gPad->SetLogz();
298  fhStsChanHitRateEvo[ uXyterIdx ]->Draw( "colz" );
299 
300  cStsSumm->cd(4);
301 // gPad->SetLogy();
302  fhStsChanAdcRawProf[ uXyterIdx ]->Draw();
303  } // for( UInt_t uXyterIdx = 0; uXyterIdx < fuStsNbStsXyters; ++uXyterIdx )
304 
305 //====================================================================//
306 */
307  /*****************************/
308  LOG(info) << "Done Creating STS Histograms";
309 }
310 /***************** STS Histograms *************************************/
311 
312 /***************** TOF Histograms *************************************/
313 void CbmMcbm2018MonitorMcbmSync::CreateTofHistograms() {
314  TString sHistName {""};
315  TString title {""};
316 
317  /*******************************************************************/
318  /*
319 
320  sHistName = "hMessageType";
321  title = "Nb of message for each type; Type";
322  // Test Big Data readout with plotting
323  fhTofMessType = new TH1I(sHistName, title, 1 + gdpbv100::MSG_STAR_TRI_A, 0., 1 + gdpbv100::MSG_STAR_TRI_A);
324  fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_HIT, "HIT");
325  fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_EPOCH, "EPOCH");
326  fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SLOWC, "SLOWC");
327  fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SYST, "SYST");
328  fhTofMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_A, "MSG_STAR_TRI");
329 */
330  /*******************************************************************/
331  /*
332  THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
333  if( server )
334  {
335  server->Register("/TofRaw", fhTofMessType );
336 
337  server->RegisterCommand("/Reset_All_TOF", "bMcbm2018SyncResetHistosTof=kTRUE");
338  server->RegisterCommand("/Save_All_Tof", "bMcbm2018SyncSaveHistosTof=kTRUE");
339  server->RegisterCommand("/Update_PulsFit", "bMcbm2018SyncUpdateZoomedFit=kTRUE");
340 
341  server->Restrict("/Reset_All_Tof", "allow=admin");
342  server->Restrict("/Save_All_Tof", "allow=admin");
343  server->Restrict("/Update_PulsFit", "allow=admin");
344  } // if( server )
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 ************************************/
385 void CbmMcbm2018MonitorMcbmSync::CreateMcbmHistograms() {
386  TString sHistName {""};
387  TString sHistTitle {""};
388 
389  fuTotalNrOfDpb = fuStsNrOfDpbs + fuTofNrOfDpbs;
390 
391  sHistName = "hMcbmHitsNbPerMs";
392  sHistTitle = "Nb of hits per DPB; Nb of hits []; DPB []";
393  fhMcbmHitsNbPerMs = new TH2D(sHistName,
394  sHistTitle,
395  1000.0,
396  0.,
397  1000.,
398  fuTotalNrOfDpb,
399  0.,
400  fuTotalNrOfDpb);
401 
402  sHistName = "hMcbmTimeDiffToDiamond";
403  sHistTitle = "Time difference for STS and TOF hits, per DPB, against any "
404  "Diamond hit; <tn - tDia> [ns]; DPB []";
405  fhMcbmTimeDiffToDiamond = new TH2D(sHistName,
406  sHistTitle,
407  1001,
408  -500.5 * stsxyter::kdClockCycleNs,
409  500.5 * stsxyter::kdClockCycleNs,
410  fuTotalNrOfDpb,
411  0.,
412  fuTotalNrOfDpb);
413  sHistName = "hMcbmTimeDiffToDiamondWide";
414  sHistTitle = "Time difference for STS and TOF hits, per DPB, against any "
415  "Diamond hit, wide range; <tn - tDia> [us]; DPB []";
416  fhMcbmTimeDiffToDiamondWide = new TH2D(sHistName,
417  sHistTitle,
418  6000.0,
419  -300.,
420  300.,
421  fuTotalNrOfDpb,
422  0.,
423  fuTotalNrOfDpb);
424  sHistName = "hMcbmTimeDiffToDiamondTs";
425  sHistTitle = "Time difference for STS and TOF hits, per DPB, against any "
426  "Diamond hit, TS range; <tn - tDia> [ms]; DPB []";
427  fhMcbmTimeDiffToDiamondTs = new TH2D(sHistName,
428  sHistTitle,
429  2000.0,
430  -10.,
431  10.,
432  fuTotalNrOfDpb,
433  0.,
434  fuTotalNrOfDpb);
435 
436  sHistName = "hMcbmTimeDiffToMuch";
437  sHistTitle = "Time difference for STS and TOF hits, per DPB, against any "
438  "Much hit; <tn - tMuch> [ns]; DPB []";
439  fhMcbmTimeDiffToMuch = new TH2D(sHistName,
440  sHistTitle,
441  1001,
442  -500.5 * stsxyter::kdClockCycleNs,
443  500.5 * stsxyter::kdClockCycleNs,
444  fuTotalNrOfDpb,
445  0.,
446  fuTotalNrOfDpb);
447  sHistName = "hMcbmTimeDiffToMuchWide";
448  sHistTitle = "Time difference for STS and TOF hits, per DPB, against any "
449  "Much hit, wide range; <tn - tMuch> [us]; DPB []";
450  fhMcbmTimeDiffToMuchWide = new TH2D(sHistName,
451  sHistTitle,
452  6000.0,
453  -300.,
454  300.,
455  fuTotalNrOfDpb,
456  0.,
457  fuTotalNrOfDpb);
458  sHistName = "hMcbmTimeDiffToMuchTs";
459  sHistTitle = "Time difference for STS and TOF hits, per DPB, against any "
460  "Much hit, TS range; <tn - tMuch> [ms]; DPB []";
461  fhMcbmTimeDiffToMuchTs = new TH2D(sHistName,
462  sHistTitle,
463  2000.0,
464  -10.,
465  10.,
466  fuTotalNrOfDpb,
467  0.,
468  fuTotalNrOfDpb);
469 
471  sHistName = "hMcbmStsTimeDiffToMuchVsAdc";
472  sHistTitle = "Time difference for STS hits against any Much hit vs STS hit "
473  "ADC; <tSts - tMuch> [ns]; ADC Sts [bin]";
474  fhMcbmStsTimeDiffToMuchVsAdc = new TH2D(sHistName,
475  sHistTitle,
476  1001,
477  -500.5 * stsxyter::kdClockCycleNs,
478  500.5 * stsxyter::kdClockCycleNs,
479  stsxyter::kuHitNbAdcBins,
480  -0.5,
481  stsxyter::kuHitNbAdcBins - 0.5);
482  sHistName = "hMcbmStsTimeDiffToMuchWideVsAdc";
483  sHistTitle = "Time difference for STS hits against any Much hit vs STS hit "
484  "ADC, wide range; <tSts - tMuch> [us]; ADC Sts [bin]";
485  fhMcbmStsTimeDiffToMuchWideVsAdc = new TH2D(sHistName,
486  sHistTitle,
487  6000.0,
488  -300.,
489  300.,
490  stsxyter::kuHitNbAdcBins,
491  -0.5,
492  stsxyter::kuHitNbAdcBins - 0.5);
493  sHistName = "hMcbmStsTimeDiffToMuchTsVsAdc";
494  sHistTitle = "Time difference for STS hits against any Much hit vs STS hit "
495  "ADC, TS range; <tSts - tMuch> [ms]; ADC Sts [bin]";
496  fhMcbmStsTimeDiffToMuchTsVsAdc = new TH2D(sHistName,
497  sHistTitle,
498  2000.0,
499  -10.,
500  10.,
501  stsxyter::kuHitNbAdcBins,
502  -0.5,
503  stsxyter::kuHitNbAdcBins - 0.5);
504 
505  for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
506 
507  sHistName = Form("hMcbmTimeDiffToDiamondEvoDpb%02u", uDpb);
508  sHistTitle =
509  Form("Evolution of time difference for STS or TOF hits from DPB %02u "
510  "against any Diamond hit; TS []; <tn - tDia> [ns]",
511  uDpb);
512  fvhMcbmTimeDiffToDiamondEvoDpb.push_back(
513  new TH2D(sHistName,
514  sHistTitle,
515  2000.0,
516  0.,
517  200000.,
518  1001,
519  -500.5 * stsxyter::kdClockCycleNs,
520  500.5 * stsxyter::kdClockCycleNs));
521 
522  sHistName = Form("hMcbmTimeDiffToDiamondWideEvoDpb%02u", uDpb);
523  sHistTitle =
524  Form("Evolution of time difference for STS or TOF hits from DPB %02u "
525  "against any Diamond hit, wide range; TS []; <tn - tDia> [us]",
526  uDpb);
527  fvhMcbmTimeDiffToDiamondWideEvoDpb.push_back(new TH2D(
528  sHistName, sHistTitle, 2000.0, 0., 200000., 4000.0, -200., 200.));
529 
530  sHistName = Form("hMcbmTimeDiffToDiamondTsEvoDpb%02u", uDpb);
531  sHistTitle =
532  Form("Evolution of time difference for STS or TOF hits from DPB %02u "
533  "against any Diamond hit, TS range; TS []; <tn - tDia> [ms]",
534  uDpb);
535  fvhMcbmTimeDiffToDiamondTsEvoDpb.push_back(
536  new TH2D(sHistName, sHistTitle, 2000.0, 0., 200000., 200.0, -10., 10.));
537 
538  if (fdSpillStartA < fdSpillStartC) {
539  sHistName = Form("hHitsTimeEvoSpillADpb%02u", uDpb);
540  sHistTitle = Form("Evolution of hit counts VS time for DPB %02u in the "
541  "first spill; tHit [s]; counts",
542  uDpb);
543  fvhHitsTimeEvoSpillA.push_back(
544  new TH1D(sHistName,
545  sHistTitle,
546  (fdSpillStartB - fdSpillStartA) * 1e5,
547  fdSpillStartA - 0.1,
548  fdSpillStartB));
549 
550  sHistName = Form("hHitsTimeEvoSpillBDpb%02u", uDpb);
551  sHistTitle = Form("Evolution of hit counts VS time for DPB %02u in the "
552  "second spill; tHit [s]; counts",
553  uDpb);
554  fvhHitsTimeEvoSpillB.push_back(
555  new TH1D(sHistName,
556  sHistTitle,
557  (fdSpillStartC - fdSpillStartB) * 1e5,
558  fdSpillStartB - 0.1,
559  fdSpillStartC));
560 
561  sHistName = Form("hMcbmTimeDiffToDiamondEvoSpillADpb%02u", uDpb);
562  sHistTitle = Form("Evolution of Time Diff to diam VS time for DPB %02u "
563  "in the first spill; tHit [s]; <tn - tDia> [us]",
564  uDpb);
565  fvhMcbmTimeDiffToDiamondEvoSpillA.push_back(
566  new TH2D(sHistName,
567  sHistTitle,
568  (fdSpillStartB - fdSpillStartA) * 1e2,
569  fdSpillStartA - 0.1,
570  fdSpillStartB,
571  6000.0,
572  -300.,
573  300.));
574 
575  sHistName = Form("hMcbmTimeDiffToDiamondEvoSpillBDpb%02u", uDpb);
576  sHistTitle = Form("Evolution of Time Diff to diam VS time for DPB %02u "
577  "in the second spill; tHit [s]; <tn - tDia> [us]",
578  uDpb);
579  fvhMcbmTimeDiffToDiamondEvoSpillB.push_back(
580  new TH2D(sHistName,
581  sHistTitle,
582  (fdSpillStartC - fdSpillStartB) * 1e2,
583  fdSpillStartB - 0.1,
584  fdSpillStartC,
585  6000.0,
586  -300.,
587  300.));
588 
589  sHistName = Form("hMcbmTimeDiffToMuchEvoSpillADpb%02u", uDpb);
590  sHistTitle = Form("Evolution of Time Diff to MUCH VS time for DPB %02u "
591  "in the first spill; tHit [s]; <tn - tDia> [us]",
592  uDpb);
593  fvhMcbmTimeDiffToMuchEvoSpillA.push_back(
594  new TH2D(sHistName,
595  sHistTitle,
596  (fdSpillStartB - fdSpillStartA) * 1e2,
597  fdSpillStartA - 0.1,
598  fdSpillStartB,
599  6000.0,
600  -300.,
601  300.));
602 
603  sHistName = Form("hMcbmTimeDiffToMuchEvoSpillBDpb%02u", uDpb);
604  sHistTitle = Form("Evolution of Time Diff to MUCH VS time for DPB %02u "
605  "in the second spill; tHit [s]; <tn - tDia> [us]",
606  uDpb);
607  fvhMcbmTimeDiffToMuchEvoSpillB.push_back(
608  new TH2D(sHistName,
609  sHistTitle,
610  (fdSpillStartC - fdSpillStartB) * 1e2,
611  fdSpillStartB - 0.1,
612  fdSpillStartC,
613  6000.0,
614  -300.,
615  300.));
616  } // if( fdSpillStartA < fdSpillStartC )
617  } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
618  THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
619  if (server) {
620  server->Register("/mCbmDt", fhMcbmTimeDiffToDiamond);
621  server->Register("/mCbmDt", fhMcbmTimeDiffToDiamondWide);
622  server->Register("/mCbmDt", fhMcbmTimeDiffToDiamondTs);
623 
624  server->Register("/mCbmDt", fhMcbmTimeDiffToMuch);
625  server->Register("/mCbmDt", fhMcbmTimeDiffToMuchWide);
626  server->Register("/mCbmDt", fhMcbmTimeDiffToMuchTs);
627 
628  server->Register("/mCbmDt", fhMcbmStsTimeDiffToMuchVsAdc);
629  server->Register("/mCbmDt", fhMcbmStsTimeDiffToMuchWideVsAdc);
630  server->Register("/mCbmDt", fhMcbmStsTimeDiffToMuchTsVsAdc);
631 
632  for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
633  server->Register("/mCbmDt", fvhMcbmTimeDiffToDiamondEvoDpb[uDpb]);
634  server->Register("/mCbmDt", fvhMcbmTimeDiffToDiamondWideEvoDpb[uDpb]);
635  server->Register("/mCbmDt", fvhMcbmTimeDiffToDiamondTsEvoDpb[uDpb]);
636  } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
637 
638  server->RegisterCommand("/Reset_All", "bMcbm2018ResetSync=kTRUE");
639  server->RegisterCommand("/Save_All", "bMcbm2018WriteSync=kTRUE");
640 
641  server->Restrict("/Reset_All", "allow=admin");
642  server->Restrict("/Save_All", "allow=admin");
643  } // if( server )
644 
645  Double_t w = 10;
646  Double_t h = 10;
648  TCanvas* cSyncMcbm = new TCanvas(
649  "cSyncMcbm",
650  "Time difference for STS and TOF hits, per DPB, against any Diamond hit",
651  w,
652  h);
653  cSyncMcbm->Divide(2);
654 
655  cSyncMcbm->cd(1);
656  gPad->SetGridx();
657  gPad->SetGridy();
658  gPad->SetLogz();
659  fhMcbmTimeDiffToDiamond->Draw("colz");
660 
661  cSyncMcbm->cd(2);
662  gPad->SetGridx();
663  gPad->SetGridy();
664  gPad->SetLogz();
665  fhMcbmTimeDiffToDiamondWide->Draw("colz");
666  /*****************************/
667  LOG(info) << "Done Creating mCBM Histograms";
668 }
669 /***************** mCBM Histograms ************************************/
670 
671 Bool_t CbmMcbm2018MonitorMcbmSync::DoUnpack(const fles::Timeslice& ts,
672  size_t component) {
674  if (bMcbm2018ResetSync) {
675  ResetAllHistos();
676  bMcbm2018ResetSync = kFALSE;
677  } // if( bMcbm2018ResetSync )
678  if (bMcbm2018WriteSync) {
679  SaveAllHistos(fsHistoFileFullname);
680  bMcbm2018WriteSync = kFALSE;
681  } // if( bMcbm2018WriteSync )
682 
683  LOG(debug) << "Timeslice contains " << ts.num_microslices(component)
684  << "microslices.";
685  fulCurrentTsIdx = ts.index();
686 
688  if (0 == fulCurrentTsIdx) return kTRUE;
689 
690  if (fulCurrentTsIdx < 30) LOG(info) << Form("TS %2llu", fulCurrentTsIdx);
691 
692  // Ignore overlap ms if flag set by user
693  UInt_t uNbMsLoop = fuNbCoreMsPerTs;
694  if (kFALSE == fbIgnoreOverlapMs) uNbMsLoop += fuNbOverMsPerTs;
695 
696  // Loop over core microslices (and overlap ones if chosen)
697  for (UInt_t uMsIdx = 0; uMsIdx < uNbMsLoop; uMsIdx++) {
698  // Loop over registered STS components
699  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsListSts.size();
700  ++uMsCompIdx) {
701  UInt_t uMsComp = fvMsComponentsListSts[uMsCompIdx];
702 
703  if (kFALSE == ProcessStsMs(ts, uMsComp, uMsIdx)) return kFALSE;
704  } // for( UInt_t uMsComp = 0; uMsComp < fvMsComponentsListSts.size(); ++uMsComp )
705 
706  // Loop over registered TOF components
707  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsListTof.size();
708  ++uMsCompIdx) {
709  UInt_t uMsComp = fvMsComponentsListTof[uMsCompIdx];
710 
711  if (kFALSE == ProcessTofMs(ts, uMsComp, uMsIdx)) return kFALSE;
712  } // for( UInt_t uMsComp = 0; uMsComp < fvMsComponentsListSts.size(); ++uMsComp )
713 
715  if (fdSpillStartA < fdSpillStartC) {
716  if (fulCurrentMsIdx * 1e-9 < fdSpillStartA - 0.2) {
718  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
719  fhMcbmHitsNbPerMs->Fill(fvmStsSdpbHitsInMs[uSdpb].size(), uSdpb);
720  fvmStsSdpbHitsInMs[uSdpb].clear();
721  } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
722  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
723  fhMcbmHitsNbPerMs->Fill(fvmTofGdpbHitsInMs[uGdpb].size(),
724  uGdpb + fuStsNrOfDpbs);
725  fvmTofGdpbHitsInMs[uGdpb].clear();
726  } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
727  continue;
728  } // if( fulCurrentMsIdx * 1e-9 < fdSpillStartA - 0.2 )
729  } // if( fdSpillStartA < fdSpillStartC )
730 
731  /****************** STS Sync ******************************************/
733  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb)
734  std::sort(fvmStsSdpbHitsInMs[uSdpb].begin(),
735  fvmStsSdpbHitsInMs[uSdpb].end());
736  /****************** STS Sync ******************************************/
737 
738  /****************** TOF Sync ******************************************/
740  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb)
741  std::sort(fvmTofGdpbHitsInMs[uGdpb].begin(),
742  fvmTofGdpbHitsInMs[uGdpb].end());
743  /****************** TOF Sync ******************************************/
744 
745  /****************** mCBM Sync *****************************************/
747  UInt_t uNbDiaHits = fvmTofGdpbHitsInMs[fuDiamondDpbIdx].size();
748  for (UInt_t uHitDia = 0; uHitDia < uNbDiaHits; uHitDia++) {
749  Double_t dDiaTime =
750  fvmTofGdpbHitsInMs[fuDiamondDpbIdx][uHitDia].GetFullTimeNs();
751 
752  if (fdSpillStartA < fdSpillStartC) {
753  fvhHitsTimeEvoSpillA[fuDiamondDpbIdx + fuStsNrOfDpbs]->Fill(dDiaTime
754  * 1e-9);
755  fvhHitsTimeEvoSpillB[fuDiamondDpbIdx + fuStsNrOfDpbs]->Fill(dDiaTime
756  * 1e-9);
757  } // if( fdSpillStartA < fdSpillStartC )
758 
759  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
760  UInt_t uNbHits = fvmStsSdpbHitsInMs[uSdpb].size();
761  Double_t dBestDt = 1e9;
762  UInt_t uNbIncrDt = 0;
763 
764  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
765  Double_t dHitTime =
766  stsxyter::kdClockCycleNs * fvmStsSdpbHitsInMs[uSdpb][uHit].GetTs();
767  if (fuMuchDpbIdx == uSdpb)
768  dHitTime -= fdMuchTofOffsetNs;
769  else
770  dHitTime -= fdStsTofOffsetNs;
771 
772  if (fdSpillStartA < fdSpillStartC) {
773  fvhHitsTimeEvoSpillA[uSdpb]->Fill(dHitTime * 1e-9);
774  fvhHitsTimeEvoSpillB[uSdpb]->Fill(dHitTime * 1e-9);
775  } // if( fdSpillStartA < fdSpillStartC )
776 
777  Double_t dDt = dHitTime - dDiaTime;
778 
779  if (kTRUE == fbUseBestPair) {
781  if (TMath::Abs(dDt) < TMath::Abs(dBestDt))
782  dBestDt = dDt;
783  else if (dBestDt < dDt)
784  uNbIncrDt++;
785 
787  if (5 == dBestDt) break;
788  } // if( kTRUE == fbUseBestPair )
789  else {
790  fhMcbmTimeDiffToDiamond->Fill(dDt, uSdpb);
791  fhMcbmTimeDiffToDiamondWide->Fill(dDt / 1000.0, uSdpb);
792 
793  fvhMcbmTimeDiffToDiamondEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dDt);
794  fvhMcbmTimeDiffToDiamondWideEvoDpb[uSdpb]->Fill(fulCurrentTsIdx,
795  dDt / 1000.0);
796  } // else of if( kTRUE == fbUseBestPair )
797  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
798 
799  if (kTRUE == fbUseBestPair) {
800  fhMcbmTimeDiffToDiamond->Fill(dBestDt, uSdpb);
801  fhMcbmTimeDiffToDiamondWide->Fill(dBestDt / 1000.0, uSdpb);
802 
803  fvhMcbmTimeDiffToDiamondEvoDpb[uSdpb]->Fill(fulCurrentTsIdx, dBestDt);
804  fvhMcbmTimeDiffToDiamondWideEvoDpb[uSdpb]->Fill(fulCurrentTsIdx,
805  dBestDt / 1000.0);
806  } // if( kTRUE == fbUseBestPair )
807  } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
808 
809  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
810  if (fuDiamondDpbIdx == uGdpb) continue;
811 
812  UInt_t uNbHits = fvmTofGdpbHitsInMs[uGdpb].size();
813  Double_t dBestDt = 1e9;
814  UInt_t uNbIncrDt = 0;
815 
816  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
817  Double_t dHitTime = fvmTofGdpbHitsInMs[uGdpb][uHit].GetFullTimeNs();
818 
819  if (fdSpillStartA < fdSpillStartC) {
820  fvhHitsTimeEvoSpillA[uGdpb + fuStsNrOfDpbs]->Fill(dHitTime * 1e-9);
821  fvhHitsTimeEvoSpillB[uGdpb + fuStsNrOfDpbs]->Fill(dHitTime * 1e-9);
822  } // if( fdSpillStartA < fdSpillStartC )
823 
824  Double_t dDt = dHitTime - dDiaTime;
825 
826  if (kTRUE == fbUseBestPair) {
828  if (TMath::Abs(dDt) < TMath::Abs(dBestDt))
829  dBestDt = dDt;
830  else if (dBestDt < dDt)
831  uNbIncrDt++;
832 
834  if (5 == dBestDt) break;
835  } // if( kTRUE == fbUseBestPair )
836  else {
837  fhMcbmTimeDiffToDiamond->Fill(dDt, uGdpb + fuStsNrOfDpbs);
838  fhMcbmTimeDiffToDiamondWide->Fill(dDt / 1000.0,
839  uGdpb + fuStsNrOfDpbs);
840 
841  fvhMcbmTimeDiffToDiamondEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(
842  fulCurrentTsIdx, dDt);
843  fvhMcbmTimeDiffToDiamondWideEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(
844  fulCurrentTsIdx, dDt / 1000.0);
845  } // else of if( kTRUE == fbUseBestPair )
846  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
847 
848  if (kTRUE == fbUseBestPair) {
849  fhMcbmTimeDiffToDiamond->Fill(dBestDt, uGdpb + fuStsNrOfDpbs);
850  fhMcbmTimeDiffToDiamondWide->Fill(dBestDt / 1000.0,
851  uGdpb + fuStsNrOfDpbs);
852 
853  fvhMcbmTimeDiffToDiamondEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(
854  fulCurrentTsIdx, dBestDt);
855  fvhMcbmTimeDiffToDiamondWideEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(
856  fulCurrentTsIdx, dBestDt / 1000.0);
857  } // if( kTRUE == fbUseBestPair )
858  } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
859  } // for( UInt_t uHitDia = 0; uHitDia < uNbDiaHits; uHitDia++)
860 
862  UInt_t uNbMuchHits = fvmStsSdpbHitsInMs[fuMuchDpbIdx].size();
863  for (UInt_t uHitMuch = 0; uHitMuch < uNbMuchHits; uHitMuch++) {
864  Double_t dMuchTime =
865  stsxyter::kdClockCycleNs
866  * fvmStsSdpbHitsInMs[fuMuchDpbIdx][uHitMuch].GetTs()
867  - fdMuchTofOffsetNs;
868 
869  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
870  if (fuMuchDpbIdx == uSdpb) continue;
871 
872  UInt_t uNbHits = fvmStsSdpbHitsInMs[uSdpb].size();
873  Double_t dBestDt = 1e9;
874  UInt_t uBestAdc = 0;
875  UInt_t uNbIncrDt = 0;
876 
877  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
878  Double_t dHitTime =
879  stsxyter::kdClockCycleNs * fvmStsSdpbHitsInMs[uSdpb][uHit].GetTs();
880  if (fuMuchDpbIdx == uSdpb)
881  dHitTime -= fdMuchTofOffsetNs;
882  else
883  dHitTime -= fdStsTofOffsetNs;
884 
885  Double_t dDt = dHitTime - dMuchTime;
886 
887  if (kTRUE == fbUseBestPair) {
889  if (TMath::Abs(dDt) < TMath::Abs(dBestDt)) {
890  dBestDt = dDt;
891  uBestAdc = fvmStsSdpbHitsInMs[uSdpb][uHit].GetAdc();
892  } // if( TMath::Abs( dDt ) < TMath::Abs( dBestDt ) )
893  else if (dBestDt < dDt)
894  uNbIncrDt++;
895 
897  if (5 == dBestDt) break;
898  } // if( kTRUE == fbUseBestPair )
899  else {
900  fhMcbmTimeDiffToMuch->Fill(dDt, uSdpb);
901  fhMcbmTimeDiffToMuchWide->Fill(dDt / 1000.0, uSdpb);
902 
903  fhMcbmStsTimeDiffToMuchVsAdc->Fill(
904  dDt, fvmStsSdpbHitsInMs[uSdpb][uHit].GetAdc());
905  fhMcbmStsTimeDiffToMuchWideVsAdc->Fill(
906  dDt / 1000.0, fvmStsSdpbHitsInMs[uSdpb][uHit].GetAdc());
907  } // else of if( kTRUE == fbUseBestPair )
908  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
909 
910  if (kTRUE == fbUseBestPair) {
911  fhMcbmTimeDiffToMuch->Fill(dBestDt, uSdpb);
912  fhMcbmTimeDiffToMuchWide->Fill(dBestDt / 1000.0, uSdpb);
913 
914  fhMcbmStsTimeDiffToMuchVsAdc->Fill(dBestDt, uBestAdc);
915  fhMcbmStsTimeDiffToMuchWideVsAdc->Fill(dBestDt / 1000.0, uBestAdc);
916  } // if( kTRUE == fbUseBestPair )
917  } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
918 
919  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
920  UInt_t uNbHits = fvmTofGdpbHitsInMs[uGdpb].size();
921  Double_t dBestDt = 1e9;
922  UInt_t uNbIncrDt = 0;
923 
924  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
925  Double_t dHitTime = fvmTofGdpbHitsInMs[uGdpb][uHit].GetFullTimeNs();
926 
927  Double_t dDt = dHitTime - dMuchTime;
928 
929  if (kTRUE == fbUseBestPair) {
931  if (TMath::Abs(dDt) < TMath::Abs(dBestDt))
932  dBestDt = dDt;
933  else if (dBestDt < dDt)
934  uNbIncrDt++;
935 
937  if (5 == dBestDt) break;
938  } // if( kTRUE == fbUseBestPair )
939  else {
940  fhMcbmTimeDiffToMuch->Fill(dDt, uGdpb + fuStsNrOfDpbs);
941  fhMcbmTimeDiffToMuchWide->Fill(dDt / 1000.0, uGdpb + fuStsNrOfDpbs);
942  } // else of if( kTRUE == fbUseBestPair )
943  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
944 
945  if (kTRUE == fbUseBestPair) {
946  fhMcbmTimeDiffToMuch->Fill(dBestDt, uGdpb + fuStsNrOfDpbs);
947  fhMcbmTimeDiffToMuchWide->Fill(dBestDt / 1000.0,
948  uGdpb + fuStsNrOfDpbs);
949  } // if( kTRUE == fbUseBestPair )
950  } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
951  } // for( UInt_t uHitMuch = 0; uHitMuch < uNbMuchHits; uHitMuch++)
952 
954  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
955  fhMcbmHitsNbPerMs->Fill(fvmStsSdpbHitsInMs[uSdpb].size(), uSdpb);
956 
957  if (fbTsLevelAna)
958  fvmStsSdpbHitsInTs[uSdpb].insert(fvmStsSdpbHitsInTs[uSdpb].end(),
959  fvmStsSdpbHitsInMs[uSdpb].begin(),
960  fvmStsSdpbHitsInMs[uSdpb].end());
961 
962  fvmStsSdpbHitsInMs[uSdpb].clear();
963  } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
964  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
965  fhMcbmHitsNbPerMs->Fill(fvmTofGdpbHitsInMs[uGdpb].size(),
966  uGdpb + fuStsNrOfDpbs);
967 
968  if (fbTsLevelAna)
969  fvmTofGdpbHitsInTs[uGdpb].insert(fvmTofGdpbHitsInTs[uGdpb].end(),
970  fvmTofGdpbHitsInMs[uGdpb].begin(),
971  fvmTofGdpbHitsInMs[uGdpb].end());
972 
973  fvmTofGdpbHitsInMs[uGdpb].clear();
974  } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
975  /****************** mCBM Sync *****************************************/
976 
978  if (fdSpillStartA < fdSpillStartC) {
979  if (fdSpillStartC < fulCurrentMsIdx * 1e-9) {
980  SaveAllHistos(fsHistoFileFullname);
981  LOG(fatal) << "Done with the spills";
982  } // if( fdSpillStartC < fulCurrentMsIdx * 1e-9 )
983  } // if( fdSpillStartA < fdSpillStartC )
984 
985  } // for( UInt_t uMsIdx = 0; uMsIdx < uNbMsLoop; uMsIdx ++ )
986 
987  /****************** mCBM Sync *****************************************/
988 
990  UInt_t uNbDiaHits = fvmTofGdpbHitsInTs[fuDiamondDpbIdx].size();
991  for (UInt_t uHitDia = 0; uHitDia < uNbDiaHits; uHitDia++) {
992  Double_t dDiaTime =
993  fvmTofGdpbHitsInTs[fuDiamondDpbIdx][uHitDia].GetFullTimeNs();
994 
995  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
996  UInt_t uNbHits = fvmStsSdpbHitsInTs[uSdpb].size();
997  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
998  Double_t dHitTime =
999  stsxyter::kdClockCycleNs * fvmStsSdpbHitsInTs[uSdpb][uHit].GetTs();
1000 
1001  Double_t dDt = dHitTime - dDiaTime;
1002 
1004  if (300e3 < dDt) break;
1005 
1006  fhMcbmTimeDiffToDiamondTs->Fill(dDt / 1e6, uSdpb);
1007 
1008  fvhMcbmTimeDiffToDiamondTsEvoDpb[uSdpb]->Fill(fulCurrentTsIdx,
1009  dDt / 1e6);
1010 
1011  if (fdSpillStartA < fdSpillStartC) {
1012  Double_t dDiaTimeSec = dDiaTime * 1e-9;
1013  if (fdSpillStartA - 0.1 < dDiaTimeSec
1014  && dDiaTimeSec < fdSpillStartC + 0.1) {
1015  fvhMcbmTimeDiffToDiamondEvoSpillA[uSdpb]->Fill(dDiaTimeSec,
1016  dDt / 1e3);
1017  fvhMcbmTimeDiffToDiamondEvoSpillB[uSdpb]->Fill(dDiaTimeSec,
1018  dDt / 1e3);
1019  } // if( fdSpillStartA - 0.1 < dDiaTimeSec && dDiaTimeSec < fdSpillStartC + 0.1 )
1020  } // if( fdSpillStartA < fdSpillStartC )
1021  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
1022  } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
1023 
1024  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
1025  if (fuDiamondDpbIdx == uGdpb) continue;
1026 
1027  UInt_t uNbHits = fvmTofGdpbHitsInTs[uGdpb].size();
1028  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
1029  Double_t dHitTime = fvmTofGdpbHitsInTs[uGdpb][uHit].GetFullTimeNs();
1030 
1031  Double_t dDt = dHitTime - dDiaTime;
1032 
1034  if (300e3 < dDt) break;
1035 
1036  fhMcbmTimeDiffToDiamondTs->Fill(dDt / 1e6, uGdpb + fuStsNrOfDpbs);
1037 
1038  fvhMcbmTimeDiffToDiamondTsEvoDpb[uGdpb + fuStsNrOfDpbs]->Fill(
1039  fulCurrentTsIdx, dDt / 1e6);
1040 
1041  if (fdSpillStartA < fdSpillStartC) {
1042  Double_t dDiaTimeSec = dDiaTime * 1e-9;
1043  if (fdSpillStartA - 0.1 < dDiaTimeSec
1044  && dDiaTimeSec < fdSpillStartC + 0.1) {
1045  fvhMcbmTimeDiffToDiamondEvoSpillA[uGdpb + fuStsNrOfDpbs]->Fill(
1046  dDiaTimeSec, dDt / 1e3);
1047  fvhMcbmTimeDiffToDiamondEvoSpillB[uGdpb + fuStsNrOfDpbs]->Fill(
1048  dDiaTimeSec, dDt / 1e3);
1049  } // if( fdSpillStartA - 0.1 < dDiaTimeSec && dDiaTimeSec < fdSpillStartC + 0.1 )
1050  } // if( fdSpillStartA < fdSpillStartC )
1051  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
1052  } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
1053  } // for( UInt_t uHitDia = 0; uHitDia < uNbDiaHits; uHitDia++)
1054 
1056  UInt_t uNbMuchHits = fvmStsSdpbHitsInTs[fuMuchDpbIdx].size();
1057  for (UInt_t uHitMuch = 0; uHitMuch < uNbMuchHits; uHitMuch++) {
1058  Double_t dMuchTime = stsxyter::kdClockCycleNs
1059  * fvmStsSdpbHitsInTs[fuMuchDpbIdx][uHitMuch].GetTs()
1060  - fdMuchTofOffsetNs;
1061 
1062  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
1063  if (fuMuchDpbIdx == uSdpb) continue;
1064 
1065  UInt_t uNbHits = fvmStsSdpbHitsInTs[uSdpb].size();
1066  // Double_t dBestDt = 1e9;
1067  // UInt_t uBestAdc = 0;
1068  // UInt_t uNbIncrDt = 0;
1069 
1070  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
1071  Double_t dHitTime =
1072  stsxyter::kdClockCycleNs * fvmStsSdpbHitsInTs[uSdpb][uHit].GetTs();
1073  if (fuMuchDpbIdx == uSdpb)
1074  dHitTime -= fdMuchTofOffsetNs;
1075  else
1076  dHitTime -= fdStsTofOffsetNs;
1077 
1078  Double_t dDt = dHitTime - dMuchTime;
1079 
1081  if (300e3 < dDt) break;
1082 
1083  fhMcbmTimeDiffToMuchTs->Fill(dDt / 1e6, uSdpb);
1084  fhMcbmStsTimeDiffToMuchTsVsAdc->Fill(
1085  dDt / 1e6, fvmStsSdpbHitsInTs[uSdpb][uHit].GetAdc());
1086 
1087  if (fdSpillStartA < fdSpillStartC) {
1088  Double_t dMuchTimeSec = dMuchTime * 1e-9;
1089  if (fdSpillStartA - 0.1 < dMuchTimeSec
1090  && dMuchTimeSec < fdSpillStartC + 0.1) {
1091  fvhMcbmTimeDiffToMuchEvoSpillA[uSdpb]->Fill(dMuchTimeSec,
1092  dDt / 1e3);
1093  fvhMcbmTimeDiffToMuchEvoSpillB[uSdpb]->Fill(dMuchTimeSec,
1094  dDt / 1e3);
1095  } // if( fdSpillStartA - 0.1 < dDiaTimeSec && dDiaTimeSec < fdSpillStartC + 0.1 )
1096  } // if( fdSpillStartA < fdSpillStartC )
1097  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
1098  } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
1099 
1100  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
1101  UInt_t uNbHits = fvmTofGdpbHitsInTs[uGdpb].size();
1102  // Double_t dBestDt = 1e9;
1103  // UInt_t uNbIncrDt = 0;
1104 
1105  for (UInt_t uHit = 0; uHit < uNbHits; ++uHit) {
1106  Double_t dHitTime = fvmTofGdpbHitsInTs[uGdpb][uHit].GetFullTimeNs();
1107 
1108  Double_t dDt = dHitTime - dMuchTime;
1109 
1111  if (300e3 < dDt) break;
1112 
1113  fhMcbmTimeDiffToMuchTs->Fill(dDt / 1e6, uGdpb + fuStsNrOfDpbs);
1114  if (fdSpillStartA < fdSpillStartC) {
1115  Double_t dMuchTimeSec = dMuchTime * 1e-9;
1116  if (fdSpillStartA - 0.1 < dMuchTimeSec
1117  && dMuchTimeSec < fdSpillStartC + 0.1) {
1118  fvhMcbmTimeDiffToMuchEvoSpillA[uGdpb + fuStsNrOfDpbs]->Fill(
1119  dMuchTimeSec, dDt / 1e3);
1120  fvhMcbmTimeDiffToMuchEvoSpillB[uGdpb + fuStsNrOfDpbs]->Fill(
1121  dMuchTimeSec, dDt / 1e3);
1122  } // if( fdSpillStartA - 0.1 < dDiaTimeSec && dDiaTimeSec < fdSpillStartC + 0.1 )
1123  } // if( fdSpillStartA < fdSpillStartC )
1124  } // for( UInt_t uHit = 0; uHit < uNbHits; ++uHit )
1125  } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
1126  } // for( UInt_t uHitMuch = 0; uHitMuch < uNbMuchHits; uHitMuch++)
1127 
1129  for (UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb) {
1130  fvmStsSdpbHitsInTs[uSdpb].clear();
1131  } // for( UInt_t uSdpb = 0; uSdpb < fuStsNrOfDpbs; ++uSdpb )
1132  for (UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb) {
1133  fvmTofGdpbHitsInTs[uGdpb].clear();
1134  } // for( UInt_t uGdpb = 0; uGdpb < fuTofNrOfDpbs; ++uGdpb )
1135 
1136  /****************** mCBM Sync *****************************************/
1137 
1138  if (0 == ts.index() % 1000) {
1139  LOG(info) << "End of TS " << std::setw(7) << ts.index();
1140  } // if( 0 == ts.index() % 1000 )
1141 
1142  return kTRUE;
1143 }
1144 
1145 /****************** STS Sync ******************************************/
1146 Bool_t CbmMcbm2018MonitorMcbmSync::ProcessStsMs(const fles::Timeslice& ts,
1147  size_t uMsComp,
1148  UInt_t uMsIdx) {
1149  auto msDescriptor = ts.descriptor(uMsComp, uMsIdx);
1150  fuCurrentEquipmentId = msDescriptor.eq_id;
1151  const uint8_t* msContent =
1152  reinterpret_cast<const uint8_t*>(ts.content(uMsComp, uMsIdx));
1153 
1154  uint32_t uSize = msDescriptor.size;
1155  fulCurrentMsIdx = msDescriptor.idx;
1156  // Double_t dMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
1157  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
1158  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
1159 
1160  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
1161  fuCurrDpbIdx = fmStsDpbIdIndexMap[fuCurrDpbId];
1162 
1164  UInt_t uTsMsbCycleHeader = std::floor(
1165  fulCurrentMsIdx / (stsxyter::kulTsCycleNbBins * stsxyter::kdClockCycleNs));
1166 
1167  if (0 == uMsIdx) {
1168  fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
1169  fvulStsCurrentTsMsb[fuCurrDpbIdx] = 0;
1170  } // if( 0 == uMsIdx )
1171  else if (uTsMsbCycleHeader != fvuStsCurrentTsMsbCycle[fuCurrDpbIdx]
1172  && 4194303 != fvulStsCurrentTsMsb[fuCurrDpbIdx]) {
1173  LOG(warning)
1174  << "TS MSB cycle from MS header does not match current cycle from data "
1175  << "for TS " << std::setw(12) << fulCurrentTsIdx << " MS "
1176  << std::setw(12) << fulCurrentMsIdx << " MsInTs " << std::setw(3)
1177  << uMsIdx << " ====> " << fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] << " VS "
1178  << uTsMsbCycleHeader;
1179  fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
1180  }
1181 
1182  // If not integer number of message in input buffer, print warning/error
1183  if (0 != (uSize % kuStsBytesPerMessage))
1184  LOG(error) << "The input microslice buffer does NOT "
1185  << "contain only complete nDPB messages!";
1186 
1187  // Compute the number of complete messages in the input microslice buffer
1188  uint32_t uNbMessages =
1189  (uSize - (uSize % kuStsBytesPerMessage)) / kuStsBytesPerMessage;
1190 
1191  // Prepare variables for the loop on contents
1192  const uint32_t* pInBuff = reinterpret_cast<const uint32_t*>(msContent);
1193 
1194  for (uint32_t uIdx = 0; uIdx < uNbMessages; ++uIdx) {
1195  // Fill message
1196  uint32_t ulData = static_cast<uint32_t>(pInBuff[uIdx]);
1197 
1198  stsxyter::Message mess(static_cast<uint32_t>(ulData & 0xFFFFFFFF));
1199 
1200  // Print message if requested
1201  if (fbPrintMessages) mess.PrintMess(std::cout, fPrintMessCtrlSts);
1202 
1203  stsxyter::MessType typeMess = mess.GetMessType();
1204  fmMsgCounter[typeMess]++;
1205 
1206  switch (typeMess) {
1207  case stsxyter::MessType::Hit: {
1208 
1209  FillStsHitInfo(mess, uMsIdx);
1210  break;
1211  } // case stsxyter::MessType::Hit :
1212  case stsxyter::MessType::TsMsb: {
1213  FillStsTsMsbInfo(mess, uIdx, uMsIdx);
1214  break;
1215  } // case stsxyter::MessType::TsMsb :
1216  case stsxyter::MessType::Epoch: {
1217  // The first message in the TS is a special ones: EPOCH
1218  FillStsEpochInfo(mess);
1219 
1220  if (0 < uIdx)
1221  LOG(info) << "CbmMcbm2018MonitorMcbmSync::DoUnpack => "
1222  << "EPOCH message at unexpected position in MS: message "
1223  << uIdx << " VS message 0 expected!";
1224  break;
1225  } // case stsxyter::MessType::TsMsb :
1226  case stsxyter::MessType::Status:
1227  case stsxyter::MessType::Empty:
1228  case stsxyter::MessType::Dummy: {
1229  break;
1230  } // case stsxyter::MessType::Dummy / ReadDataAck / Ack :
1231  default: {
1232  LOG(fatal)
1233  << "CbmMcbm2018MonitorMcbmSync::DoUnpack => "
1234  << "Unknown message type, should never happen, stopping here!";
1235  }
1236  } // switch( mess.GetMessType() )
1237  } // for( uint32_t uIdx = 0; uIdx < uNbMessages; ++uIdx )
1238  return kTRUE;
1239 }
1240 
1241 void CbmMcbm2018MonitorMcbmSync::FillStsHitInfo(stsxyter::Message mess,
1242  const UInt_t& /*uMsIdx*/) {
1243  UShort_t usChan = mess.GetHitChannel();
1244  UShort_t usRawAdc = mess.GetHitAdc();
1245  // UShort_t usFullTs = mess.GetHitTimeFull();
1246  // UShort_t usTsOver = mess.GetHitTimeOver();
1247  UShort_t usRawTs = mess.GetHitTime();
1248 
1249  UInt_t uAsicIdx =
1250  0;
1251 
1252  if (fuCurrDpbIdx == fuMuchDpbIdx) {
1254  switch (usChan) {
1255  case 101:
1256  case 99:
1257  case 91:
1258  case 89:
1259  case 88:
1260  case 86:
1261  case 84:
1262  case 83:
1263  case 80:
1264  case 78:
1265  case 76:
1266  case 50:
1267  case 39:
1268  case 37:
1269  case 35:
1270  case 20: {
1271  return;
1272  break;
1273  } // if bad channel
1274  default: break;
1275  } // switch( usChan )
1276  } // if( fuCurrDpbIdx == fuMuchDpbIdx )
1277  else {
1279  if (usRawAdc < 15) return;
1280 
1282  uAsicIdx = fUnpackParSts->ElinkIdxToAsicIdx(kFALSE, mess.GetLinkIndex());
1283  UInt_t uChanIdx = usChan + fUnpackParSts->GetNbChanPerAsic() * uAsicIdx;
1284  switch (uChanIdx) {
1285  case 781:
1286  case 270:
1287  case 411:
1288  case 518: {
1289  return;
1290  break;
1291  } // if bad channel
1292  default: break;
1293  } // switch( mess.GetLinkIndex() )
1294  if ((0 == uChanIdx % 2) && (543 < uChanIdx) && (uChanIdx < 633)) {
1295  return;
1296  } // if bad channel
1297  } // else of if( fuCurrDpbIdx == fuMuchDpbIdx )
1298 
1299  // Compute the Full time stamp
1300  // Use TS w/o overlap bits as they will anyway come from the TS_MSB
1301  Long64_t ulStsHitTime = usRawTs;
1302 
1303  ulStsHitTime +=
1304  static_cast<ULong64_t>(stsxyter::kuHitNbTsBins)
1305  * static_cast<ULong64_t>(fvulStsCurrentTsMsb[fuCurrDpbIdx])
1306  + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBins)
1307  * static_cast<ULong64_t>(fvuStsCurrentTsMsbCycle[fuCurrDpbIdx]);
1308 
1309  // Convert the Hit time in bins to Hit time in ns
1310  // Double_t dHitTimeNs = ulStsHitTime * stsxyter::kdClockCycleNs;
1311 
1312 
1313  // Pulser and MS
1314  fvmStsSdpbHitsInMs[fuCurrDpbIdx].push_back(
1315  stsxyter::FinalHit(ulStsHitTime, usRawAdc, uAsicIdx, usChan));
1316 }
1317 
1318 void CbmMcbm2018MonitorMcbmSync::FillStsTsMsbInfo(stsxyter::Message mess,
1319  UInt_t uMessIdx,
1320  UInt_t uMsIdx) {
1321  UInt_t uVal = mess.GetTsMsbVal();
1322 
1323  // Update Status counters
1324  if (uVal < fvulStsCurrentTsMsb[fuCurrDpbIdx]) {
1325 
1326  LOG(info) << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
1327  << std::setw(12) << fulCurrentMsIdx << " DPB " << std::setw(2)
1328  << fuCurrDpbIdx << " Old TsMsb " << std::setw(5)
1329  << fvulStsCurrentTsMsb[fuCurrDpbIdx] << " Old MsbCy "
1330  << std::setw(5) << fvuStsCurrentTsMsbCycle[fuCurrDpbIdx]
1331  << " new TsMsb " << std::setw(5) << uVal;
1332 
1333  fvuStsCurrentTsMsbCycle[fuCurrDpbIdx]++;
1334  } // if( uVal < fvulStsCurrentTsMsb[fuCurrDpbIdx] )
1335  if (uVal != fvulStsCurrentTsMsb[fuCurrDpbIdx] + 1 && 0 != uVal
1336  && 4194303 != fvulStsCurrentTsMsb[fuCurrDpbIdx] && 1 != uMessIdx) {
1337  LOG(info) << "TS MSb Jump in "
1338  << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
1339  << std::setw(12) << fulCurrentMsIdx << " MS Idx " << std::setw(4)
1340  << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx << " DPB "
1341  << std::setw(2) << fuCurrDpbIdx << " => Old TsMsb "
1342  << std::setw(5) << fvulStsCurrentTsMsb[fuCurrDpbIdx]
1343  << " new TsMsb " << std::setw(5) << uVal;
1344  } // if( uVal + 1 != fvulStsCurrentTsMsb[fuCurrDpbIdx] && 4194303 != uVal && 0 != fvulStsCurrentTsMsb[fuCurrDpbIdx] )
1345  fvulStsCurrentTsMsb[fuCurrDpbIdx] = uVal;
1346  /*
1347  ULong64_t ulNewTsMsbTime = static_cast< ULong64_t >( stsxyter::kuHitNbTsBins )
1348  * static_cast< ULong64_t >( fvulStsCurrentTsMsb[fuCurrDpbIdx])
1349  + static_cast< ULong64_t >( stsxyter::kulTsCycleNbBins )
1350  * static_cast< ULong64_t >( fvuStsCurrentTsMsbCycle[fuCurrDpbIdx] );
1351 */
1352 }
1353 
1354 void CbmMcbm2018MonitorMcbmSync::FillStsEpochInfo(stsxyter::Message /*mess*/) {
1355  // UInt_t uVal = mess.GetTsMsbVal();
1356 }
1357 /****************** STS Sync ******************************************/
1358 
1359 /****************** TOF Sync ******************************************/
1360 
1361 Bool_t CbmMcbm2018MonitorMcbmSync::ProcessTofMs(const fles::Timeslice& ts,
1362  size_t uMsComp,
1363  UInt_t uMsIdx) {
1364  auto msDescriptor = ts.descriptor(uMsComp, uMsIdx);
1365  fuCurrentEquipmentId = msDescriptor.eq_id;
1366  fdTofMsIndex = static_cast<double>(msDescriptor.idx);
1367  const uint8_t* msContent =
1368  reinterpret_cast<const uint8_t*>(ts.content(uMsComp, uMsIdx));
1369 
1370  uint32_t size = msDescriptor.size;
1371  // fulLastMsIdx = msDescriptor.idx;
1372  if (size > 0)
1373  LOG(debug) << "Microslice: " << msDescriptor.idx << " has size: " << size;
1374 
1375  Int_t messageType = -111;
1376 
1377  // If not integer number of message in input buffer, print warning/error
1378  if (0 != (size % kuTofBytesPerMessage))
1379  LOG(error) << "The input microslice buffer does NOT "
1380  << "contain only complete nDPB messages!";
1381 
1382  // Compute the number of complete messages in the input microslice buffer
1383  uint32_t uNbMessages =
1384  (size - (size % kuTofBytesPerMessage)) / kuTofBytesPerMessage;
1385 
1386  // Get the gDPB ID from the MS header
1387  fuTofGdpbId = fuCurrentEquipmentId;
1388  fuTofGdpbNr = fmTofDpbIdIndexMap[fuTofGdpbId];
1389 
1390  // Prepare variables for the loop on contents
1391  const uint64_t* pInBuff = reinterpret_cast<const uint64_t*>(msContent);
1392  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
1393  // Fill message
1394  uint64_t ulData = static_cast<uint64_t>(pInBuff[uIdx]);
1395  gdpbv100::Message mess(ulData);
1396 
1398  if (0 == uIdx) {
1399  FillTofEpochCycle(ulData);
1400  continue;
1401  } // if( 0 == uIdx )
1402 
1403  if (gLogger->IsLogNeeded(fair::Severity::debug2)) {
1404  mess.printDataCout();
1405  } // if (gLogger->IsLogNeeded( fair::Severity::debug2 ))
1406 
1407  // Increment counter for different message types
1408  // and fill the corresponding histogram
1409  messageType = mess.getMessageType();
1410  fviTofMsgCounter[messageType]++;
1411 
1412  switch (messageType) {
1413  case gdpbv100::MSG_HIT: {
1414  if (!mess.getGdpbHitIs24b()) {
1415  fvmTofEpSupprBuffer[fuTofGdpbNr].push_back(mess);
1416  } // if( !getGdpbHitIs24b() )
1417  break;
1418  } // case gdpbv100::MSG_HIT:
1419  case gdpbv100::MSG_EPOCH: {
1420  if (gdpbv100::kuChipIdMergedEpoch == mess.getGdpbGenChipId()) {
1421  FillTofEpochInfo(mess);
1422  } // if this epoch message is a merged one valiud for all chips
1423  else
1424  LOG(fatal) << "Bad epoch: " << mess.getGdpbGenChipId();
1425  break;
1426  } // case gdpbv100::MSG_EPOCH:
1427  case gdpbv100::MSG_SLOWC:
1428  case gdpbv100::MSG_SYST:
1429  case gdpbv100::MSG_STAR_TRI_A:
1430  case gdpbv100::MSG_STAR_TRI_B:
1431  case gdpbv100::MSG_STAR_TRI_C:
1432  case gdpbv100::MSG_STAR_TRI_D: break;
1433  default:
1434  LOG(error) << "Message type " << std::hex << std::setw(2)
1435  << static_cast<uint16_t>(messageType)
1436  << " not included in Get4 unpacker.";
1437  } // switch( mess.getMessageType() )
1438  } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
1439 
1440  return kTRUE;
1441 }
1442 
1443 void CbmMcbm2018MonitorMcbmSync::FillTofEpochCycle(uint64_t ulCycleData) {
1444  uint64_t ulEpochCycleVal = ulCycleData & gdpbv100::kulEpochCycleFieldSz;
1445  fvulTofCurrentEpochCycle[fuTofGdpbNr] = ulEpochCycleVal;
1446 
1447  return;
1448 }
1449 
1450 void CbmMcbm2018MonitorMcbmSync::FillTofHitInfo(gdpbv100::Message mess) {
1451  // UInt_t uChannel = mess.getGdpbHitChanId();
1452  // UInt_t uTot = mess.getGdpbHit32Tot();
1453  // UInt_t uFts = mess.getGdpbHitFineTs();
1454 
1455  ULong64_t ulCurEpochGdpbGet4 = fvulTofCurrentEpochFull[fuTofGdpbNr];
1456 
1457  // In Ep. Suppr. Mode, receive following epoch instead of previous
1458  if (0 < ulCurEpochGdpbGet4)
1459  ulCurEpochGdpbGet4--;
1460  else
1461  ulCurEpochGdpbGet4 = gdpbv100::kuEpochCounterSz; // Catch epoch cycle!
1462 
1463  // ULong_t ulHitTime = mess.getMsgFullTime(ulCurEpochGdpbGet4);
1464  // Double_t dHitTime = mess.getMsgFullTimeD(ulCurEpochGdpbGet4);
1465 
1466  // In 32b mode the coarse counter is already computed back to 112 FTS bins
1467  // => need to hide its contribution from the Finetime
1468  // => FTS = Fullt TS modulo 112
1469  // uFts = mess.getGdpbHitFullTs() % 112;
1470 
1472  fvmTofGdpbHitsInMs[fuTofGdpbNr].push_back(
1473  gdpbv100::FullMessage(mess, ulCurEpochGdpbGet4));
1474 }
1475 
1476 void CbmMcbm2018MonitorMcbmSync::FillTofEpochInfo(gdpbv100::Message mess) {
1477  ULong64_t ulEpochNr = mess.getGdpbEpEpochNb();
1478 
1479  fvulTofCurrentEpoch[fuTofGdpbNr] = ulEpochNr;
1480  fvulTofCurrentEpochFull[fuTofGdpbNr] =
1481  ulEpochNr
1482  + gdpbv100::kulEpochCycleBins * fvulTofCurrentEpochCycle[fuTofGdpbNr];
1483 
1484  fulTofCurrentEpochTime = mess.getMsgFullTime(ulEpochNr);
1485 
1488  if (0 < ulEpochNr)
1489  mess.setGdpbEpEpochNb(ulEpochNr - 1);
1490  else
1491  mess.setGdpbEpEpochNb(gdpbv100::kuEpochCounterSz);
1492 
1493  Int_t iBufferSize = fvmTofEpSupprBuffer[fuTofGdpbNr].size();
1494  if (0 < iBufferSize) {
1495  LOG(debug) << "Now processing stored messages for for gDPB " << fuTofGdpbNr
1496  << " with epoch number "
1497  << (fvulTofCurrentEpoch[fuTofGdpbNr] - 1);
1498 
1501  std::stable_sort(fvmTofEpSupprBuffer[fuTofGdpbNr].begin(),
1502  fvmTofEpSupprBuffer[fuTofGdpbNr].begin());
1503 
1504  for (Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++) {
1505  FillTofHitInfo(fvmTofEpSupprBuffer[fuTofGdpbNr][iMsgIdx]);
1506  } // for( Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++ )
1507 
1508  fvmTofEpSupprBuffer[fuTofGdpbNr].clear();
1509  } // if( 0 < fvmTofEpSupprBuffer[fuTofGdpbNr] )
1510 }
1511 /****************** TOF Sync ******************************************/
1512 
1513 /****************** STS histos ****************************************/
1514 /****************** STS histos ****************************************/
1515 
1516 /****************** TOF histos ****************************************/
1517 /****************** TOF Histos ****************************************/
1518 
1519 void CbmMcbm2018MonitorMcbmSync::Reset() {}
1520 
1521 void CbmMcbm2018MonitorMcbmSync::Finish() {
1522  /*
1523  LOG(info) << "-------------------------------------";
1524  LOG(info) << "CbmMcbm2018MonitorMcbmSync statistics are ";
1525  LOG(info) << " Hit messages: " << fmMsgCounter[ stsxyter::MessType::Hit ] << "\n"
1526  << " Ts MSB messages: " << fmMsgCounter[ stsxyter::MessType::TsMsb ] << "\n"
1527  << " Dummy messages: " << fmMsgCounter[ stsxyter::MessType::Dummy ] << "\n"
1528  << " Epoch messages: " << fmMsgCounter[ stsxyter::MessType::Epoch ] << "\n"
1529  << " Empty messages: " << fmMsgCounter[ stsxyter::MessType::Empty ];
1530 */
1531  LOG(info) << "-------------------------------------";
1532 
1533  SaveAllHistos(fsHistoFileFullname);
1534  SaveAllHistos();
1535 }
1536 
1537 
1538 void CbmMcbm2018MonitorMcbmSync::SaveAllHistos(TString sFileName) {
1539  TDirectory* oldDir = nullptr;
1540  TFile* histoFile = nullptr;
1541  if ("" != sFileName) {
1542  // Store current directory position to allow restore later
1543  oldDir = gDirectory;
1544  // open separate histo file in recreate mode
1545  histoFile = new TFile(sFileName, "RECREATE");
1546  histoFile->cd();
1547  } // if( "" != sFileName )
1548 
1549  /****************** STS Sync ******************************************/
1550  /****************** STS Sync ******************************************/
1551 
1552  /****************** TOF Sync ******************************************/
1553  /****************** TOF Sync ******************************************/
1554 
1555  /****************** mCBM Sync *****************************************/
1556  gDirectory->mkdir("mcbmDt");
1557  gDirectory->cd("mcbmDt");
1558  fhMcbmHitsNbPerMs->Write();
1559  fhMcbmTimeDiffToDiamond->Write();
1560  fhMcbmTimeDiffToDiamondWide->Write();
1561  fhMcbmTimeDiffToDiamondTs->Write();
1562 
1563  fhMcbmTimeDiffToMuch->Write();
1564  fhMcbmTimeDiffToMuchWide->Write();
1565  fhMcbmTimeDiffToMuchTs->Write();
1566 
1567  fhMcbmStsTimeDiffToMuchVsAdc->Write();
1568  fhMcbmStsTimeDiffToMuchWideVsAdc->Write();
1569  fhMcbmStsTimeDiffToMuchTsVsAdc->Write();
1570 
1571  for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
1572  fvhMcbmTimeDiffToDiamondEvoDpb[uDpb]->Write();
1573  fvhMcbmTimeDiffToDiamondWideEvoDpb[uDpb]->Write();
1574  fvhMcbmTimeDiffToDiamondTsEvoDpb[uDpb]->Write();
1575 
1576  if (fdSpillStartA < fdSpillStartC) {
1577  fvhHitsTimeEvoSpillA[uDpb]->Write();
1578  fvhHitsTimeEvoSpillB[uDpb]->Write();
1579 
1580  fvhMcbmTimeDiffToDiamondEvoSpillA[uDpb]->Write();
1581  fvhMcbmTimeDiffToDiamondEvoSpillB[uDpb]->Write();
1582 
1583  fvhMcbmTimeDiffToMuchEvoSpillA[uDpb]->Write();
1584  fvhMcbmTimeDiffToMuchEvoSpillB[uDpb]->Write();
1585  } // if( fdSpillStartA < fdSpillStartC )
1586  } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
1587 
1588  gDirectory->cd("..");
1589  /****************** mCBM Sync *****************************************/
1590 
1591  if ("" != sFileName) {
1592  // Restore original directory position
1593  histoFile->Close();
1594  oldDir->cd();
1595  } // if( "" != sFileName )
1596 }
1597 void CbmMcbm2018MonitorMcbmSync::ResetAllHistos() {
1598  /****************** STS Sync ******************************************/
1599  /****************** STS Sync ******************************************/
1600 
1601  /****************** TOF Sync ******************************************/
1602 
1603  /****************** TOF Sync ******************************************/
1604 
1605  /****************** mCBM Sync *****************************************/
1606  fhMcbmHitsNbPerMs->Reset();
1607  fhMcbmTimeDiffToDiamond->Reset();
1608  fhMcbmTimeDiffToDiamondWide->Reset();
1609  fhMcbmTimeDiffToDiamondTs->Reset();
1610 
1611  fhMcbmTimeDiffToMuch->Reset();
1612  fhMcbmTimeDiffToMuchWide->Reset();
1613  fhMcbmTimeDiffToMuchTs->Reset();
1614 
1615  fhMcbmStsTimeDiffToMuchVsAdc->Reset();
1616  fhMcbmStsTimeDiffToMuchWideVsAdc->Reset();
1617  fhMcbmStsTimeDiffToMuchTsVsAdc->Reset();
1618 
1619  for (UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb) {
1620  fvhMcbmTimeDiffToDiamondEvoDpb[uDpb]->Reset();
1621  fvhMcbmTimeDiffToDiamondWideEvoDpb[uDpb]->Reset();
1622  fvhMcbmTimeDiffToDiamondTsEvoDpb[uDpb]->Reset();
1623 
1624  if (fdSpillStartA < fdSpillStartC) {
1625  fvhHitsTimeEvoSpillA[uDpb]->Reset();
1626  fvhHitsTimeEvoSpillB[uDpb]->Reset();
1627 
1628  fvhMcbmTimeDiffToDiamondEvoSpillA[uDpb]->Reset();
1629  fvhMcbmTimeDiffToDiamondEvoSpillB[uDpb]->Reset();
1630 
1631  fvhMcbmTimeDiffToMuchEvoSpillA[uDpb]->Reset();
1632  fvhMcbmTimeDiffToMuchEvoSpillB[uDpb]->Reset();
1633  } // if( fdSpillStartA < fdSpillStartC )
1634  } // for( UInt_t uDpb = 0; uDpb < fuTotalNrOfDpb; ++uDpb )
1635  /****************** mCBM Sync *****************************************/
1636 }
1637 
1638 ClassImp(CbmMcbm2018MonitorMcbmSync)
CbmMcbm2018MonitorMcbmSync::CreateStsHistograms
void CreateStsHistograms()
All hits (time in bins, ADC in bins, asic, channel) in last TS, sorted with "<" operator.
Definition: CbmMcbm2018MonitorMcbmSync.cxx:249
gdpbv100::MSG_STAR_TRI_A
@ MSG_STAR_TRI_A
Definition: gDpbMessv100.h:63
gdpbv100::Message
Definition: gDpbMessv100.h:133
CbmMcbm2018MonitorMcbmSync::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: CbmMcbm2018MonitorMcbmSync.h:154
CbmMcbm2018MonitorMcbmSync::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:147
CbmMcbm2018MonitorMcbmSync::fvhHitsTimeEvoSpillA
std::vector< TH1 * > fvhHitsTimeEvoSpillA
Definition: CbmMcbm2018MonitorMcbmSync.h:231
CbmMcbm2018MonitorMcbmSync::FillStsHitInfo
void FillStsHitInfo(stsxyter::Message mess, const UInt_t &uMsIdx)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1241
CbmMcbm2018MonitorMcbmSync.h
CbmMcbm2018MonitorMcbmSync::fvmTofGdpbHitsInTs
std::vector< std::vector< gdpbv100::FullMessage > > fvmTofGdpbHitsInTs
Definition: CbmMcbm2018MonitorMcbmSync.h:197
gdpbv100::Message::getGdpbEpEpochNb
uint32_t getGdpbEpEpochNb() const
Definition: gDpbMessv100.h:231
CbmMcbm2018MonitorMcbmSync::CreateMcbmHistograms
void CreateMcbmHistograms()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:385
CbmMcbm2018MonitorMcbmSync::fhMcbmStsTimeDiffToMuchVsAdc
TH2 * fhMcbmStsTimeDiffToMuchVsAdc
Definition: CbmMcbm2018MonitorMcbmSync.h:220
CbmMcbm2018MonitorMcbmSync::fulTofCurrentEpochTime
ULong64_t fulTofCurrentEpochTime
Definition: CbmMcbm2018MonitorMcbmSync.h:190
CbmMcbm2018MonitorMcbmSync::fuTofNrOfDpbs
UInt_t fuTofNrOfDpbs
Definition: CbmMcbm2018MonitorMcbmSync.h:109
CbmMcbm2018MonitorMcbmSync::fviTofMsgCounter
std::vector< int > fviTofMsgCounter
Definition: CbmMcbm2018MonitorMcbmSync.h:178
CbmMcbm2018TofPar::GetGdpbId
Int_t GetGdpbId(Int_t i)
Definition: CbmMcbm2018TofPar.h:67
CbmMcbm2018MonitorMcbmSync::fvhMcbmTimeDiffToDiamondEvoSpillB
std::vector< TH2 * > fvhMcbmTimeDiffToDiamondEvoSpillB
Definition: CbmMcbm2018MonitorMcbmSync.h:235
CbmMcbm2018TofPar.h
stsxyter::Message
Definition: StsXyterMessage.h:165
gdpbv100::msg_print_Human
@ msg_print_Human
Definition: gDpbMessv100.h:91
CbmMcbm2018MonitorMcbmSync::fvmTofGdpbHitsInMs
std::vector< std::vector< gdpbv100::FullMessage > > fvmTofGdpbHitsInMs
Buffer for system sync check.
Definition: CbmMcbm2018MonitorMcbmSync.h:196
CbmMcbm2018MonitorMcbmSync::fhMcbmHitsNbPerMs
TH2 * fhMcbmHitsNbPerMs
Definition: CbmMcbm2018MonitorMcbmSync.h:210
stsxyter::MessType::Status
@ Status
CbmMcbm2018StsPar::GetDpbId
UInt_t GetDpbId(UInt_t uDpbIdx)
Definition: CbmMcbm2018StsPar.cxx:206
gdpbv100::MSG_HIT
@ MSG_HIT
Definition: gDpbMessv100.h:59
CbmMcbm2018MonitorMcbmSync::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:158
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
gdpbv100::MSG_SLOWC
@ MSG_SLOWC
Definition: gDpbMessv100.h:61
CbmMcbm2018MonitorMcbmSync::AddMsComponentToListSts
void AddMsComponentToListSts(size_t component)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:224
CbmMcbm2018MonitorMcbmSync::fbPrintMessages
Bool_t fbPrintMessages
Definition: CbmMcbm2018MonitorMcbmSync.h:128
CbmMcbm2018MonitorMcbmSync::fmMsgCounter
std::map< stsxyter::MessType, UInt_t > fmMsgCounter
Definition: CbmMcbm2018MonitorMcbmSync.h:134
CbmMcbm2018MonitorMcbmSync
Definition: CbmMcbm2018MonitorMcbmSync.h:34
gdpbv100::Message::getMessageType
uint8_t getMessageType() const
Returns the message type. Valid for all message types. 4 bit.
Definition: gDpbMessv100.h:206
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:172
gdpbv100::MSG_STAR_TRI_D
@ MSG_STAR_TRI_D
Definition: gDpbMessv100.h:66
stsxyter::Message::GetTsMsbVal
uint32_t GetTsMsbVal() const
For TS MSB data: Returns the TS MSB 22 bit field)
Definition: StsXyterMessage.h:334
stsxyter::Message::GetLinkIndex
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:249
stsxyter::MessType
MessType
Message types.
Definition: StsXyterMessage.h:27
gdpbv100::Message::setGdpbEpEpochNb
void setGdpbEpEpochNb(uint32_t v)
Definition: gDpbMessv100.h:283
CbmMcbm2018MonitorMcbmSync::AddMsComponentToList
virtual void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:203
CbmMcbm2018MonitorMcbmSync::fPrintMessCtrlSts
stsxyter::MessagePrintMask fPrintMessCtrlSts
Definition: CbmMcbm2018MonitorMcbmSync.h:129
stsxyter::kulTsCycleNbBins
static const uint64_t kulTsCycleNbBins
Definition: StsXyterMessage.h:152
gdpbv100::kuEpochCounterSz
const uint32_t kuEpochCounterSz
Definition: gDpbMessv100.h:40
CbmMcbm2018MonitorMcbmSync::fbTsLevelAna
Bool_t fbTsLevelAna
Definition: CbmMcbm2018MonitorMcbmSync.h:117
CbmMcbm2018MonitorMcbmSync::CreateTofHistograms
void CreateTofHistograms()
Processing methods.
Definition: CbmMcbm2018MonitorMcbmSync.cxx:313
CbmMcbm2018StsPar::GetNrOfDpbs
UInt_t GetNrOfDpbs()
Definition: CbmMcbm2018StsPar.h:83
CbmMcbm2018MonitorMcbmSync::fdTofMsIndex
Double_t fdTofMsIndex
Definition: CbmMcbm2018MonitorMcbmSync.h:173
CbmMcbm2018MonitorMcbmSync::fdSpillStartB
Double_t fdSpillStartB
Definition: CbmMcbm2018MonitorMcbmSync.h:229
CbmMcbm2018MonitorMcbmSync::fUnpackParTof
CbmMcbm2018TofPar * fUnpackParTof
Unpacking and mapping parameters for TOF.
Definition: CbmMcbm2018MonitorMcbmSync.h:108
CbmMcbm2018MonitorMcbmSync::fvhMcbmTimeDiffToDiamondWideEvoDpb
std::vector< TH2 * > fvhMcbmTimeDiffToDiamondWideEvoDpb
Definition: CbmMcbm2018MonitorMcbmSync.h:225
CbmMcbm2018MonitorMcbmSync::fuTotalNrOfDpb
UInt_t fuTotalNrOfDpb
Global parameters.
Definition: CbmMcbm2018MonitorMcbmSync.h:113
CbmMcbm2018MonitorMcbmSync::fvmTofEpSupprBuffer
std::vector< std::vector< gdpbv100::Message > > fvmTofEpSupprBuffer
Buffer for suppressed epoch processing.
Definition: CbmMcbm2018MonitorMcbmSync.h:193
CbmMcbm2018MonitorMcbmSync::fvhMcbmTimeDiffToMuchEvoSpillB
std::vector< TH2 * > fvhMcbmTimeDiffToMuchEvoSpillB
Definition: CbmMcbm2018MonitorMcbmSync.h:238
CbmMcbm2018MonitorMcbmSync::fvhMcbmTimeDiffToDiamondEvoSpillA
std::vector< TH2 * > fvhMcbmTimeDiffToDiamondEvoSpillA
Definition: CbmMcbm2018MonitorMcbmSync.h:234
stsxyter::Message::GetHitAdc
uint16_t GetHitAdc() const
For Hit data: Returns ADC value (5 bit field)
Definition: StsXyterMessage.h:277
CbmMcbm2018MonitorMcbmSync::CbmMcbm2018MonitorMcbmSync
CbmMcbm2018MonitorMcbmSync()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:53
CbmMcbm2018MonitorMcbmSync::ResetAllHistos
void ResetAllHistos()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1597
CbmMcbm2018TofPar::GetNrOfGdpbs
Int_t GetNrOfGdpbs()
FIXME: replace with method returning the correspondign constants! see Star2019 parameter.
Definition: CbmMcbm2018TofPar.h:66
bMcbm2018WriteSync
Bool_t bMcbm2018WriteSync
Definition: CbmMcbm2018MonitorMcbmSync.cxx:42
CbmMcbm2018MonitorMcbmSync::fvhMcbmTimeDiffToMuchEvoSpillA
std::vector< TH2 * > fvhMcbmTimeDiffToMuchEvoSpillA
Definition: CbmMcbm2018MonitorMcbmSync.h:237
gdpbv100::MSG_STAR_TRI_C
@ MSG_STAR_TRI_C
Definition: gDpbMessv100.h:65
stsxyter::MessType::Empty
@ Empty
h
Data class with information on a STS local track.
CbmMcbm2018MonitorMcbmSync::fvulTofCurrentEpochFull
std::vector< ULong64_t > fvulTofCurrentEpochFull
Definition: CbmMcbm2018MonitorMcbmSync.h:188
CbmMcbm2018MonitorMcbmSync::Init
virtual Bool_t Init()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:127
CbmMcbm2018MonitorMcbmSync::fvhHitsTimeEvoSpillB
std::vector< TH1 * > fvhHitsTimeEvoSpillB
Definition: CbmMcbm2018MonitorMcbmSync.h:232
stsxyter::FinalHit
Definition: StsXyterFinalHit.h:16
CbmMcbm2018MonitorMcbmSync::fbUseBestPair
Bool_t fbUseBestPair
Definition: CbmMcbm2018MonitorMcbmSync.h:116
stsxyter::MessType::Hit
@ Hit
CbmMcbm2018MonitorMcbmSync::fhMcbmTimeDiffToDiamondTs
TH2 * fhMcbmTimeDiffToDiamondTs
Definition: CbmMcbm2018MonitorMcbmSync.h:214
CbmMcbm2018MonitorMcbmSync::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmMcbm2018MonitorMcbmSync.h:98
CbmMcbm2018MonitorMcbmSync::fhMcbmTimeDiffToDiamond
TH2 * fhMcbmTimeDiffToDiamond
Definition: CbmMcbm2018MonitorMcbmSync.h:212
stsxyter::kuHitNbTsBins
static const uint32_t kuHitNbTsBins
Definition: StsXyterMessage.h:146
CbmMcbm2018StsPar::ElinkIdxToAsicIdx
UInt_t ElinkIdxToAsicIdx(Bool_t bFebType, UInt_t uElink)
Definition: CbmMcbm2018StsPar.h:69
CbmMcbm2018MonitorMcbmSync::fdMuchTofOffsetNs
Double_t fdMuchTofOffsetNs
Definition: CbmMcbm2018MonitorMcbmSync.h:115
CbmMcbm2018MonitorMcbmSync::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmMcbm2018MonitorMcbmSync.h:97
CbmMcbm2018MonitorMcbmSync::fvuStsCurrentTsMsbCycle
std::vector< UInt_t > fvuStsCurrentTsMsbCycle
Current TS MSB for each DPB.
Definition: CbmMcbm2018MonitorMcbmSync.h:148
gdpbv100::kuChipIdMergedEpoch
const uint32_t kuChipIdMergedEpoch
Definition: gDpbMessv100.h:51
CbmMcbm2018MonitorMcbmSync::fvulTofCurrentEpoch
std::vector< ULong64_t > fvulTofCurrentEpoch
Definition: CbmMcbm2018MonitorMcbmSync.h:186
ClassImp
ClassImp(CbmConverterManager) InitStatus CbmConverterManager
Definition: CbmConverterManager.cxx:12
CbmMcbm2018MonitorMcbmSync::fhMcbmTimeDiffToMuchWide
TH2 * fhMcbmTimeDiffToMuchWide
Definition: CbmMcbm2018MonitorMcbmSync.h:217
CbmMcbm2018MonitorMcbmSync::fhMcbmTimeDiffToMuch
TH2 * fhMcbmTimeDiffToMuch
Definition: CbmMcbm2018MonitorMcbmSync.h:216
CbmMcbm2018MonitorMcbmSync::fvulStsCurrentTsMsb
std::vector< ULong64_t > fvulStsCurrentTsMsb
Bin size in s for the plots with date as X axis.
Definition: CbmMcbm2018MonitorMcbmSync.h:147
CbmMcbm2018MonitorMcbmSync::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Definition: CbmMcbm2018MonitorMcbmSync.h:136
CbmMcbm2018MonitorMcbmSync::fuMuchDpbIdx
UInt_t fuMuchDpbIdx
Map of DPB Identifier to DPB index.
Definition: CbmMcbm2018MonitorMcbmSync.h:106
CbmMcbm2018MonitorMcbmSync::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Definition: CbmMcbm2018MonitorMcbmSync.h:131
gdpbv100::MSG_SYST
@ MSG_SYST
Definition: gDpbMessv100.h:62
CbmMcbm2018MonitorMcbmSync::fvMsComponentsListTof
std::vector< size_t > fvMsComponentsListTof
Definition: CbmMcbm2018MonitorMcbmSync.h:96
CbmMcbm2018MonitorMcbmSync::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Definition: CbmMcbm2018MonitorMcbmSync.h:132
CbmMcbm2018MonitorMcbmSync::Reset
virtual void Reset()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1519
stsxyter::kdClockCycleNs
static const double kdClockCycleNs
Definition: StsXyterMessage.h:156
CbmMcbm2018MonitorMcbmSync::Finish
virtual void Finish()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1521
CbmMcbm2018MonitorMcbmSync::FillTofEpochCycle
void FillTofEpochCycle(uint64_t ulCycleData)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1443
CbmMcbm2018StsPar
Definition: CbmMcbm2018StsPar.h:18
stsxyter::Message::GetMessType
MessType GetMessType() const
Returns the message type, see enum MessType.
Definition: StsXyterMessage.h:259
CbmMcbm2018MonitorMcbmSync::fhMcbmTimeDiffToDiamondWide
TH2 * fhMcbmTimeDiffToDiamondWide
Definition: CbmMcbm2018MonitorMcbmSync.h:213
CbmMcbm2018MonitorMcbmSync::SetNbMsInTs
virtual void SetNbMsInTs(size_t uCoreMsNb, size_t uOverlapMsNb)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:240
CbmMcbm2018MonitorMcbmSync::fmStsDpbIdIndexMap
std::map< UInt_t, UInt_t > fmStsDpbIdIndexMap
Total number of Sts DPBs in system.
Definition: CbmMcbm2018MonitorMcbmSync.h:105
CbmMcbm2018MonitorMcbmSync::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018MonitorMcbmSync.h:138
CbmMcbm2018MonitorMcbmSync::AddMsComponentToListTof
void AddMsComponentToListTof(size_t component)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:232
gdpbv100::MessagePrintMask
MessagePrintMask
Definition: gDpbMessv100.h:87
CbmMcbm2018MonitorMcbmSync::FillTofEpochInfo
void FillTofEpochInfo(gdpbv100::Message)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1476
CbmMcbm2018MonitorMcbmSync::fmTofDpbIdIndexMap
std::map< UInt_t, UInt_t > fmTofDpbIdIndexMap
Total number of GDPBs in the system.
Definition: CbmMcbm2018MonitorMcbmSync.h:110
CbmMcbm2018MonitorMcbmSync::fhMcbmTimeDiffToMuchTs
TH2 * fhMcbmTimeDiffToMuchTs
Definition: CbmMcbm2018MonitorMcbmSync.h:218
CbmMcbm2018MonitorMcbmSync::fuTofGdpbId
UInt_t fuTofGdpbId
Definition: CbmMcbm2018MonitorMcbmSync.h:174
CbmMcbm2018TofPar
Definition: CbmMcbm2018TofPar.h:18
CbmMcbm2018MonitorMcbmSync::fvMsComponentsListSts
std::vector< size_t > fvMsComponentsListSts
Definition: CbmMcbm2018MonitorMcbmSync.h:90
CbmMcbm2018MonitorMcbmSync::fdStsTofOffsetNs
Double_t fdStsTofOffsetNs
Definition: CbmMcbm2018MonitorMcbmSync.h:114
CbmMcbm2018MonitorMcbmSync::fsHistoFileFullname
TString fsHistoFileFullname
Definition: CbmMcbm2018MonitorMcbmSync.h:126
CbmMcbm2018MonitorMcbmSync::SaveAllHistos
void SaveAllHistos(TString sFileName="")
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1538
CbmMcbm2018MonitorMcbmSync::fvhMcbmTimeDiffToDiamondEvoDpb
std::vector< TH2 * > fvhMcbmTimeDiffToDiamondEvoDpb
Definition: CbmMcbm2018MonitorMcbmSync.h:224
gdpbv100::MSG_EPOCH
@ MSG_EPOCH
Definition: gDpbMessv100.h:60
gdpbv100
Definition: gDpbMessv100.cxx:29
stsxyter::Message::GetHitChannel
uint16_t GetHitChannel() const
For Hit data: Returns StsXYTER channel number (7 bit field)
Definition: StsXyterMessage.h:274
CbmMcbm2018MonitorMcbmSync::kuTofBytesPerMessage
static const UInt_t kuTofBytesPerMessage
TODO => move to the message class!!
Definition: CbmMcbm2018MonitorMcbmSync.h:122
stsxyter::Message::PrintMess
bool PrintMess(std::ostream &os, MessagePrintMask ctrl=MessagePrintMask::msg_print_Human) const
Definition: StsXyterMessage.cxx:29
CbmMcbm2018MonitorMcbmSync::FillTofHitInfo
void FillTofHitInfo(gdpbv100::Message)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1450
gdpbv100::kulEpochCycleFieldSz
const uint64_t kulEpochCycleFieldSz
Definition: gDpbMessv100.h:49
gdpbv100::Message::getGdpbHitIs24b
uint16_t getGdpbHitIs24b() const
Definition: gDpbMessv100.h:218
CbmMcbm2018MonitorMcbmSync::fuTofGdpbNr
UInt_t fuTofGdpbNr
Definition: CbmMcbm2018MonitorMcbmSync.h:176
gdpbv100::Message::getGdpbGenChipId
uint16_t getGdpbGenChipId() const
Definition: gDpbMessv100.h:214
CbmMcbm2018MonitorMcbmSync::FillStsEpochInfo
void FillStsEpochInfo(stsxyter::Message mess)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1354
CbmMcbm2018MonitorMcbmSync::fuDiamondDpbIdx
UInt_t fuDiamondDpbIdx
Definition: CbmMcbm2018MonitorMcbmSync.h:111
gdpbv100::MSG_STAR_TRI_B
@ MSG_STAR_TRI_B
Definition: gDpbMessv100.h:64
gdpbv100::kulEpochCycleBins
const uint64_t kulEpochCycleBins
Definition: gDpbMessv100.h:42
CbmMcbm2018MonitorMcbmSync::kuStsBytesPerMessage
static const UInt_t kuStsBytesPerMessage
Definition: CbmMcbm2018MonitorMcbmSync.h:120
CbmMcbm2018MonitorMcbmSync::fhMcbmStsTimeDiffToMuchTsVsAdc
TH2 * fhMcbmStsTimeDiffToMuchTsVsAdc
Definition: CbmMcbm2018MonitorMcbmSync.h:222
CbmMcbm2018MonitorMcbmSync::SetParContainers
void SetParContainers()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:136
bMcbm2018ResetSync
Bool_t bMcbm2018ResetSync
Definition: CbmMcbm2018MonitorMcbmSync.cxx:41
CbmMcbm2018MonitorMcbmSync::ProcessStsMs
Bool_t ProcessStsMs(const fles::Timeslice &ts, size_t uMsComp, UInt_t uMsIdx)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1146
stsxyter::MessType::TsMsb
@ TsMsb
CbmMcbm2018MonitorMcbmSync::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition: CbmMcbm2018MonitorMcbmSync.h:140
gdpbv100::FullMessage
Definition: gDpbMessv100.h:362
CbmMcbm2018MonitorMcbmSync::fuStsNrOfDpbs
UInt_t fuStsNrOfDpbs
Definition: CbmMcbm2018MonitorMcbmSync.h:103
stsxyter::Message::GetHitTime
uint16_t GetHitTime() const
For Hit data: Returns timestamp (8 bit field, 2 MSB bits overlap removed)
Definition: StsXyterMessage.h:286
stsxyter::MessType::Dummy
@ Dummy
CbmMcbm2018StsPar.h
CbmMcbm2018MonitorMcbmSync::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmMcbm2018MonitorMcbmSync.h:100
stsxyter::MessType::Epoch
@ Epoch
CbmMcbm2018MonitorMcbmSync::fdSpillStartA
Double_t fdSpillStartA
Definition: CbmMcbm2018MonitorMcbmSync.h:228
CbmMcbm2018MonitorMcbmSync::DoUnpack
virtual Bool_t DoUnpack(const fles::Timeslice &ts, size_t component)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:671
CbmMcbm2018MonitorMcbmSync::fhMcbmStsTimeDiffToMuchWideVsAdc
TH2 * fhMcbmStsTimeDiffToMuchWideVsAdc
Definition: CbmMcbm2018MonitorMcbmSync.h:221
CbmMcbm2018MonitorMcbmSync::fvhMcbmTimeDiffToDiamondTsEvoDpb
std::vector< TH2 * > fvhMcbmTimeDiffToDiamondTsEvoDpb
Definition: CbmMcbm2018MonitorMcbmSync.h:226
stsxyter::kuHitNbAdcBins
static const uint32_t kuHitNbAdcBins
Status/properties constants.
Definition: StsXyterMessage.h:144
CbmMcbm2018MonitorMcbmSync::FillStsTsMsbInfo
void FillStsTsMsbInfo(stsxyter::Message mess, UInt_t uMessIdx=0, UInt_t uMsIdx=0)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1318
gdpbv100::Message::getMsgFullTime
uint64_t getMsgFullTime(uint64_t epoch) const
Returns expanded and adjusted time of message (in ns)
Definition: gDpbMessv100.cxx:98
CbmMcbm2018MonitorMcbmSync::~CbmMcbm2018MonitorMcbmSync
virtual ~CbmMcbm2018MonitorMcbmSync()
Definition: CbmMcbm2018MonitorMcbmSync.cxx:125
CbmMcbm2018MonitorMcbmSync::fvmStsSdpbHitsInMs
std::vector< std::vector< stsxyter::FinalHit > > fvmStsSdpbHitsInMs
Current TS MSB cycle for DPB.
Definition: CbmMcbm2018MonitorMcbmSync.h:152
CbmMcbm2018MonitorMcbmSync::fdSpillStartC
Double_t fdSpillStartC
Definition: CbmMcbm2018MonitorMcbmSync.h:230
CbmMcbmUnpack
Definition: CbmMcbmUnpack.h:15
CbmMcbm2018MonitorMcbmSync::fUnpackParSts
CbmMcbm2018StsPar * fUnpackParSts
Definition: CbmMcbm2018MonitorMcbmSync.h:102
stsxyter
Definition: StsXyterFinalHit.h:12
CbmMcbm2018StsPar::GetNbChanPerAsic
static constexpr UInt_t GetNbChanPerAsic()
Definition: CbmMcbm2018StsPar.h:52
CbmMcbm2018MonitorMcbmSync::fvulTofCurrentEpochCycle
std::vector< ULong64_t > fvulTofCurrentEpochCycle
Definition: CbmMcbm2018MonitorMcbmSync.h:187
CbmMcbm2018MonitorMcbmSync::ProcessTofMs
Bool_t ProcessTofMs(const fles::Timeslice &ts, size_t uMsComp, UInt_t uMsIdx)
Definition: CbmMcbm2018MonitorMcbmSync.cxx:1361