CbmRoot
CbmMcbm2018MonitorAlgoTof.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018MonitorAlgoTof -----
4 // ----- Created 27.11.2019 by P.-A. Loizeau -----
5 // ----- -----
6 // -----------------------------------------------------------------------------
7 
8 #include "CbmMcbm2018MonitorAlgoTof.h"
9 
10 #include "CbmFlesHistosTools.h"
11 #include "CbmFormatMsHeaderPrintout.h"
12 #include "CbmMcbm2018TofPar.h"
13 #include "CbmTofAddress.h"
14 #include "CbmTofDetectorId_v14a.h" // in cbmdata/tof
15 
16 #include "FairLogger.h"
17 #include "FairRootManager.h"
18 #include "FairRun.h"
19 #include "FairRunOnline.h"
20 #include "FairRuntimeDb.h"
21 
22 #include "TCanvas.h"
23 #include "TH1.h"
24 #include "TH2.h"
25 #include "TList.h"
26 #include "TPaveStats.h"
27 #include "TProfile.h"
28 #include "TProfile2D.h"
29 #include "TROOT.h"
30 #include "TString.h"
31 
32 #include <fstream>
33 #include <iomanip>
34 #include <iostream>
35 #include <stdint.h>
36 
37 // -------------------------------------------------------------------------
38 CbmMcbm2018MonitorAlgoTof::CbmMcbm2018MonitorAlgoTof()
39  : CbmStar2019Algo()
40  ,
42  fbDebugMonitorMode(kFALSE)
43  , fbIgnoreCriticalErrors(kFALSE)
44  , fvbMaskedComponents()
45  , fUnpackPar(nullptr)
46  , fuNrOfGdpbs(0)
47  , fGdpbIdIndexMap()
48  , fuNrOfFeePerGdpb(0)
49  , fuNrOfGet4PerFee(0)
50  , fuNrOfChannelsPerGet4(0)
51  , fuNrOfChannelsPerFee(0)
52  , fuNrOfGet4(0)
53  , fuNrOfGet4PerGdpb(0)
54  , fuNrOfChannelsPerGdpb(0)
55  , fuMinTotPulser(90)
56  , fuMaxTotPulser(100)
57  , fulCurrentTsIdx(0)
58  , fulCurrentMsIdx(0)
59  , fdTsStartTime(-1.0)
60  , fdTsStopTimeCore(-1.0)
61  , fdMsTime(-1.0)
62  , fuMsIndex(0)
63  , fmMsgCounter()
64  , fuCurrentEquipmentId(0)
65  , fuCurrDpbId(0)
66  , fuCurrDpbIdx(0)
67  , fiRunStartDateTimeSec(-1)
68  , fiBinSizeDatePlots(-1)
69  , fuGet4Id(0)
70  , fuGet4Nr(0)
71  , fvulCurrentEpoch()
72  , fvulCurrentEpochCycle()
73  , fvulCurrentEpochFull()
74  , fvmEpSupprBuffer()
75  , fdStartTime(-1.0)
76  , fdStartTimeMsSz(0.0)
77  , ftStartTimeUnix(std::chrono::steady_clock::now())
78  , fvulGdpbTsMsb()
79  , fvulGdpbTsLsb()
80  , fvulStarTsMsb()
81  , fvulStarTsMid()
82  , fvulGdpbTsFullLast()
83  , fvulStarTsFullLast()
84  , fvuStarTokenLast()
85  , fvuStarDaqCmdLast()
86  , fvuStarTrigCmdLast()
87  , fbEpochSinceLastHit(kTRUE)
88  , fuDuplicatesCount(0)
89  , fmLastHit(0)
90  , fuHistoryHistoSize(3600)
91  , fhMessType(nullptr)
92  , fhSysMessType(nullptr)
93  , fhGet4MessType(nullptr)
94  , fhGet4ChanScm(nullptr)
95  , fhGet4ChanErrors(nullptr)
96  , fhGet4EpochFlags(nullptr)
97  , fhGdpbAsicSpiCounts(nullptr)
98  , fhGdpbMessType(nullptr)
99  , fhGdpbSysMessType(nullptr)
100  , fhGdpbSysMessPattType(nullptr)
101  , fhGdpbEpochFlags(nullptr)
102  , fhGdpbEpochSyncEvo(nullptr)
103  , fhGdpbEpochMissEvo(nullptr)
104  , fhGdpbEndMsBufferNotEmpty(nullptr)
105  , fhGdpbEndMsDataLost(nullptr)
106  , fhGdpbHitRate(nullptr)
107  , fvhGdpbGet4MessType()
108  , fvhGdpbGet4ChanScm()
109  , fvhGdpbGet4ChanErrors()
110  , fhMsgCntEvo(nullptr)
111  , fhHitCntEvo(nullptr)
112  , fhErrorCntEvo(nullptr)
113  , fhLostEvtCntEvo(nullptr)
114  , fhErrorFractEvo(nullptr)
115  , fhLostEvtFractEvo(nullptr)
116  , fhMsgCntPerMsEvo(nullptr)
117  , fhHitCntPerMsEvo(nullptr)
118  , fhErrorCntPerMsEvo(nullptr)
119  , fhLostEvtCntPerMsEvo(nullptr)
120  , fhErrorFractPerMsEvo(nullptr)
121  , fhLostEvtFractPerMsEvo(nullptr)
122  , fvhRawFt_gDPB()
123  , fvhRawCt_gDPB()
124  , fvhRemapTot_gDPB()
125  , fvhRemapChCount_gDPB()
126  , fvhRemapChRate_gDPB()
127  , fvhRemapChErrFract_gDPB()
128  , fuNbMissmatchPattern()
129  , fhNbMissPatternPerMs(nullptr)
130  , fhPatternMissmatch(nullptr)
131  , fhPatternEnable(nullptr)
132  , fhPatternResync(nullptr)
133  , fvhGdpbPatternMissmatchEvo()
134  , fvhGdpbPatternEnableEvo()
135  , fvhGdpbPatternResyncEvo()
136  , fvvbGdpbLastMissmatchPattern()
137  , fvvbGdpbLastEnablePattern()
138  , fvvbGdpbLastResyncPattern()
139  , fvhGdpbMissmatchEvoPerTs()
140  , fvhGdpbMissmatchEnaEvoPerTs()
141  , fvhGdpbEnableEvoPerTs()
142  , fvhGdpbResyncEvoPerTs()
143  , fvhGdpbResyncEnaEvoPerTs()
144  , fvhGdpbStateEvoPerTs()
145  , fvhTokenMsgType()
146  , fvhTriggerRate()
147  , fvhCmdDaqVsTrig()
148  , fvhStarTokenEvo()
149  , fvhStarTrigGdpbTsEvo()
150  , fvhStarTrigStarTsEvo()
151  , fcSummary(nullptr)
152  , fcSummaryGdpb(nullptr)
153  , fvcSumGdpbGet4()
154  , fcStarTrigTokenType(nullptr)
155  , fcStarTriggerRate(nullptr)
156  , fcStarTrigCmdDaqVsTrig(nullptr)
157  , fcStarTrigStarTokenEvo(nullptr)
158  , fcStarTrigGdpbTsEvo(nullptr)
159  , fcStarTrigStarTsEvo(nullptr) {}
160 CbmMcbm2018MonitorAlgoTof::~CbmMcbm2018MonitorAlgoTof() {
162  fvmEpSupprBuffer.clear();
163 }
164 
165 // -------------------------------------------------------------------------
166 Bool_t CbmMcbm2018MonitorAlgoTof::Init() {
167  LOG(info) << "Initializing mCBM T0 2019 monitor algo";
168 
169  return kTRUE;
170 }
171 void CbmMcbm2018MonitorAlgoTof::Reset() {}
172 void CbmMcbm2018MonitorAlgoTof::Finish() {
174 
176 }
177 
178 // -------------------------------------------------------------------------
179 Bool_t CbmMcbm2018MonitorAlgoTof::InitContainers() {
180  LOG(info) << "Init parameter containers for CbmMcbm2018MonitorAlgoTof";
181  Bool_t initOK = ReInitContainers();
182 
183  return initOK;
184 }
185 Bool_t CbmMcbm2018MonitorAlgoTof::ReInitContainers() {
186  LOG(info) << "**********************************************";
187  LOG(info) << "ReInit parameter containers for CbmMcbm2018MonitorAlgoTof";
188 
189  fUnpackPar = (CbmMcbm2018TofPar*) fParCList->FindObject("CbmMcbm2018TofPar");
190  if (nullptr == fUnpackPar) return kFALSE;
191 
192  Bool_t initOK = InitParameters();
193 
194  return initOK;
195 }
196 TList* CbmMcbm2018MonitorAlgoTof::GetParList() {
197  if (nullptr == fParCList) fParCList = new TList();
198  fUnpackPar = new CbmMcbm2018TofPar("CbmMcbm2018TofPar");
199  fParCList->Add(fUnpackPar);
200 
201  return fParCList;
202 }
203 Bool_t CbmMcbm2018MonitorAlgoTof::InitParameters() {
204  LOG(info) << "Debug Monitor mode: " << (fbDebugMonitorMode ? "ON" : "OFF");
205 
206  if (kTRUE == fbIgnoreCriticalErrors)
207  LOG(warning) << "Monitor set to ignore critical GET4 errors!!! No printout "
208  "will be delivered for those!!!!";
209 
210  fuNrOfGdpbs = fUnpackPar->GetNrOfGdpbs();
211  LOG(info) << "Nr. of Tof GDPBs: " << fuNrOfGdpbs;
212 
213  fuNrOfFeePerGdpb = fUnpackPar->GetNrOfFeePerGdpb();
214  LOG(info) << "Nr. of FEES per Tof GDPB: " << fuNrOfFeePerGdpb;
215 
216  fuNrOfGet4PerFee = fUnpackPar->GetNrOfGet4PerFee();
217  LOG(info) << "Nr. of GET4 per Tof FEE: " << fuNrOfGet4PerFee;
218 
219  fuNrOfChannelsPerGet4 = fUnpackPar->GetNrOfChannelsPerGet4();
220  LOG(info) << "Nr. of channels per GET4: " << fuNrOfChannelsPerGet4;
221 
222  fuNrOfChannelsPerFee = fuNrOfGet4PerFee * fuNrOfChannelsPerGet4;
223  LOG(info) << "Nr. of channels per FEE: " << fuNrOfChannelsPerFee;
224 
225  fuNrOfGet4 = fuNrOfGdpbs * fuNrOfFeePerGdpb * fuNrOfGet4PerFee;
226  LOG(info) << "Nr. of GET4s: " << fuNrOfGet4;
227 
228  fuNrOfGet4PerGdpb = fuNrOfFeePerGdpb * fuNrOfGet4PerFee;
229  LOG(info) << "Nr. of GET4s per GDPB: " << fuNrOfGet4PerGdpb;
230 
231  fuNrOfChannelsPerGdpb = fuNrOfGet4PerGdpb * fuNrOfChannelsPerGet4;
232  LOG(info) << "Nr. of channels per GDPB: " << fuNrOfChannelsPerGdpb;
233 
234  fGdpbIdIndexMap.clear();
235  for (UInt_t i = 0; i < fuNrOfGdpbs; ++i) {
236  fGdpbIdIndexMap[fUnpackPar->GetGdpbId(i)] = i;
237  LOG(info) << "GDPB Id of TOF " << i << " : " << std::hex
238  << fUnpackPar->GetGdpbId(i) << std::dec;
239  } // for( UInt_t i = 0; i < fuNrOfGdpbs; ++i )
240 
242  fdMsSizeInNs = fUnpackPar->GetSizeMsInNs();
243  LOG(info) << "Timeslice parameters: each MS is " << fdMsSizeInNs << " ns";
244 
246  if (-1 < fiGdpbIndex) {
247  if (fuNrOfGdpbs <= static_cast<UInt_t>(fiGdpbIndex))
248  LOG(fatal) << "Selected gDPB out of bounds relative to parameter file: "
249  << fiGdpbIndex << " VS " << fuNrOfGdpbs;
250  else
251  LOG(info) << "Selected gDPB " << fiGdpbIndex
252  << " for single gDPB analysis";
253 
254  fuNrOfGdpbs = 1;
255  fGdpbIdIndexMap.clear();
256  fGdpbIdIndexMap[fUnpackPar->GetGdpbId(fiGdpbIndex)] = 0;
257  } // if( -1 < fiGdpbIndex )
258 
260  fvulCurrentEpoch.resize(fuNrOfGdpbs, 0);
261  fvulCurrentEpochCycle.resize(fuNrOfGdpbs, 0);
262  fvulCurrentEpochFull.resize(fuNrOfGdpbs, 0);
263 
266  fvvbGdpbLastMissmatchPattern.resize(fuNrOfGdpbs);
267  fvvbGdpbLastEnablePattern.resize(fuNrOfGdpbs);
268  fvvbGdpbLastResyncPattern.resize(fuNrOfGdpbs);
270  fvulGdpbTsMsb.resize(fuNrOfGdpbs);
271  fvulGdpbTsLsb.resize(fuNrOfGdpbs);
272  fvulStarTsMsb.resize(fuNrOfGdpbs);
273  fvulStarTsMid.resize(fuNrOfGdpbs);
274  fvulGdpbTsFullLast.resize(fuNrOfGdpbs);
275  fvulStarTsFullLast.resize(fuNrOfGdpbs);
276  fvuStarTokenLast.resize(fuNrOfGdpbs);
277  fvuStarDaqCmdLast.resize(fuNrOfGdpbs);
278  fvuStarTrigCmdLast.resize(fuNrOfGdpbs);
279  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
281  fvvbGdpbLastMissmatchPattern[uGdpb].resize(fuNrOfGet4PerGdpb, kFALSE);
282  fvvbGdpbLastEnablePattern[uGdpb].resize(fuNrOfGet4PerGdpb, kTRUE);
283  fvvbGdpbLastResyncPattern[uGdpb].resize(fuNrOfGet4PerGdpb, kFALSE);
285  fvulGdpbTsMsb[uGdpb] = 0;
286  fvulGdpbTsLsb[uGdpb] = 0;
287  fvulStarTsMsb[uGdpb] = 0;
288  fvulStarTsMid[uGdpb] = 0;
289  fvulGdpbTsFullLast[uGdpb] = 0;
290  fvulStarTsFullLast[uGdpb] = 0;
291  fvuStarTokenLast[uGdpb] = 0;
292  fvuStarDaqCmdLast[uGdpb] = 0;
293  fvuStarTrigCmdLast[uGdpb] = 0;
294  } // for (Int_t iGdpb = 0; iGdpb < fuNrOfGdpbs; ++iGdpb)
295 
296  if (kTRUE == fbDebugMonitorMode) fuNbMissmatchPattern.resize(fuNrOfGdpbs, 0);
297 
298  return kTRUE;
299 }
300 // -------------------------------------------------------------------------
301 
302 void CbmMcbm2018MonitorAlgoTof::AddMsComponentToList(size_t component,
303  UShort_t usDetectorId) {
305  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsList.size(); ++uCompIdx)
306  if (component == fvMsComponentsList[uCompIdx]) return;
307 
309  fvMsComponentsList.push_back(component);
310 
311  LOG(info) << "CbmMcbm2018MonitorAlgoTof::AddMsComponentToList => Component "
312  << component << " with detector ID 0x" << std::hex << usDetectorId
313  << std::dec << " added to list";
314 }
315 // -------------------------------------------------------------------------
316 
317 Bool_t CbmMcbm2018MonitorAlgoTof::ProcessTs(const fles::Timeslice& ts) {
318  fulCurrentTsIdx = ts.index();
319  fdTsStartTime = static_cast<Double_t>(ts.descriptor(0, 0).idx);
320 
322  if (0 == fulCurrentTsIdx) return kTRUE;
323 
325  if (-1.0 == fdTsCoreSizeInNs) {
326  fuNbCoreMsPerTs = ts.num_core_microslices();
327  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
328  fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
329  fdTsFullSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs + fuNbOverMsPerTs);
330  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
331  << " Core MS and " << fuNbOverMsPerTs
332  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
333  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
334 
336  fuNbMsLoop = fuNbCoreMsPerTs;
337  if (kFALSE == fbIgnoreOverlapMs) fuNbMsLoop += fuNbOverMsPerTs;
338  LOG(info) << "In each TS " << fuNbMsLoop << " MS will be looped over";
339  } // if( -1.0 == fdTsCoreSizeInNs )
340 
342  fdTsStopTimeCore = fdTsStartTime + fdTsCoreSizeInNs;
343  // LOG(info) << Form( "TS %5d Start %12f Stop %12f", fulCurrentTsIdx, fdTsStartTime, fdTsStopTimeCore );
344 
346  for (fuMsIndex = 0; fuMsIndex < fuNbMsLoop; fuMsIndex++) {
348  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size();
349  ++uMsCompIdx) {
350  UInt_t uMsComp = fvMsComponentsList[uMsCompIdx];
351 
352  if (kFALSE == ProcessMs(ts, uMsComp, fuMsIndex)) {
353  LOG(error) << "Failed to process ts " << fulCurrentTsIdx << " MS "
354  << fuMsIndex << " for component " << uMsComp;
355  return kFALSE;
356  } // if( kFALSE == ProcessMs( ts, uMsCompIdx, fuMsIndex ) )
357  } // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
358 
359  if (kTRUE == fbDebugMonitorMode) {
360  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
361  fhNbMissPatternPerMs->Fill(fuNbMissmatchPattern[uGdpb], uGdpb);
362  fuNbMissmatchPattern[uGdpb] = 0;
363  } // for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb)
364  } // if( kTRUE == fbDebugMonitorMode )
365  } // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
366 
368  if (kFALSE == FillHistograms()) {
369  LOG(error) << "Failed to fill histos in ts " << fulCurrentTsIdx;
370  return kFALSE;
371  } // if( kFALSE == FillHistograms() )
372 
373  return kTRUE;
374 }
375 
376 Bool_t CbmMcbm2018MonitorAlgoTof::ProcessMs(const fles::Timeslice& ts,
377  size_t uMsCompIdx,
378  size_t uMsIdx) {
379  auto msDescriptor = ts.descriptor(uMsCompIdx, uMsIdx);
380  fuCurrentEquipmentId = msDescriptor.eq_id;
381  const uint8_t* msContent =
382  reinterpret_cast<const uint8_t*>(ts.content(uMsCompIdx, uMsIdx));
383 
384  uint32_t uSize = msDescriptor.size;
385  fulCurrentMsIdx = msDescriptor.idx;
386  fuCurrentMsSysId = static_cast<uint32_t>(msDescriptor.sys_id);
387  fdMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
388  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
389  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
390 
391  if (0 == fvbMaskedComponents.size())
392  fvbMaskedComponents.resize(ts.num_components(), kFALSE);
393 
394  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
395  // fuCurrDpbIdx = fDpbIdIndexMap[ fuCurrDpbId ];
396 
398  auto it = fGdpbIdIndexMap.find(fuCurrDpbId);
399  if (it == fGdpbIdIndexMap.end()) {
400  if (kFALSE == fvbMaskedComponents[uMsCompIdx]) {
401  LOG(info)
402  << "---------------------------------------------------------------";
403  LOG(info) << FormatMsHeaderPrintout(msDescriptor);
404  LOG(warning) << "Could not find the gDPB index for AFCK id 0x" << std::hex
405  << fuCurrDpbId << std::dec << " in timeslice "
406  << fulCurrentTsIdx << " in microslice " << uMsIdx
407  << " component " << uMsCompIdx << "\n"
408  << "If valid this index has to be added in the TOF "
409  "parameter file in the DbpIdArray field";
410  fvbMaskedComponents[uMsCompIdx] = kTRUE;
411  } // if( kFALSE == fvbMaskedComponents[ uMsComp ] )
412  else
413  return kTRUE;
414 
417 
418  return kFALSE;
419  } // if( it == fGdpbIdIndexMap.end() )
420  else
421  fuCurrDpbIdx = fGdpbIdIndexMap[fuCurrDpbId];
422 
424  if (fdStartTime < 0) fdStartTime = (fbUseAbsoluteTime ? 0.0 : fdMsTime);
426  else if (fuHistoryHistoSize < fdMsTime - fdStartTime) {
427  ResetEvolutionHistograms();
428  fdStartTime = (fbUseAbsoluteTime
429  ? fuHistoryHistoSize
430  * static_cast<uint32_t>(fdMsTime / fuHistoryHistoSize)
431  : fdMsTime);
432  } // else if( fuHistoryHistoSize < fdMsTime - fdStartTime )
433  /*
435  if (fdStartTimeLong < 0)
436  fdStartTimeLong = fdMsTime;
438  if( fuHistoryHistoSizeLong < 1e-9 * (fdMsTime - fdStartTimeLong) / 60.0 )
439  {
440  ResetLongEvolutionHistograms();
441  fdStartTimeLong = dHitTime;
442  } // if( fuHistoryHistoSize < 1e-9 * (fdMsTime - fdStartTimeLong) / 60.0 )
443 */
444 
445  // If not integer number of message in input buffer, print warning/error
446  if (0 != (uSize % kuBytesPerMessage))
447  LOG(error) << "The input microslice buffer does NOT "
448  << "contain only complete nDPB messages!";
449 
450  // Compute the number of complete messages in the input microslice buffer
451  uint32_t uNbMessages =
452  (uSize - (uSize % kuBytesPerMessage)) / kuBytesPerMessage;
453 
454  // Prepare variables for the loop on contents
455  Int_t messageType = -111;
456  const uint64_t* pInBuff = reinterpret_cast<const uint64_t*>(msContent);
457  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
458  // Fill message
459  uint64_t ulData = static_cast<uint64_t>(pInBuff[uIdx]);
460 
462  if (0 == uIdx) {
463  ProcessEpochCycle(ulData);
464  continue;
465  } // if( 0 == uIdx )
466 
467  gdpbv100::Message mess(ulData);
469  messageType = mess.getMessageType();
470  fhMessType->Fill(messageType);
471  fhGdpbMessType->Fill(messageType, fuCurrDpbIdx);
472 
473  fuGet4Id = fUnpackPar->ElinkIdxToGet4Idx(mess.getGdpbGenChipId());
475  if (0x90 == fuCurrentMsSysId) fuGet4Id = mess.getGdpbGenChipId();
476  fuGet4Nr = (fuCurrDpbIdx * fuNrOfGet4PerGdpb) + fuGet4Id;
477 
478  if (fuNrOfGet4PerGdpb <= fuGet4Id && !mess.isStarTrigger()
479  && (gdpbv100::kuChipIdMergedEpoch != fuGet4Id))
480  LOG(warning) << "Message with Get4 ID too high: " << fuGet4Id << " VS "
481  << fuNrOfGet4PerGdpb << " set in parameters.";
482 
483  switch (messageType) {
484  case gdpbv100::MSG_HIT: {
485  if (mess.getGdpbHitIs24b()) {
487  LOG(fatal) << "This monitor does not support 24b hit messages!!!.";
488  continue;
489  } // if( getGdpbHitIs24b() )
490  else {
492  fhGdpbHitRate->Fill(fdMsTime - fdStartTime, fuCurrDpbIdx);
493  fhGet4MessType->Fill(fuGet4Nr, 0);
494  fvhGdpbGet4MessType[fuCurrDpbIdx]->Fill(fuGet4Id, 0);
495 
496  fhErrorFractEvo->Fill(fdMsTime - fdStartTime, 0.0);
497  fhLostEvtFractEvo->Fill(fdMsTime - fdStartTime, 0.0);
498 
499  fhMsgCntEvo->Fill(fdMsTime - fdStartTime);
500  fhHitCntEvo->Fill(fdMsTime - fdStartTime);
501  /*
502  if( kFALSE == fbEpochSinceLastHit )
503  {
504  if( fmLastHit != mess )
505  {
506  if( 0 < fuDuplicatesCount )
507  {
508  LOG(warning) << "Detected duplicate hits in gDPB " << fuCurrDpbIdx
509  << ": " << fuDuplicatesCount << " times "
510  << Form( "0x%16lx", fmLastHit.getData() );
511  } // if( 0 < fuDuplicatesCount )
512  fmLastHit = mess;
513  fuDuplicatesCount = 0;
514  }
515  else fuDuplicatesCount++;
516  } // if( kFALSE == fbEpochSinceLastHit )
517  else
518  {
519  fmLastHit = mess;
520  fbEpochSinceLastHit = kFALSE;
521  } // else of if( kFALSE == fbEpochSinceLastHit )
522 */
523  fvmEpSupprBuffer.push_back(mess);
524  } // else of if( getGdpbHitIs24b() )
525  break;
526  } // case gdpbv100::MSG_HIT:
527  case gdpbv100::MSG_EPOCH: {
528  if (gdpbv100::kuChipIdMergedEpoch == fuGet4Id) {
529  ProcessEpoch(mess);
530  } // if this epoch message is a merged one valid for all chips
531  else {
533  LOG(fatal) << "This event builder does not support unmerged epoch "
534  "messages!!!.";
535  continue;
536  } // if single chip epoch message
537  break;
538  } // case gdpbv100::MSG_EPOCH:
539  case gdpbv100::MSG_SLOWC: {
540  ProcessSlowCtrl(mess);
541  break;
542  } // case gdpbv100::MSG_SLOWC:
543  case gdpbv100::MSG_SYST: {
544  ProcessSysMess(mess);
545  break;
546  } // case gdpbv100::MSG_SYST:
547  case gdpbv100::MSG_STAR_TRI_A:
548  case gdpbv100::MSG_STAR_TRI_B:
549  case gdpbv100::MSG_STAR_TRI_C:
550  case gdpbv100::MSG_STAR_TRI_D: {
551  ProcessStarTrig(mess);
552  break;
553  } // case gdpbv100::MSG_STAR_TRI_A-D
554  default:
555  LOG(fatal) << "Message type " << std::hex << std::setw(2)
556  << static_cast<uint16_t>(messageType)
557  << " not included in Get4 data format.";
558  } // switch( mess.getMessageType() )
559  } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
560 
563  if (0 < fvmEpSupprBuffer.size()) {
564  fhGdpbEndMsBufferNotEmpty->Fill(fuCurrDpbIdx);
565  fhGdpbEndMsDataLost->Fill(fuCurrDpbIdx, fvmEpSupprBuffer.size());
566  } // if( 0 < fvmEpSupprBuffer.size() )
567 
569  fvmEpSupprBuffer.clear();
570 
572  FillHistograms();
573 
574  return kTRUE;
575 }
576 
577 // -------------------------------------------------------------------------
578 void CbmMcbm2018MonitorAlgoTof::ProcessEpochCycle(uint64_t ulCycleData) {
579  ULong64_t ulEpochCycleVal = ulCycleData & gdpbv100::kulEpochCycleFieldSz;
580 
581  if (!(ulEpochCycleVal == fvulCurrentEpochCycle[fuCurrDpbIdx]
582  || ulEpochCycleVal == fvulCurrentEpochCycle[fuCurrDpbIdx] + 1)
583  && 0 < fulCurrentMsIdx) {
584  LOG(warning) << "CbmMcbm2018MonitorAlgoTof::ProcessEpochCycle => "
585  << " Missmatch in epoch cycles detected for Gdpb "
586  << fuCurrDpbIdx
587  << ", probably fake cycles due to epoch index corruption! "
588  << Form(" Current cycle 0x%09llX New cycle 0x%09llX",
589  fvulCurrentEpochCycle[fuCurrDpbIdx],
590  ulEpochCycleVal);
591  } // if epoch cycle did not stay constant or increase by exactly 1, except if first MS of the TS
592  if (ulEpochCycleVal != fvulCurrentEpochCycle[fuCurrDpbIdx]) {
593  LOG(info) << "CbmStar2019EventBuilderEtofAlgo::ProcessEpochCycle => "
594  << " New epoch cycle for Gdpb " << fuCurrDpbIdx
595  << Form(": Current cycle 0x%09llX New cycle 0x%09llX",
596  fvulCurrentEpochCycle[fuCurrDpbIdx],
597  ulEpochCycleVal);
598  } // if( ulEpochCycleVal != fvulCurrentEpochCycle[fuCurrDpbIdx] )
599  fvulCurrentEpochCycle[fuCurrDpbIdx] = ulEpochCycleVal;
600 
601  return;
602 }
603 void CbmMcbm2018MonitorAlgoTof::ProcessEpoch(gdpbv100::Message mess) {
604  ULong64_t ulEpochNr = mess.getGdpbEpEpochNb();
605  Bool_t bSyncFlag = (1 == mess.getGdpbEpSync());
606  Bool_t bDataLoss = (1 == mess.getGdpbEpDataLoss());
607  Bool_t bEpochLoss = (1 == mess.getGdpbEpEpochLoss());
608  Bool_t bMissmMatch = (1 == mess.getGdpbEpMissmatch());
609 
610  fvulCurrentEpoch[fuCurrDpbIdx] = ulEpochNr;
611  fvulCurrentEpochFull[fuCurrDpbIdx] =
612  ulEpochNr
613  + (gdpbv100::kuEpochCounterSz + 1) * fvulCurrentEpochCycle[fuCurrDpbIdx];
614 
616  if (bSyncFlag) {
617  fhGdpbEpochFlags->Fill(fuCurrDpbIdx, 0);
618  fhGdpbEpochSyncEvo->Fill(fdMsTime - fdStartTime, fuCurrDpbIdx);
619  } // if( bSyncFlag )
620 
621  if (bDataLoss) fhGdpbEpochFlags->Fill(fuCurrDpbIdx, 1);
622 
623  if (bEpochLoss) fhGdpbEpochFlags->Fill(fuCurrDpbIdx, 2);
624 
625  if (bMissmMatch) {
626  fhGdpbEpochFlags->Fill(fuCurrDpbIdx, 3);
627  fhGdpbEpochMissEvo->Fill(fdMsTime - fdStartTime, fuCurrDpbIdx);
628  } // if( bMissmMatch )
629 
630  for (uint32_t uGet4Index = 0; uGet4Index < fuNrOfGet4PerGdpb; uGet4Index++) {
631  fuGet4Id = uGet4Index;
632  fuGet4Nr = (fuCurrDpbIdx * fuNrOfGet4PerGdpb) + fuGet4Id;
633 
634  fhGet4MessType->Fill(fuGet4Nr, 1);
635  fvhGdpbGet4MessType[fuCurrDpbIdx]->Fill(fuGet4Id, 1);
636 
637  if (bSyncFlag) fhGet4EpochFlags->Fill(fuGet4Nr, 0);
638  if (bDataLoss) fhGet4EpochFlags->Fill(fuGet4Nr, 1);
639  if (bEpochLoss) fhGet4EpochFlags->Fill(fuGet4Nr, 2);
640  if (bMissmMatch) fhGet4EpochFlags->Fill(fuGet4Nr, 3);
641  } // for( uint32_t uGet4Index = 0; uGet4Index < fuNrOfGet4PerGdpb; uGet4Index ++ )
642 
643  if (0 < fuDuplicatesCount)
644  LOG(warning) << "Detected duplicate hits: " << fuDuplicatesCount
645  << " times "
646  << Form("0x%16lx",
647  static_cast<unsigned long>(fmLastHit.getData()));
648  fbEpochSinceLastHit = kTRUE;
649  fuDuplicatesCount = 0;
650 
652  ProcessEpSupprBuffer();
653 }
654 // -------------------------------------------------------------------------
655 void CbmMcbm2018MonitorAlgoTof::ProcessEpSupprBuffer() {
656  Int_t iBufferSize = fvmEpSupprBuffer.size();
657 
658  if (0 == iBufferSize) return;
659 
660  LOG(debug) << "Now processing stored messages for for gDPB " << fuCurrDpbIdx
661  << " with epoch number " << (fvulCurrentEpoch[fuCurrDpbIdx] - 1);
662 
665  std::stable_sort(fvmEpSupprBuffer.begin(), fvmEpSupprBuffer.end());
666 
668  ULong64_t ulCurEpochGdpbGet4 = fvulCurrentEpochFull[fuCurrDpbIdx];
669 
671  if (0 == ulCurEpochGdpbGet4) return;
672 
674  ulCurEpochGdpbGet4--;
675 
676  Int_t messageType = -111;
677  for (Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++) {
678  messageType = fvmEpSupprBuffer[iMsgIdx].getMessageType();
679 
680  fuGet4Id = fUnpackPar->ElinkIdxToGet4Idx(
681  fvmEpSupprBuffer[iMsgIdx].getGdpbGenChipId());
683  if (0x90 == fuCurrentMsSysId)
684  fuGet4Id = fvmEpSupprBuffer[iMsgIdx].getGdpbGenChipId();
685  fuGet4Nr = (fuCurrDpbIdx * fuNrOfGet4PerGdpb) + fuGet4Id;
686 
688  gdpbv100::FullMessage fullMess(fvmEpSupprBuffer[iMsgIdx],
689  ulCurEpochGdpbGet4);
690 
692  switch (messageType) {
693  case gdpbv100::MSG_HIT: {
694  ProcessHit(fullMess);
695  break;
696  } // case gdpbv100::MSG_HIT:
697  case gdpbv100::MSG_SLOWC:
699  break;
700  case gdpbv100::MSG_SYST: {
702  if (gdpbv100::SYS_GET4_ERROR == fullMess.getGdpbSysSubType())
703  ProcessError(fullMess);
704  break;
705  } // case gdpbv100::MSG_SYST:
706  case gdpbv100::MSG_EPOCH:
707  case gdpbv100::MSG_STAR_TRI_A:
708  case gdpbv100::MSG_STAR_TRI_B:
709  case gdpbv100::MSG_STAR_TRI_C:
710  case gdpbv100::MSG_STAR_TRI_D:
712  break;
713  default:
714  LOG(error) << "Message type " << std::hex << std::setw(2)
715  << static_cast<uint16_t>(messageType)
716  << " not included in Get4 unpacker.";
717  } // switch( mess.getMessageType() )
718  } // for( Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++ )
719 
720  fvmEpSupprBuffer.clear();
721 }
722 // -------------------------------------------------------------------------
723 void CbmMcbm2018MonitorAlgoTof::ProcessHit(gdpbv100::FullMessage mess) {
724  UInt_t uChannel = mess.getGdpbHitChanId();
725  UInt_t uTot = mess.getGdpbHit32Tot();
726 
730  UInt_t uFts = mess.getGdpbHitFullTs() % 112;
731  UInt_t uCts = mess.getGdpbHitFullTs() / 112;
732 
733  UInt_t uChannelNr = fuGet4Id * fuNrOfChannelsPerGet4 + uChannel;
734  UInt_t uChannelNrInFee =
735  (fuGet4Id % fuNrOfGet4PerFee) * fuNrOfChannelsPerGet4 + uChannel;
736  UInt_t uFeeNr = (fuGet4Id / fuNrOfGet4PerFee);
737  // UInt_t uFeeNrInSys = fuCurrDpbIdx * fuNrOfFeePerGdpb + uFeeNr;
738  UInt_t uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee
739  + fUnpackPar->Get4ChanToPadiChan(uChannelNrInFee);
741  if (0x90 == fuCurrentMsSysId)
742  uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee + uChannelNrInFee;
743  // UInt_t uGbtxNr = (uFeeNr / fUnpackPar->GetNrOfFeePerGbtx());
744  // UInt_t uFeeInGbtx = (uFeeNr % fUnpackPar->GetNrOfFeePerGbtx());
745  // UInt_t uGbtxNrInSys = fuCurrDpbIdx * fUnpackPar->GetNrOfGbtxPerGdpb() + uGbtxNr;
746 
747  // UInt_t uChanInSyst = fuCurrDpbIdx * fuNrOfChannelsPerGdpb + uChannelNr;
748  // UInt_t uRemappedChannelNrInSys = fuCurrDpbIdx * fuNrOfChannelsPerGdpb
749  // + uFeeNr * fuNrOfChannelsPerFee
750  // + fUnpackPar->Get4ChanToPadiChan( uChannelNrInFee );
751 
752  // ULong_t ulHitTime = mess.getMsgFullTime( mess.getExtendedEpoch() );
753  Double_t dHitTime = mess.GetFullTimeNs();
754  // Double_t dHitTot = uTot; // in bins
755 
757  if (kTRUE == fbDebugMonitorMode) {
758  fvhRawFt_gDPB[fuCurrDpbIdx]->Fill(uChannelNr, uFts);
759  fvhRawCt_gDPB[fuCurrDpbIdx]->Fill(uChannelNr, uCts);
760  } // if( kTRUE == fbDebugMonitorMode )
761 
763  if (4096 <= uCts) {
764  LOG(debug)
765  << "CbmMcbm2018MonitorAlgoTof::ProcessHit => Coarse time above 4096 "
766  "detected."
767  << Form(
768  " gDPB %02u GET4 %03u Channel %u, TS %8llu MS %3u (MS time %12llu)",
769  fuCurrDpbIdx,
770  fuGet4Id,
771  uChannel,
772  fulCurrentTsIdx,
773  fuMsIndex,
774  fulCurrentMsIdx);
775  } // if( 4096 <= uCts )
776 
778  fvhRemapChCount_gDPB[fuCurrDpbIdx]->Fill(uRemappedChannelNr);
779  fvhRemapTot_gDPB[fuCurrDpbIdx]->Fill(uRemappedChannelNr, uTot);
780 
783  if (0 <= fdStartTime) {
784  fvhRemapChRate_gDPB[fuCurrDpbIdx]->Fill(1e-9 * dHitTime - fdStartTime,
785  uRemappedChannelNr);
786  if (kTRUE == fbDebugMonitorMode)
787  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
788  1e-9 * dHitTime - fdStartTime, uRemappedChannelNr, 0);
789  // fvhFeeRate_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill( 1e-9 * (dHitTime - fdStartTime));
790  // fvhFeeErrorRatio_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill( 1e-9 * (dHitTime - fdStartTime), 0, 1);
791  } // if (0 <= fdStartTime)
792  /*
793  if (0 <= fdStartTimeLong)
794  {
795  fvhFeeRateLong_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill(
796  1e-9 / 60.0 * (dHitTime - fdStartTimeLong), 1 / 60.0 );
797  fvhFeeErrorRatioLong_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill(
798  1e-9 / 60.0 * (dHitTime - fdStartTimeLong), 0, 1 / 60.0 );
799  } // if (0 <= fdStartTimeLong)
800 */
801 }
802 // -------------------------------------------------------------------------
803 void CbmMcbm2018MonitorAlgoTof::ProcessSysMess(gdpbv100::FullMessage mess) {
804  UInt_t uSubType = mess.getGdpbSysSubType();
805  fhSysMessType->Fill(uSubType);
806  fhGdpbSysMessType->Fill(uSubType, fuCurrDpbIdx);
807 
808  switch (mess.getGdpbSysSubType()) {
809  case gdpbv100::SYS_GET4_ERROR: {
811  fhGet4MessType->Fill(fuGet4Nr, 3);
812  fvhGdpbGet4MessType[fuCurrDpbIdx]->Fill(fuGet4Id, 3);
813 
815  fvmEpSupprBuffer.push_back(mess);
816  // ProcessError( mess );
817  break;
818  } // case gdpbv100::SYSMSG_GET4_EVENT
819  case gdpbv100::SYS_GDPB_UNKWN: {
820  LOG(debug) << "Unknown GET4 message, data: " << std::hex << std::setw(8)
821  << mess.getGdpbSysUnkwData() << std::dec
822  << " Full message: " << std::hex << std::setw(16)
823  << mess.getData() << std::dec;
824  break;
825  } // case gdpbv100::SYS_GDPB_UNKWN:
826  case gdpbv100::SYS_GET4_SYNC_MISS: {
827  if (mess.getGdpbSysFwErrResync())
828  LOG(info) << Form("GET4 Resynchronization: Get4:0x%04x ",
829  mess.getGdpbGenChipId())
830  << fuCurrDpbIdx;
831  else
832  LOG(info) << "GET4 synchronization pulse missing in gDPB "
833  << fuCurrDpbIdx;
834  break;
835  } // case gdpbv100::SYS_GET4_SYNC_MISS:
836  case gdpbv100::SYS_PATTERN: {
837  ProcessPattern(mess);
838  break;
839  } // case gdpbv100::SYS_PATTERN:
840  default: {
841  LOG(info) << "Crazy system message, subtype " << mess.getGdpbSysSubType();
842  break;
843  } // default
844  } // switch( mess.getGdpbSysSubType() )
845 }
846 // -------------------------------------------------------------------------
847 void CbmMcbm2018MonitorAlgoTof::ProcessError(gdpbv100::FullMessage mess) {
848  uint32_t uErrorType = mess.getGdpbSysErrData();
849 
850  fhGet4MessType->Fill(fuGet4Nr, 3);
851  fvhGdpbGet4MessType[fuCurrDpbIdx]->Fill(fuGet4Id, 3);
852 
853  // UInt_t uFeeNr = (fuGet4Id / fuNrOfGet4PerFee);
854 
856  fhErrorFractEvo->Fill(fdMsTime - fdStartTime, 0.0);
857  fhLostEvtFractEvo->Fill(fdMsTime - fdStartTime, 0.0);
858 
859  fhMsgCntEvo->Fill(fdMsTime - fdStartTime);
860  fhErrorCntEvo->Fill(fdMsTime - fdStartTime);
861  fhErrorFractEvo->Fill(fdMsTime - fdStartTime, 1.0);
862 
863  if (gdpbv100::GET4_V2X_ERR_LOST_EVT == uErrorType) {
864  fhLostEvtCntEvo->Fill(fdMsTime - fdStartTime);
865  fhLostEvtFractEvo->Fill(fdMsTime - fdStartTime, 1.0);
866  } // if( gdpbv100::GET4_V2X_ERR_LOST_EVT == mess.getGdpbSysErrData() )
867  /*
869  if (0 <= fdStartTime)
870  {
871  fvhFeeErrorRate_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill(
872  1e-9 * (mess.getMsgFullTimeD(fvulCurrentEpoch[fuGet4Nr]) - fdStartTime));
873  fvhFeeErrorRatio_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill(
874  1e-9 * (mess.getMsgFullTimeD(fvulCurrentEpoch[fuGet4Nr]) - fdStartTime), 1, 1 );
875  } // if (0 <= fdStartTime)
876  if (0 <= fdStartTimeLong)
877  {
878  fvhFeeErrorRateLong_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill(
879  1e-9 / 60.0 * (mess.getMsgFullTimeD(fvulCurrentEpoch[fuGet4Nr]) - fdStartTimeLong), 1 / 60.0);
880  fvhFeeErrorRatioLong_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill(
881  1e-9 / 60.0 * (mess.getMsgFullTimeD(fvulCurrentEpoch[fuGet4Nr]) - fdStartTimeLong), 1, 1 / 60.0);
882  } // if (0 <= fdStartTime)
883 */
884  Int_t dGdpbChId =
885  fuGet4Id * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId();
886  UInt_t uChannelNrInFee = (fuGet4Id % fuNrOfGet4PerFee) * fuNrOfChannelsPerGet4
887  + mess.getGdpbSysErrChanId();
888  UInt_t uFeeNr = (fuGet4Id / fuNrOfGet4PerFee);
889  // UInt_t uFeeNrInSys = fuCurrDpbIdx * fuNrOfFeePerGdpb + uFeeNr;
890  UInt_t uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee
891  + fUnpackPar->Get4ChanToPadiChan(uChannelNrInFee);
893  if (0x90 == fuCurrentMsSysId)
894  uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee + uChannelNrInFee;
895 
896  Int_t dFullChId =
897  fuGet4Nr * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId();
898 
899  switch (uErrorType) {
900  case gdpbv100::GET4_V2X_ERR_READ_INIT: {
901  fhGet4ChanErrors->Fill(dFullChId, 0);
902  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 0);
903  break;
904  } // case gdpbv100::GET4_V2X_ERR_READ_INIT:
905  case gdpbv100::GET4_V2X_ERR_SYNC: {
906  fhGet4ChanErrors->Fill(dFullChId, 1);
907  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 1);
908  break;
909  } // case gdpbv100::GET4_V2X_ERR_SYNC:
910  case gdpbv100::GET4_V2X_ERR_EP_CNT_SYNC: {
911  fhGet4ChanErrors->Fill(dFullChId, 2);
912  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 2);
913  break;
914  } // case gdpbv100::GET4_V2X_ERR_EP_CNT_SYNC:
915  case gdpbv100::GET4_V2X_ERR_EP: {
916  fhGet4ChanErrors->Fill(dFullChId, 3);
917  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 3);
918  break;
919  } // case gdpbv100::GET4_V2X_ERR_EP:
920  case gdpbv100::GET4_V2X_ERR_FIFO_WRITE: {
921  fhGet4ChanErrors->Fill(dFullChId, 4);
922  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 4);
923  break;
924  } // case gdpbv100::GET4_V2X_ERR_FIFO_WRITE:
925  case gdpbv100::GET4_V2X_ERR_LOST_EVT: {
926  fhGet4ChanErrors->Fill(dFullChId, 5);
927  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 5);
928  break;
929  } // case gdpbv100::GET4_V2X_ERR_LOST_EVT:
930  case gdpbv100::GET4_V2X_ERR_CHAN_STATE: {
931  fhGet4ChanErrors->Fill(dFullChId, 6);
932  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 6);
933  break;
934  } // case gdpbv100::GET4_V2X_ERR_CHAN_STATE:
935  case gdpbv100::GET4_V2X_ERR_TOK_RING_ST: {
936  fhGet4ChanErrors->Fill(dFullChId, 7);
937  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 7);
938  break;
939  } // case gdpbv100::GET4_V2X_ERR_TOK_RING_ST:
940  case gdpbv100::GET4_V2X_ERR_TOKEN: {
941  fhGet4ChanErrors->Fill(dFullChId, 8);
942  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 8);
943  break;
944  } // case gdpbv100::GET4_V2X_ERR_TOKEN:
945  case gdpbv100::GET4_V2X_ERR_READOUT_ERR: {
946  fhGet4ChanErrors->Fill(dFullChId, 9);
947  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 9);
948  break;
949  } // case gdpbv100::GET4_V2X_ERR_READOUT_ERR:
950  case gdpbv100::GET4_V2X_ERR_SPI: {
951  fhGet4ChanErrors->Fill(dFullChId, 10);
952  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 10);
953  break;
954  } // case gdpbv100::GET4_V2X_ERR_SPI:
955  case gdpbv100::GET4_V2X_ERR_DLL_LOCK: {
956  fhGet4ChanErrors->Fill(dFullChId, 11);
957  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 11);
958  break;
959  } // case gdpbv100::GET4_V2X_ERR_DLL_LOCK:
960  case gdpbv100::GET4_V2X_ERR_DLL_RESET: {
961  fhGet4ChanErrors->Fill(dFullChId, 12);
962  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 12);
963  break;
964  } // case gdpbv100::GET4_V2X_ERR_DLL_RESET:
965  case gdpbv100::GET4_V2X_ERR_TOT_OVERWRT: {
966  fhGet4ChanErrors->Fill(dFullChId, 13);
967  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 13);
968  if (kTRUE == fbDebugMonitorMode)
969  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
970  fdMsTime - fdStartTime, uRemappedChannelNr, 1);
971  break;
972  } // case gdpbv100::GET4_V2X_ERR_TOT_OVERWRT:
973  case gdpbv100::GET4_V2X_ERR_TOT_RANGE: {
974  fhGet4ChanErrors->Fill(dFullChId, 14);
975  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 14);
976  if (kTRUE == fbDebugMonitorMode)
977  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
978  fdMsTime - fdStartTime, uRemappedChannelNr, 1);
979  break;
980  } // case gdpbv100::GET4_V2X_ERR_TOT_RANGE:
981  case gdpbv100::GET4_V2X_ERR_EVT_DISCARD: {
982  fhGet4ChanErrors->Fill(dFullChId, 15);
983  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 15);
984  if (kTRUE == fbDebugMonitorMode)
985  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
986  fdMsTime - fdStartTime, uRemappedChannelNr, 1);
987  break;
988  } // case gdpbv100::GET4_V2X_ERR_EVT_DISCARD:
989  case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG: {
990  fhGet4ChanErrors->Fill(dFullChId, 16);
991  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 16);
992  if (kTRUE == fbDebugMonitorMode)
993  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
994  fdMsTime - fdStartTime, uRemappedChannelNr, 1);
995  break;
996  } // case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG:
997  case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL: {
998  fhGet4ChanErrors->Fill(dFullChId, 17);
999  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 17);
1000  if (kTRUE == fbDebugMonitorMode)
1001  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
1002  fdMsTime - fdStartTime, uRemappedChannelNr, 1);
1003  break;
1004  } // case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL:
1005  case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER: {
1006  fhGet4ChanErrors->Fill(dFullChId, 18);
1007  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 18);
1008  if (kTRUE == fbDebugMonitorMode)
1009  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
1010  fdMsTime - fdStartTime, uRemappedChannelNr, 1);
1011  break;
1012  } // case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER:
1013  case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF: {
1014  fhGet4ChanErrors->Fill(dFullChId, 19);
1015  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 19);
1016  if (kTRUE == fbDebugMonitorMode)
1017  fvhRemapChErrFract_gDPB[fuCurrDpbIdx]->Fill(
1018  fdMsTime - fdStartTime, uRemappedChannelNr, 1);
1019  break;
1020  } // case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF:
1021  case gdpbv100::GET4_V2X_ERR_UNKNOWN: {
1022  fhGet4ChanErrors->Fill(dFullChId, 20);
1023  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 20);
1024  break;
1025  } // case gdpbv100::GET4_V2X_ERR_UNKNOWN:
1026  default: // Corrupt error or not yet supported error
1027  {
1028  fhGet4ChanErrors->Fill(dFullChId, 21);
1029  fvhGdpbGet4ChanErrors[fuCurrDpbIdx]->Fill(dGdpbChId, 21);
1030  break;
1031  } //
1032  } // Switch( mess.getGdpbSysErrData() )
1033 
1034  switch (uErrorType) {
1035  case gdpbv100::GET4_V2X_ERR_READ_INIT:
1036  case gdpbv100::GET4_V2X_ERR_SYNC:
1037  case gdpbv100::GET4_V2X_ERR_EP_CNT_SYNC:
1038  case gdpbv100::GET4_V2X_ERR_EP:
1039  case gdpbv100::GET4_V2X_ERR_FIFO_WRITE:
1040  case gdpbv100::GET4_V2X_ERR_CHAN_STATE:
1041  case gdpbv100::GET4_V2X_ERR_TOK_RING_ST:
1042  case gdpbv100::GET4_V2X_ERR_TOKEN:
1043  case gdpbv100::GET4_V2X_ERR_READOUT_ERR:
1044  case gdpbv100::GET4_V2X_ERR_DLL_LOCK:
1045  case gdpbv100::GET4_V2X_ERR_DLL_RESET: {
1047  if (kFALSE == fbIgnoreCriticalErrors)
1048  LOG(info) << " +++++++ > gDPB: " << std::hex << std::setw(4)
1049  << fuCurrDpbIdx << std::dec << ", Chip = " << std::setw(2)
1050  << mess.getGdpbGenChipId() << ", Chan = " << std::setw(1)
1051  << mess.getGdpbSysErrChanId() << ", Edge = " << std::setw(1)
1052  << mess.getGdpbSysErrEdge() << ", Empt = " << std::setw(1)
1053  << mess.getGdpbSysErrUnused() << ", Data = " << std::hex
1054  << std::setw(2) << uErrorType << std::dec
1055  << " -- GET4 V1 Error Event";
1056  break;
1057  } // critical errors
1058  case gdpbv100::GET4_V2X_ERR_SPI:
1060  break;
1061  case gdpbv100::GET4_V2X_ERR_LOST_EVT:
1062  case gdpbv100::GET4_V2X_ERR_TOT_OVERWRT:
1063  case gdpbv100::GET4_V2X_ERR_TOT_RANGE:
1064  case gdpbv100::GET4_V2X_ERR_EVT_DISCARD:
1065  case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG:
1066  case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL:
1067  case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER: {
1069  LOG(debug) << " +++++++ >gDPB: " << std::hex << std::setw(4)
1070  << fuCurrDpbIdx << std::dec << ", Chip = " << std::setw(2)
1071  << mess.getGdpbGenChipId() << ", Chan = " << std::setw(1)
1072  << mess.getGdpbSysErrChanId() << ", Edge = " << std::setw(1)
1073  << mess.getGdpbSysErrEdge() << ", Empt = " << std::setw(1)
1074  << mess.getGdpbSysErrUnused() << ", Data = " << std::hex
1075  << std::setw(2) << uErrorType << std::dec
1076  << " -- GET4 V1 Error Event ";
1077  break;
1078  } // Input channel related errors (TOT, shaky signals, etc...)
1079  case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF: break;
1080  case gdpbv100::GET4_V2X_ERR_UNKNOWN:
1082  break;
1083  default:
1085  break;
1086  } // switch( uErrorType )
1087 
1088  return;
1089 }
1090 // -------------------------------------------------------------------------
1091 void CbmMcbm2018MonitorAlgoTof::ProcessPattern(gdpbv100::Message mess) {
1092  uint16_t usType = mess.getGdpbSysPattType();
1093  uint16_t usIndex = mess.getGdpbSysPattIndex();
1094  uint32_t uPattern = mess.getGdpbSysPattPattern();
1095  UInt_t uNbBits = (7 == usIndex ? 16 : 32);
1096  fhGdpbSysMessPattType->Fill(usType, fuCurrDpbIdx);
1097 
1098 
1099  switch (usType) {
1100  case gdpbv100::PATT_MISSMATCH: {
1101 
1102  if (kTRUE == fbDebugMonitorMode && 0 == usIndex) {
1103  fuNbMissmatchPattern[fuCurrDpbIdx]++;
1104 
1105  LOG(debug) << Form("Missmatch pattern message => Type %d, Index %2d, "
1106  "Pattern 0x%08X TS %12llu MS %3u Epoch %12llu",
1107  usType,
1108  usIndex,
1109  uPattern,
1110  fulCurrentTsIdx,
1111  fuMsIndex,
1112  fvulCurrentEpoch[fuCurrDpbIdx]);
1113  } // if( 0 == usIndex )
1114 
1115  LOG(debug) << Form(
1116  "Missmatch pattern message => Type %d, Index %2d, Pattern 0x%08X",
1117  usType,
1118  usIndex,
1119  uPattern);
1120  if (kTRUE == fbDebugMonitorMode)
1121  for (UInt_t uBit = 0; uBit < uNbBits; ++uBit) {
1122  UInt_t uBadAsic = fUnpackPar->ElinkIdxToGet4Idx(32 * usIndex + uBit);
1123 
1124  if ((uPattern >> uBit) & 0x1) {
1125  fhPatternMissmatch->Fill(uBadAsic, fuCurrDpbIdx);
1126  fvhGdpbPatternMissmatchEvo[fuCurrDpbIdx]->Fill(fulCurrentTsIdx,
1127  uBadAsic);
1128  fvvbGdpbLastMissmatchPattern[fuCurrDpbIdx][uBadAsic] = kTRUE;
1129  } // if( ( uPattern >> uBit ) & 0x1 )
1130  else
1131  fvvbGdpbLastMissmatchPattern[fuCurrDpbIdx][uBadAsic] = kFALSE;
1132 
1133  } // for( UInt_t uBit = 0; uBit < uNbBits; ++uBit )
1134  break;
1135  } // case gdpbv100::PATT_MISSMATCH:
1136  case gdpbv100::PATT_ENABLE: {
1137  LOG(debug) << Form(
1138  "ENABLE pattern message => Type %d, Index %2d, Pattern 0x%08X",
1139  usType,
1140  usIndex,
1141  uPattern);
1142 
1143  if (kTRUE == fbDebugMonitorMode)
1144  for (UInt_t uBit = 0; uBit < uNbBits; ++uBit) {
1145  UInt_t uAsic = fUnpackPar->ElinkIdxToGet4Idx(32 * usIndex + uBit);
1146 
1147  if ((uPattern >> uBit) & 0x1) {
1148  fhPatternEnable->Fill(uAsic, fuCurrDpbIdx);
1149  fvhGdpbPatternEnableEvo[fuCurrDpbIdx]->Fill(fulCurrentTsIdx, uAsic);
1150  fvvbGdpbLastEnablePattern[fuCurrDpbIdx][uAsic] = kFALSE;
1151  } // if( ( uPattern >> uBit ) & 0x1 )
1152  else
1153  fvvbGdpbLastEnablePattern[fuCurrDpbIdx][uAsic] = kTRUE;
1154 
1155  } // for( UInt_t uBit = 0; uBit < uNbBits; ++uBit )
1156  break;
1157  } // case gdpbv100::PATT_ENABLE:
1158  case gdpbv100::PATT_RESYNC: {
1159  LOG(debug) << Form(
1160  "RESYNC pattern message => Type %d, Index %2d, Pattern 0x%08X",
1161  usType,
1162  usIndex,
1163  uPattern);
1164 
1165  if (kTRUE == fbDebugMonitorMode)
1166  for (UInt_t uBit = 0; uBit < uNbBits; ++uBit) {
1167  UInt_t uBadAsic = fUnpackPar->ElinkIdxToGet4Idx(32 * usIndex + uBit);
1168 
1169  if ((uPattern >> uBit) & 0x1) {
1170  fhPatternResync->Fill(uBadAsic, fuCurrDpbIdx);
1171  fvhGdpbPatternResyncEvo[fuCurrDpbIdx]->Fill(fulCurrentTsIdx,
1172  uBadAsic);
1173  fvvbGdpbLastResyncPattern[fuCurrDpbIdx][uBadAsic] = kTRUE;
1174  } // if( ( uPattern >> uBit ) & 0x1 )
1175  else
1176  fvvbGdpbLastResyncPattern[fuCurrDpbIdx][uBadAsic] = kFALSE;
1177 
1178  } // for( UInt_t uBit = 0; uBit < uNbBits; ++uBit )
1179  break;
1180  } // case gdpbv100::PATT_RESYNC:
1181  default: {
1182  LOG(debug) << "Crazy pattern message, subtype " << usType;
1183  break;
1184  } // default
1185  } // switch( usType )
1186 
1187  return;
1188 }
1189 // -------------------------------------------------------------------------
1190 void CbmMcbm2018MonitorAlgoTof::ProcessSlowCtrl(gdpbv100::Message mess) {
1191  UInt_t uChan = mess.getGdpbSlcChan();
1192  UInt_t uEdge = mess.getGdpbSlcEdge();
1193  UInt_t uData = mess.getGdpbSlcData();
1194  UInt_t uType = mess.getGdpbSlcType();
1195 
1196  Double_t dGdpbChId = fuGet4Id * fuNrOfChannelsPerGet4 + mess.getGdpbSlcChan()
1197  + 0.5 * mess.getGdpbSlcEdge();
1198  Double_t dFullChId = fuGet4Nr * fuNrOfChannelsPerGet4 + mess.getGdpbSlcChan()
1199  + 0.5 * mess.getGdpbSlcEdge();
1200  Double_t dMessTime = fulCurrentMsIdx * 1e-9;
1201 
1202 
1203  switch (uType) {
1204  case gdpbv100::GET4_32B_SLC_SCALER: {
1205  fhGet4ChanScm->Fill(dFullChId, uType);
1206  fvhGdpbGet4ChanScm[fuCurrDpbIdx]->Fill(dGdpbChId, uType);
1207  break;
1208  } // case gdpbv100::GET4_32B_SLC_SCALER:
1209  case gdpbv100::GET4_32B_SLC_DEADT: {
1210  fhGet4ChanScm->Fill(dFullChId, uType);
1211  fvhGdpbGet4ChanScm[fuCurrDpbIdx]->Fill(dGdpbChId, uType);
1212  break;
1213  } // case gdpbv100::GET4_32B_SLC_DEADT:
1214  case gdpbv100::GET4_32B_SLC_SPIREAD: {
1215  fhGet4ChanScm->Fill(dFullChId, uType);
1216  fvhGdpbGet4ChanScm[fuCurrDpbIdx]->Fill(dGdpbChId, uType);
1217 
1219  fhGdpbAsicSpiCounts->Fill(fuGet4Id, fuCurrDpbIdx);
1220  LOG(info) << "GET4 Slow Control SPI message, time "
1221  << Form("%3.3f", dMessTime) << " s "
1222  << " for board ID " << std::hex << std::setw(4) << fuCurrDpbIdx
1223  << std::dec << "\n"
1224  << " +++++++ > Chip = " << std::setw(3) << fuGet4Id
1225  << ", Chan = " << std::setw(1) << uChan
1226  << ", Edge = " << std::setw(1) << uEdge
1227  << ", Type = " << std::setw(1) << mess.getGdpbSlcType() << ", "
1228  << Form("channel %1u,", (uData >> 10) & 0xF)
1229  << Form("value 0x%03x ", uData & 0x3FF)
1230  << Form("level %4.1f ",
1231  fUnpackPar->GetPadiThresholdVal(uData & 0x3FF))
1232  << Form("(Data = 0x%06x) ", uData);
1233  break;
1234  } // if( gdpbv100::GET4_32B_SLC_SPIREAD == uType )
1235  case gdpbv100::GET4_32B_SLC_START_SEU: {
1236  if (0 == mess.getGdpbSlcChan()
1237  && 0 == mess.getGdpbSlcEdge()) // START message
1238  {
1239  fhGet4ChanScm->Fill(dFullChId, uType + 1);
1240  fvhGdpbGet4ChanScm[fuCurrDpbIdx]->Fill(dGdpbChId, uType + 1);
1241  } // if( 0 == mess.getGdpbSlcChan() && 0 == mess.getGdpbSlcEdge() )
1242  else if (0 == mess.getGdpbSlcChan()
1243  && 1 == mess.getGdpbSlcEdge()) // SEU counter message
1244  {
1245  fhGet4ChanScm->Fill(dFullChId, uType);
1246  fvhGdpbGet4ChanScm[fuCurrDpbIdx]->Fill(dGdpbChId, uType);
1247  } // else if( 0 == mess.getGdpbSlcChan() && 1 == mess.getGdpbSlcEdge() )
1248  break;
1249  } // case gdpbv100::GET4_32B_SLC_START_SEU:
1250  default: break;
1251  } // switch( uType )
1252 
1254  fhGet4MessType->Fill(fuGet4Nr, 2);
1255  fvhGdpbGet4MessType[fuCurrDpbIdx]->Fill(fuGet4Id, 2);
1256 }
1257 // -------------------------------------------------------------------------
1258 void CbmMcbm2018MonitorAlgoTof::ProcessStarTrig(gdpbv100::Message mess) {
1259  Int_t iMsgIndex = mess.getStarTrigMsgIndex();
1260 
1261  switch (iMsgIndex) {
1262  case 0:
1263  fvhTokenMsgType[fuCurrDpbIdx]->Fill(0);
1264  fvulGdpbTsMsb[fuCurrDpbIdx] = mess.getGdpbTsMsbStarA();
1265  break;
1266  case 1:
1267  fvhTokenMsgType[fuCurrDpbIdx]->Fill(1);
1268  fvulGdpbTsLsb[fuCurrDpbIdx] = mess.getGdpbTsLsbStarB();
1269  fvulStarTsMsb[fuCurrDpbIdx] = mess.getStarTsMsbStarB();
1270  break;
1271  case 2:
1272  fvhTokenMsgType[fuCurrDpbIdx]->Fill(2);
1273  fvulStarTsMid[fuCurrDpbIdx] = mess.getStarTsMidStarC();
1274  break;
1275  case 3: {
1276  fvhTokenMsgType[fuCurrDpbIdx]->Fill(3);
1277 
1278  ULong64_t ulNewGdpbTsFull =
1279  (fvulGdpbTsMsb[fuCurrDpbIdx] << 24) + (fvulGdpbTsLsb[fuCurrDpbIdx]);
1280  ULong64_t ulNewStarTsFull = (fvulStarTsMsb[fuCurrDpbIdx] << 48)
1281  + (fvulStarTsMid[fuCurrDpbIdx] << 8)
1282  + mess.getStarTsLsbStarD();
1283  UInt_t uNewToken = mess.getStarTokenStarD();
1284  UInt_t uNewDaqCmd = mess.getStarDaqCmdStarD();
1285  UInt_t uNewTrigCmd = mess.getStarTrigCmdStarD();
1286 
1287  if ((uNewToken == fvuStarTokenLast[fuCurrDpbIdx])
1288  && (ulNewGdpbTsFull == fvulGdpbTsFullLast[fuCurrDpbIdx])
1289  && (ulNewStarTsFull == fvulStarTsFullLast[fuCurrDpbIdx])
1290  && (uNewDaqCmd == fvuStarDaqCmdLast[fuCurrDpbIdx])
1291  && (uNewTrigCmd == fvuStarTrigCmdLast[fuCurrDpbIdx])) {
1292  UInt_t uTrigWord = ((fvuStarTrigCmdLast[fuCurrDpbIdx] & 0x00F) << 16)
1293  + ((fvuStarDaqCmdLast[fuCurrDpbIdx] & 0x00F) << 12)
1294  + ((fvuStarTokenLast[fuCurrDpbIdx] & 0xFFF));
1295  LOG(warning) << "Possible error: identical STAR tokens found twice in "
1296  "a row => ignore 2nd! "
1297  << " TS " << fulCurrentTsIdx << " gDBB #" << fuCurrDpbIdx
1298  << " "
1299  << Form("token = %5u ", fvuStarTokenLast[fuCurrDpbIdx])
1300  << Form("gDPB ts = %12llu ",
1301  fvulGdpbTsFullLast[fuCurrDpbIdx])
1302  << Form("STAR ts = %12llu ",
1303  fvulStarTsFullLast[fuCurrDpbIdx])
1304  << Form("DAQ cmd = %2u ", fvuStarDaqCmdLast[fuCurrDpbIdx])
1305  << Form("TRG cmd = %2u ", fvuStarTrigCmdLast[fuCurrDpbIdx])
1306  << Form("TRG Wrd = %5x ", uTrigWord);
1307  return;
1308  } // if exactly same message repeated
1309 
1310  // STAR TS counter reset detection
1311  if (ulNewStarTsFull < fvulStarTsFullLast[fuCurrDpbIdx])
1312  LOG(info) << "Probable reset of the STAR TS: old = "
1313  << Form("%16llu", fvulStarTsFullLast[fuCurrDpbIdx])
1314  << " new = " << Form("%16llu", ulNewStarTsFull) << " Diff = -"
1315  << Form("%8llu",
1316  fvulStarTsFullLast[fuCurrDpbIdx] - ulNewStarTsFull);
1317 
1318  // ULong64_t ulGdpbTsDiff = ulNewGdpbTsFull - fvulGdpbTsFullLast[ fuCurrDpbIdx ];
1319  fvulGdpbTsFullLast[fuCurrDpbIdx] = ulNewGdpbTsFull;
1320  fvulStarTsFullLast[fuCurrDpbIdx] = ulNewStarTsFull;
1321  fvuStarTokenLast[fuCurrDpbIdx] = uNewToken;
1322  fvuStarDaqCmdLast[fuCurrDpbIdx] = uNewDaqCmd;
1323  fvuStarTrigCmdLast[fuCurrDpbIdx] = uNewTrigCmd;
1324 
1326  if (fuMsIndex < fuNbCoreMsPerTs) {
1328  if (0 <= fdStartTime) {
1329  fvhTriggerRate[fuCurrDpbIdx]->Fill(fdMsTime - fdStartTime);
1330  fvhStarTokenEvo[fuCurrDpbIdx]->Fill(fdMsTime - fdStartTime,
1331  fvuStarTokenLast[fuCurrDpbIdx]);
1332  fvhStarTrigGdpbTsEvo[fuCurrDpbIdx]->Fill(
1333  fdMsTime - fdStartTime, fvulGdpbTsFullLast[fuCurrDpbIdx]);
1334  fvhStarTrigStarTsEvo[fuCurrDpbIdx]->Fill(
1335  fdMsTime - fdStartTime, fvulStarTsFullLast[fuCurrDpbIdx]);
1336  } // if( 0 < fdStartTime )
1337  fvhCmdDaqVsTrig[fuCurrDpbIdx]->Fill(fvuStarDaqCmdLast[fuCurrDpbIdx],
1338  fvuStarTrigCmdLast[fuCurrDpbIdx]);
1339  } // if( fuMsIndex < fuNbCoreMsPerTs )
1340 
1341  break;
1342  } // case 3
1343  default: LOG(error) << "Unknown Star Trigger messageindex: " << iMsgIndex;
1344  } // switch( iMsgIndex )
1345 }
1346 // -------------------------------------------------------------------------
1347 
1348 Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms() {
1349  std::string sFolder = "eTofMoni";
1350 
1351  LOG(info) << "create Histos for eTOF monitoring ";
1352 
1354  uint32_t iNbBinsLog = 0;
1356  std::vector<double> dBinsLogVector = GenerateLogBinArray(4, 9, 1, iNbBinsLog);
1357  double* dBinsLog = dBinsLogVector.data();
1358  // double * dBinsLog = GenerateLogBinArray( 4, 9, 1, iNbBinsLog );
1359 
1360  /*******************************************************************/
1361  fhMessType = new TH1I("hMessageType",
1362  "Nb of message for each type; Type",
1363  1 + gdpbv100::MSG_STAR_TRI_D,
1364  0.,
1365  1 + gdpbv100::MSG_STAR_TRI_D);
1366  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_HIT, "HIT");
1367  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_EPOCH, "EPOCH");
1368  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SLOWC, "SLOWC");
1369  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SYST, "SYST");
1370  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_A, "TRI_A");
1371  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_B, "TRI_B");
1372  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_C, "TRI_C");
1373  fhMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_D, "TRI_D");
1374 
1375  fhSysMessType = new TH1I("hSysMessType",
1376  "Nb of system message for each type; System Type",
1377  1 + gdpbv100::SYS_PATTERN,
1378  0.,
1379  1 + gdpbv100::SYS_PATTERN);
1380  fhSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_GET4_ERROR,
1381  "GET4 ERROR");
1382  fhSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_GDPB_UNKWN,
1383  "UNKW GET4 MSG");
1384  fhSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_GET4_SYNC_MISS,
1385  "SYS_GET4_SYNC_MISS");
1386  fhSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_PATTERN,
1387  "SYS_PATTERN");
1388 
1389  fhGet4MessType =
1390  new TH2I("hGet4MessType",
1391  "Nb of message for each type per GET4; GET4 chip # ; Type",
1392  fuNrOfGet4,
1393  0.,
1394  fuNrOfGet4,
1395  4,
1396  0.,
1397  4.);
1398  fhGet4MessType->GetYaxis()->SetBinLabel(1, "DATA 32b");
1399  fhGet4MessType->GetYaxis()->SetBinLabel(2, "EPOCH");
1400  fhGet4MessType->GetYaxis()->SetBinLabel(3, "S.C. M");
1401  fhGet4MessType->GetYaxis()->SetBinLabel(4, "ERROR");
1402  // fhGet4MessType->GetYaxis()->SetBinLabel( 5, "DATA 24b");
1403  // fhGet4MessType->GetYaxis()->SetBinLabel( 6, "STAR Trigger");
1404 
1405  fhGet4ChanScm =
1406  new TH2I("hGet4ChanScm",
1407  "SC messages per GET4 channel; GET4 channel # ; SC type",
1408  2 * fuNrOfGet4 * fuNrOfChannelsPerGet4,
1409  0.,
1410  fuNrOfGet4 * fuNrOfChannelsPerGet4,
1411  5,
1412  0.,
1413  5.);
1414  fhGet4ChanScm->GetYaxis()->SetBinLabel(1, "Hit Scal");
1415  fhGet4ChanScm->GetYaxis()->SetBinLabel(2, "Deadtime");
1416  fhGet4ChanScm->GetYaxis()->SetBinLabel(3, "SPI");
1417  fhGet4ChanScm->GetYaxis()->SetBinLabel(4, "SEU Scal");
1418  fhGet4ChanScm->GetYaxis()->SetBinLabel(5, "START");
1419 
1420  fhGet4ChanErrors =
1421  new TH2I("hGet4ChanErrors",
1422  "Error messages per GET4 channel; GET4 channel # ; Error",
1423  fuNrOfGet4 * fuNrOfChannelsPerGet4,
1424  0.,
1425  fuNrOfGet4 * fuNrOfChannelsPerGet4,
1426  21,
1427  0.,
1428  21.);
1429  fhGet4ChanErrors->GetYaxis()->SetBinLabel(1, "0x00: Readout Init ");
1430  fhGet4ChanErrors->GetYaxis()->SetBinLabel(2, "0x01: Sync ");
1431  fhGet4ChanErrors->GetYaxis()->SetBinLabel(3, "0x02: Epoch count sync");
1432  fhGet4ChanErrors->GetYaxis()->SetBinLabel(4, "0x03: Epoch ");
1433  fhGet4ChanErrors->GetYaxis()->SetBinLabel(5, "0x04: FIFO Write ");
1434  fhGet4ChanErrors->GetYaxis()->SetBinLabel(6, "0x05: Lost event ");
1435  fhGet4ChanErrors->GetYaxis()->SetBinLabel(7, "0x06: Channel state ");
1436  fhGet4ChanErrors->GetYaxis()->SetBinLabel(8, "0x07: Token Ring state");
1437  fhGet4ChanErrors->GetYaxis()->SetBinLabel(9, "0x08: Token ");
1438  fhGet4ChanErrors->GetYaxis()->SetBinLabel(10, "0x09: Error Readout ");
1439  fhGet4ChanErrors->GetYaxis()->SetBinLabel(11, "0x0a: SPI ");
1440  fhGet4ChanErrors->GetYaxis()->SetBinLabel(
1441  12, "0x0b: DLL Lock error "); // <- From GET4 v1.2
1442  fhGet4ChanErrors->GetYaxis()->SetBinLabel(
1443  13, "0x0c: DLL Reset invoc."); // <- From GET4 v1.2
1444  fhGet4ChanErrors->GetYaxis()->SetBinLabel(14, "0x11: Overwrite ");
1445  fhGet4ChanErrors->GetYaxis()->SetBinLabel(15, "0x12: ToT out of range");
1446  fhGet4ChanErrors->GetYaxis()->SetBinLabel(16, "0x13: Event Discarded ");
1447  fhGet4ChanErrors->GetYaxis()->SetBinLabel(
1448  17, "0x14: Add. Rising edge"); // <- From GET4 v1.3
1449  fhGet4ChanErrors->GetYaxis()->SetBinLabel(
1450  18, "0x15: Unpaired Falling"); // <- From GET4 v1.3
1451  fhGet4ChanErrors->GetYaxis()->SetBinLabel(
1452  19, "0x16: Sequence error "); // <- From GET4 v1.3
1453  fhGet4ChanErrors->GetYaxis()->SetBinLabel(20, "0x7f: Unknown ");
1454  fhGet4ChanErrors->GetYaxis()->SetBinLabel(21, "Corrupt/unsuprtd error");
1455 
1456  fhGet4EpochFlags = new TH2I("hGet4EpochFlags",
1457  "Epoch flags per GET4; GET4 chip # ; Type",
1458  fuNrOfGet4,
1459  0.,
1460  fuNrOfGet4,
1461  4,
1462  0.,
1463  4.);
1464  fhGet4EpochFlags->GetYaxis()->SetBinLabel(1, "SYNC");
1465  fhGet4EpochFlags->GetYaxis()->SetBinLabel(2, "Ep LOSS");
1466  fhGet4EpochFlags->GetYaxis()->SetBinLabel(3, "Da LOSS");
1467  fhGet4EpochFlags->GetYaxis()->SetBinLabel(4, "MISSMAT");
1468 
1469  Double_t dGdpbMin = -0.5;
1470  Double_t dGdpbMax = fuNrOfGdpbs + dGdpbMin;
1471  fhGdpbAsicSpiCounts = new TH2I(
1472  "hGdpbAsicSpiCounts",
1473  "SPI messages count per gDPB and ASIC; ASIC Idx []; gDPB []; SPI msg[]",
1474  fuNrOfGet4PerGdpb,
1475  -0.5,
1476  fuNrOfGet4PerGdpb - 0.5,
1477  fuNrOfGdpbs,
1478  dGdpbMin,
1479  dGdpbMax);
1480 
1481  fhGdpbMessType =
1482  new TH2I("hGdpbMessageType",
1483  "Nb of message for each type per gDPB; Type; gDPB []",
1484  1 + gdpbv100::MSG_STAR_TRI_D,
1485  0.,
1486  1 + gdpbv100::MSG_STAR_TRI_D,
1487  fuNrOfGdpbs,
1488  dGdpbMin,
1489  dGdpbMax);
1490  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_HIT, "HIT");
1491  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_EPOCH, "EPOCH");
1492  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SLOWC, "SLOWC");
1493  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_SYST, "SYST");
1494  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_A,
1495  "TRI_A");
1496  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_B,
1497  "TRI_B");
1498  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_C,
1499  "TRI_C");
1500  fhGdpbMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::MSG_STAR_TRI_D,
1501  "TRI_D");
1502 
1503  fhGdpbSysMessType = new TH2I(
1504  "hGdpbSysMessType",
1505  "Nb of system message for each type per gDPB; System Type; gDPB []",
1506  1 + gdpbv100::SYS_PATTERN,
1507  0.,
1508  1 + gdpbv100::SYS_PATTERN,
1509  fuNrOfGdpbs,
1510  dGdpbMin,
1511  dGdpbMax);
1512  fhGdpbSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_GET4_ERROR,
1513  "GET4 ERROR");
1514  fhGdpbSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_GDPB_UNKWN,
1515  "UNKW GET4 MSG");
1516  fhGdpbSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_GET4_SYNC_MISS,
1517  "SYS_GET4_SYNC_MISS");
1518  fhGdpbSysMessType->GetXaxis()->SetBinLabel(1 + gdpbv100::SYS_PATTERN,
1519  "SYS_PATTERN");
1520 
1521  fhGdpbSysMessPattType = new TH2I(
1522  "hGdpbSysMessPattType",
1523  "Nb of pattern message for each type per gDPB; Pattern Type; gDPB []",
1524  1 + gdpbv100::PATT_RESYNC,
1525  0.,
1526  1 + gdpbv100::PATT_RESYNC,
1527  fuNrOfGdpbs,
1528  dGdpbMin,
1529  dGdpbMax);
1530  fhGdpbSysMessPattType->GetXaxis()->SetBinLabel(1 + gdpbv100::PATT_MISSMATCH,
1531  "PATT_MISSMATCH");
1532  fhGdpbSysMessPattType->GetXaxis()->SetBinLabel(1 + gdpbv100::PATT_ENABLE,
1533  "PATT_ENABLE");
1534  fhGdpbSysMessPattType->GetXaxis()->SetBinLabel(1 + gdpbv100::PATT_RESYNC,
1535  "PATT_RESYNC");
1536 
1537  fhGdpbEpochFlags = new TH2I("hGdpbEpochFlags",
1538  "Epoch flags per gDPB; gDPB # ; Type",
1539  fuNrOfGdpbs,
1540  dGdpbMin,
1541  dGdpbMax,
1542  4,
1543  0.,
1544  4.);
1545  fhGdpbEpochFlags->GetYaxis()->SetBinLabel(1, "SYNC");
1546  fhGdpbEpochFlags->GetYaxis()->SetBinLabel(2, "Ep LOSS");
1547  fhGdpbEpochFlags->GetYaxis()->SetBinLabel(3, "Da LOSS");
1548  fhGdpbEpochFlags->GetYaxis()->SetBinLabel(4, "MISSMAT");
1549 
1550  fhGdpbEpochSyncEvo =
1551  new TH2D("hGdpbEpochSyncEvo",
1552  "Epoch SYNC per second and gDPB; Time[s]; gDPB #; SYNC Nb",
1553  fuHistoryHistoSize,
1554  0,
1555  fuHistoryHistoSize,
1556  fuNrOfGdpbs,
1557  dGdpbMin,
1558  dGdpbMax);
1559 
1560  fhGdpbEpochMissEvo = new TH2D(
1561  "hGdpbEpochMissEvo",
1562  "Epoch Missmatch per second and gDPB; Time[s]; gDPB #; Missmatch Nb",
1563  fuHistoryHistoSize,
1564  0,
1565  fuHistoryHistoSize,
1566  fuNrOfGdpbs,
1567  dGdpbMin,
1568  dGdpbMax);
1569 
1570  fhGdpbEndMsBufferNotEmpty =
1571  new TH1D("hGdpbEndMsBufferNotEmpty",
1572  "MS where buffer is not empty at end, per gDPB; gDPB #; Bad MS",
1573  fuNrOfGdpbs,
1574  dGdpbMin,
1575  dGdpbMax);
1576 
1577  fhGdpbEndMsDataLost =
1578  new TH2D("hGdpbEndMsDataLost",
1579  "Amount of lost data when buffer not empty at end, per MS and "
1580  "gDPB; gDPB #; Lost Data per bad MS []; Bad MS",
1581  fuNrOfGdpbs,
1582  dGdpbMin,
1583  dGdpbMax,
1584  iNbBinsLog,
1585  dBinsLog);
1586 
1587  fhGdpbHitRate =
1588  new TH2D("fhGdpbHitRate",
1589  "Hit rate per second and gDPB; Time[s]; gDPB #; HITS Nb",
1590  fuHistoryHistoSize,
1591  0,
1592  fuHistoryHistoSize,
1593  fuNrOfGdpbs,
1594  dGdpbMin,
1595  dGdpbMax);
1596 
1597  if (kTRUE == fbDebugMonitorMode) {
1598  fhNbMissPatternPerMs =
1599  new TH2I("hNbMissPatternPerMs",
1600  "Nb of missmatch pattern per MS for each gDPB; Number of "
1601  "pattern messages []; gDPB []; MS",
1602  1000,
1603  -0.5,
1604  999.5,
1605  fuNrOfGdpbs,
1606  dGdpbMin,
1607  dGdpbMax);
1608 
1609  fhPatternMissmatch =
1610  new TH2I("hPatternMissmatch",
1611  "Missmatch pattern integral per gDPB; ASIC Pattern []; gDPB []",
1612  fuNrOfGet4PerGdpb,
1613  0.,
1614  fuNrOfGet4PerGdpb,
1615  fuNrOfGdpbs,
1616  dGdpbMin,
1617  dGdpbMax);
1618 
1619  fhPatternEnable =
1620  new TH2I("hPatternEnable",
1621  "Enable pattern integral per gDPB; ASIC Pattern []; gDPB []",
1622  fuNrOfGet4PerGdpb,
1623  0.,
1624  fuNrOfGet4PerGdpb,
1625  fuNrOfGdpbs,
1626  dGdpbMin,
1627  dGdpbMax);
1628 
1629  fhPatternResync =
1630  new TH2I("hPatternResync",
1631  "Resync pattern integral per gDPB; ASIC Pattern []; gDPB []",
1632  fuNrOfGet4PerGdpb,
1633  0.,
1634  fuNrOfGet4PerGdpb,
1635  fuNrOfGdpbs,
1636  dGdpbMin,
1637  dGdpbMax);
1638  } // if( kTRUE == fbDebugMonitorMode )
1639 
1641  AddHistoToVector(fhMessType, sFolder);
1642  AddHistoToVector(fhSysMessType, sFolder);
1644  AddHistoToVector(fhGet4MessType, sFolder);
1645  AddHistoToVector(fhGet4ChanScm, sFolder);
1646  AddHistoToVector(fhGet4ChanErrors, sFolder);
1647  AddHistoToVector(fhGet4EpochFlags, sFolder);
1648  AddHistoToVector(fhGdpbAsicSpiCounts, sFolder);
1650  AddHistoToVector(fhGdpbMessType, sFolder);
1651  AddHistoToVector(fhGdpbSysMessType, sFolder);
1652  AddHistoToVector(fhGdpbSysMessPattType, sFolder);
1653  AddHistoToVector(fhGdpbEpochFlags, sFolder);
1654  AddHistoToVector(fhGdpbEpochSyncEvo, sFolder);
1655  AddHistoToVector(fhGdpbEpochMissEvo, sFolder);
1656  AddHistoToVector(fhGdpbEndMsBufferNotEmpty, sFolder);
1657  AddHistoToVector(fhGdpbEndMsDataLost, sFolder);
1658  AddHistoToVector(fhGdpbHitRate, sFolder);
1661  if (kTRUE == fbDebugMonitorMode) {
1662  AddHistoToVector(fhNbMissPatternPerMs, sFolder);
1663  AddHistoToVector(fhPatternMissmatch, sFolder);
1664  AddHistoToVector(fhPatternEnable, sFolder);
1665  AddHistoToVector(fhPatternResync, sFolder);
1666  } // if( kTRUE == fbDebugMonitorMode )
1667 
1668  /*******************************************************************/
1669  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
1670  UInt_t uGdpbIndex = uGdpb;
1671  if (-1 < fiGdpbIndex) uGdpbIndex += fiGdpbIndex;
1672 
1673  std::string sFolderGdpb = Form("gdpb%02u", uGdpbIndex);
1674  std::string sFolderGdpbPatt = Form("gdpb%02u/Pattern", uGdpbIndex);
1675  std::string sFolderGdpbTrig = Form("gdpb%02u/Trigger", uGdpbIndex);
1676 
1677  fvhGdpbGet4MessType.push_back(new TH2I(
1678  Form("hGdpbGet4MessType_%02u", uGdpb),
1679  Form(
1680  "Nb of message for each type per GET4 in Gdpb %02u; GET4 chip # ; Type",
1681  uGdpbIndex),
1682  fuNrOfGet4PerGdpb,
1683  0.,
1684  fuNrOfGet4PerGdpb,
1685  4,
1686  0.,
1687  4.));
1688  fvhGdpbGet4MessType[uGdpb]->GetYaxis()->SetBinLabel(1, "DATA 32b");
1689  fvhGdpbGet4MessType[uGdpb]->GetYaxis()->SetBinLabel(2, "EPOCH");
1690  fvhGdpbGet4MessType[uGdpb]->GetYaxis()->SetBinLabel(3, "S.C. M");
1691  fvhGdpbGet4MessType[uGdpb]->GetYaxis()->SetBinLabel(4, "ERROR");
1692 
1693  fvhGdpbGet4ChanScm.push_back(new TH2I(
1694  Form("hGdpbGet4ChanScm_%02u", uGdpb),
1695  Form(
1696  "SC messages per GET4 channel in Gdpb %02u; GET4 channel # ; SC type",
1697  uGdpbIndex),
1698  2 * fuNrOfChannelsPerGdpb,
1699  0.,
1700  fuNrOfChannelsPerGdpb,
1701  5,
1702  0.,
1703  5.));
1704  fvhGdpbGet4ChanScm[uGdpb]->GetYaxis()->SetBinLabel(1, "Hit Scal");
1705  fvhGdpbGet4ChanScm[uGdpb]->GetYaxis()->SetBinLabel(2, "Deadtime");
1706  fvhGdpbGet4ChanScm[uGdpb]->GetYaxis()->SetBinLabel(3, "SPI");
1707  fvhGdpbGet4ChanScm[uGdpb]->GetYaxis()->SetBinLabel(4, "SEU Scal");
1708  fvhGdpbGet4ChanScm[uGdpb]->GetYaxis()->SetBinLabel(5, "START");
1709 
1710  fvhGdpbGet4ChanErrors.push_back(new TH2I(
1711  Form("hGdpbGet4ChanErrors_%02u", uGdpb),
1712  Form(
1713  "Error messages per GET4 channel in Gdpb %02u; GET4 channel # ; Error",
1714  uGdpbIndex),
1715  fuNrOfChannelsPerGdpb,
1716  0.,
1717  fuNrOfChannelsPerGdpb,
1718  22,
1719  0.,
1720  22.));
1721  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1722  1, "0x00: Readout Init ");
1723  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1724  2, "0x01: Sync ");
1725  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1726  3, "0x02: Epoch count sync");
1727  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1728  4, "0x03: Epoch ");
1729  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1730  5, "0x04: FIFO Write ");
1731  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1732  6, "0x05: Lost event ");
1733  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1734  7, "0x06: Channel state ");
1735  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1736  8, "0x07: Token Ring state");
1737  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1738  9, "0x08: Token ");
1739  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1740  10, "0x09: Error Readout ");
1741  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1742  11, "0x0a: SPI ");
1743  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1744  12, "0x0b: DLL Lock error "); // <- From GET4 v1.2
1745  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1746  13, "0x0c: DLL Reset invoc."); // <- From GET4 v1.2
1747  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1748  14, "0x11: Overwrite "); // <- From GET4 v1.0 to 1.3
1749  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1750  15, "0x12: ToT out of range");
1751  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1752  16, "0x13: Event Discarded ");
1753  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1754  17, "0x14: Add. Rising edge"); // <- From GET4 v1.3
1755  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1756  18, "0x15: Unpaired Falling"); // <- From GET4 v1.3
1757  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1758  19, "0x16: Sequence error "); // <- From GET4 v1.3
1759  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1760  20, "0x17: Epoch Overflow "); // <- From GET4 v2.0
1761  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1762  21, "0x7f: Unknown ");
1763  fvhGdpbGet4ChanErrors[uGdpb]->GetYaxis()->SetBinLabel(
1764  22, "Corrupt/unsuprtd error");
1765 
1767  if (kTRUE == fbDebugMonitorMode) {
1768  fvhRawFt_gDPB.push_back(
1769  new TH2I(Form("RawFt_gDPB_%02u", uGdpbIndex),
1770  Form("Raw FineTime gDPB %02u Plot 0; channel; FineTime [bin]",
1771  uGdpbIndex),
1772  fuNrOfChannelsPerGdpb,
1773  0,
1774  fuNrOfChannelsPerGdpb,
1775  128,
1776  0,
1777  128));
1778 
1779  fvhRawCt_gDPB.push_back(new TH2I(
1780  Form("RawCt_gDPB_%02u", uGdpbIndex),
1781  Form("Raw CoarseTime gDPB %02u Plot 0; channel; CoarseTime [bin]",
1782  uGdpbIndex),
1783  fuNrOfChannelsPerGdpb,
1784  0,
1785  fuNrOfChannelsPerGdpb,
1786  4096,
1787  0,
1788  4096));
1789  } // if( kTRUE == fbDebugMonitorMode )
1790 
1791  fvhRemapTot_gDPB.push_back(new TH2I(
1792  Form("RemapTot_gDPB_%02u", uGdpbIndex),
1793  Form("Raw TOT gDPB %02u remapped; PADI channel; TOT [bin]", uGdpbIndex),
1794  fuNrOfChannelsPerGdpb,
1795  0,
1796  fuNrOfChannelsPerGdpb,
1797  256,
1798  0,
1799  256));
1800 
1801  fvhRemapChCount_gDPB.push_back(new TH1I(
1802  Form("RemapChCount_gDPB_%02u", uGdpbIndex),
1803  Form("Channel counts gDPB %02u remapped; PADI channel; Hits", uGdpbIndex),
1804  fuNrOfFeePerGdpb * fuNrOfChannelsPerFee,
1805  0,
1806  fuNrOfFeePerGdpb * fuNrOfChannelsPerFee));
1807 
1808  fvhRemapChRate_gDPB.push_back(
1809  new TH2D(Form("RemapChRate_gDPB_%02u", uGdpbIndex),
1810  Form("PADI channel rate gDPB %02u; Time in run [s]; PADI "
1811  "channel; Rate [1/s]",
1812  uGdpbIndex),
1813  fuHistoryHistoSize,
1814  0,
1815  fuHistoryHistoSize,
1816  fuNrOfFeePerGdpb * fuNrOfChannelsPerFee,
1817  0,
1818  fuNrOfFeePerGdpb * fuNrOfChannelsPerFee));
1819 
1820  if (kTRUE == fbDebugMonitorMode)
1821  fvhRemapChErrFract_gDPB.push_back(
1822  new TProfile2D(Form("RemapChErrFract_gDPB_%02u", uGdpbIndex),
1823  Form("PADI channel error fraction gDPB %02u; Time in "
1824  "run [s]; PADI channel; Fraction []",
1825  uGdpbIndex),
1826  18000,
1827  0,
1828  180,
1829  fuNrOfFeePerGdpb * fuNrOfChannelsPerFee,
1830  0,
1831  fuNrOfFeePerGdpb * fuNrOfChannelsPerFee));
1832 
1834  if (kTRUE == fbDebugMonitorMode) {
1835  fvhGdpbPatternMissmatchEvo.push_back(new TH2I(
1836  Form("hGdpbPatternMissmatchEvo_%02u", uGdpbIndex),
1837  Form(
1838  "Missmatch pattern vs TS index in gDPB %02u; TS # ; ASIC Pattern []",
1839  uGdpbIndex),
1840  10000,
1841  0.,
1842  100000,
1843  fuNrOfGet4PerGdpb,
1844  0.,
1845  fuNrOfGet4PerGdpb));
1846 
1847  fvhGdpbPatternEnableEvo.push_back(new TH2I(
1848  Form("hGdpbPatternEnableEvo_%02u", uGdpbIndex),
1849  Form("Enable pattern vs TS index in gDPB %02u; TS # ; ASIC Pattern []",
1850  uGdpbIndex),
1851  10000,
1852  0.,
1853  100000,
1854  fuNrOfGet4PerGdpb,
1855  0.,
1856  fuNrOfGet4PerGdpb));
1857 
1858  fvhGdpbPatternResyncEvo.push_back(new TH2I(
1859  Form("hGdpbPatternResyncEvo%02u", uGdpbIndex),
1860  Form("Resync pattern vs TS index in gDPB %02u; TS # ; ASIC Pattern []",
1861  uGdpbIndex),
1862  10000,
1863  0.,
1864  100000,
1865  fuNrOfGet4PerGdpb,
1866  0.,
1867  fuNrOfGet4PerGdpb));
1868 
1869  fvhGdpbMissmatchEvoPerTs.push_back(new TH2I(
1870  Form("hGdpbMissmatchEvoPerTs%02u", uGdpbIndex),
1871  Form(
1872  "Missmatch vs TS index in gDPB %02u; TS # ; Asic []; Missmatch? []",
1873  uGdpbIndex),
1874  10000,
1875  0.,
1876  100000,
1877  fuNrOfGet4PerGdpb,
1878  0.,
1879  fuNrOfGet4PerGdpb));
1880 
1881  fvhGdpbMissmatchEnaEvoPerTs.push_back(
1882  new TH2I(Form("hGdpbMissmatchEnaEvoPerTs%02u", uGdpbIndex),
1883  Form("Enable+Missmatch vs TS index in gDPB %02u; TS # ; Asic "
1884  "[]; Enabled & Missmatch? []",
1885  uGdpbIndex),
1886  10000,
1887  0.,
1888  100000,
1889  fuNrOfGet4PerGdpb,
1890  0.,
1891  fuNrOfGet4PerGdpb));
1892 
1893  fvhGdpbEnableEvoPerTs.push_back(new TH2I(
1894  Form("hGdpbEnableEvoPerTs%02u", uGdpbIndex),
1895  Form("Enable vs TS index in gDPB %02u; TS # ; Asic []; Enabled? []",
1896  uGdpbIndex),
1897  100000,
1898  0.,
1899  100000,
1900  fuNrOfGet4PerGdpb,
1901  0.,
1902  fuNrOfGet4PerGdpb));
1903 
1904  fvhGdpbResyncEvoPerTs.push_back(new TH2I(
1905  Form("hGdpbResyncEvoPerTs%02u", uGdpbIndex),
1906  Form("Resync vs TS index in gDPB %02u; TS # ; Asic []; Resync? []",
1907  uGdpbIndex),
1908  10000,
1909  0.,
1910  100000,
1911  fuNrOfGet4PerGdpb,
1912  0.,
1913  fuNrOfGet4PerGdpb));
1914 
1915  fvhGdpbResyncEnaEvoPerTs.push_back(
1916  new TH2I(Form("hGdpbResyncEnaEvoPerTs%02u", uGdpbIndex),
1917  Form("Enable+Resync vs TS index in gDPB %02u; TS # ; Asic []; "
1918  "Enabled & Resync? []",
1919  uGdpbIndex),
1920  10000,
1921  0.,
1922  100000,
1923  fuNrOfGet4PerGdpb,
1924  0.,
1925  fuNrOfGet4PerGdpb));
1926 
1927  fvhGdpbStateEvoPerTs.push_back(new TH2I(
1928  Form("hGdpbStateEvoPerTs%02u", uGdpbIndex),
1929  Form("ASIC State vs TS index in gDPB %02u; TS # ; Asic []; 0 = Off, 1 "
1930  "= OK, 2 = Miss, 3 = Resync, 4 = Miss + Resync []",
1931  uGdpbIndex),
1932  100000,
1933  0.,
1934  100000,
1935  fuNrOfGet4PerGdpb,
1936  0.,
1937  fuNrOfGet4PerGdpb));
1938  } // if( kTRUE == fbDebugMonitorMode )
1939 
1942  fvhTokenMsgType.push_back(new TH1F(
1943  Form("hTokenMsgType_gDPB_%02u", uGdpbIndex),
1944  Form("STAR trigger Messages type gDPB %02u; Type ; Counts", uGdpbIndex),
1945  4,
1946  0,
1947  4));
1948  fvhTokenMsgType[uGdpb]->GetXaxis()->SetBinLabel(1, "A"); // gDPB TS high
1949  fvhTokenMsgType[uGdpb]->GetXaxis()->SetBinLabel(
1950  2, "B"); // gDPB TS low, STAR TS high
1951  fvhTokenMsgType[uGdpb]->GetXaxis()->SetBinLabel(3, "C"); // STAR TS mid
1952  fvhTokenMsgType[uGdpb]->GetXaxis()->SetBinLabel(
1953  4, "D"); // STAR TS low, token, CMDs
1954 
1955  fvhTriggerRate.push_back(new TH1F(
1956  Form("hTriggerRate_gDPB_%02u", uGdpbIndex),
1957  Form("STAR trigger signals per second gDPB %02u; Time[s] ; Counts",
1958  uGdpbIndex),
1959  fuHistoryHistoSize,
1960  0,
1961  fuHistoryHistoSize));
1962 
1963  fvhCmdDaqVsTrig.push_back(new TH2I(
1964  Form("hCmdDaqVsTrig_gDPB_%02u", uGdpbIndex),
1965  Form("STAR daq command VS STAR trigger command gDPB %02u; DAQ ; TRIGGER",
1966  uGdpbIndex),
1967  16,
1968  0,
1969  16,
1970  16,
1971  0,
1972  16));
1973  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(
1974  1, "0x0: no-trig "); // idle link
1975  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(
1976  2, "0x1: clear "); // clears redundancy counters on the readout boards
1977  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(
1978  3, "0x2: mast-rst"); // general reset of the whole front-end logic
1979  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(
1980  4, "0x3: spare "); // reserved
1981  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(
1982  5, "0x4: trigg. 0"); // Default physics readout, all det support required
1983  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(6, "0x5: trigg. 1"); //
1984  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(7, "0x6: trigg. 2"); //
1985  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(8, "0x7: trigg. 3"); //
1986  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(9, "0x8: puls. 0"); //
1987  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(10, "0x9: puls. 1"); //
1988  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(11, "0xA: puls. 2"); //
1989  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(12, "0xB: puls. 3"); //
1990  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(
1991  13,
1992  "0xC: config "); // housekeeping trigger: return geographic info of FE
1993  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(
1994  14, "0xD: abort "); // aborts and clears an active event
1995  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(15, "0xE: L1accept"); //
1996  fvhCmdDaqVsTrig[uGdpb]->GetXaxis()->SetBinLabel(16, "0xF: L2accept"); //
1997  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
1998  1, "0x0: 0"); // To be filled at STAR
1999  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2000  2, "0x1: 1"); // To be filled at STAR
2001  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2002  3, "0x2: 2"); // To be filled at STAR
2003  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2004  4, "0x3: 3"); // To be filled at STAR
2005  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2006  5, "0x4: 4"); // To be filled at STAR
2007  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2008  6, "0x5: 5"); // To be filled at STAR
2009  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2010  7, "0x6: 6"); // To be filled at STAR
2011  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2012  8, "0x7: 7"); // To be filled at STAR
2013  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2014  9, "0x8: 8"); // To be filled at STAR
2015  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2016  10, "0x9: 9"); // To be filled at STAR
2017  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2018  11, "0xA: 10"); // To be filled at STAR
2019  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2020  12, "0xB: 11"); // To be filled at STAR
2021  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2022  13, "0xC: 12"); // To be filled at STAR
2023  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2024  14, "0xD: 13"); // To be filled at STAR
2025  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2026  15, "0xE: 14"); // To be filled at STAR
2027  fvhCmdDaqVsTrig[uGdpb]->GetYaxis()->SetBinLabel(
2028  16, "0xF: 15"); // To be filled at STAR
2029 
2030  fvhStarTokenEvo.push_back(
2031  new TH2I(Form("hStarTokenEvo_gDPB_%02u", uGdpbIndex),
2032  Form("STAR token value VS time gDPB %02u; Time in Run [s] ; "
2033  "STAR Token; Counts",
2034  uGdpbIndex),
2035  fuHistoryHistoSize,
2036  0,
2037  fuHistoryHistoSize,
2038  410,
2039  0,
2040  4100));
2041 
2042  fvhStarTrigGdpbTsEvo.push_back(
2043  new TProfile(Form("hStarTrigGdpbTsEvo_gDPB_%02u", uGdpbIndex),
2044  Form("gDPB TS in STAR triger tokens for gDPB %02u; Time in "
2045  "Run [s] ; gDPB TS;",
2046  uGdpbIndex),
2047  fuHistoryHistoSize,
2048  0,
2049  fuHistoryHistoSize));
2050 
2051  fvhStarTrigStarTsEvo.push_back(
2052  new TProfile(Form("hStarTrigStarTsEvo_gDPB_%02u", uGdpbIndex),
2053  Form("STAR TS in STAR triger tokens for gDPB %02u; Time in "
2054  "Run [s] ; STAR TS;",
2055  uGdpbIndex),
2056  fuHistoryHistoSize,
2057  0,
2058  fuHistoryHistoSize));
2059 
2060 
2063  AddHistoToVector(fvhGdpbGet4MessType[uGdpb], sFolderGdpb);
2064  AddHistoToVector(fvhGdpbGet4ChanScm[uGdpb], sFolderGdpb);
2065  AddHistoToVector(fvhGdpbGet4ChanErrors[uGdpb], sFolderGdpb);
2067  if (kTRUE == fbDebugMonitorMode) {
2068  AddHistoToVector(fvhRawFt_gDPB[uGdpb], sFolderGdpb);
2069  AddHistoToVector(fvhRawCt_gDPB[uGdpb], sFolderGdpb);
2070  } // if( kTRUE == fbDebugMonitorMode )
2071  AddHistoToVector(fvhRemapTot_gDPB[uGdpb], sFolderGdpb);
2072  AddHistoToVector(fvhRemapChCount_gDPB[uGdpb], sFolderGdpb);
2073  AddHistoToVector(fvhRemapChRate_gDPB[uGdpb], sFolderGdpb);
2074  if (kTRUE == fbDebugMonitorMode) {
2075  AddHistoToVector(fvhRemapChErrFract_gDPB[uGdpb], sFolderGdpb);
2077  AddHistoToVector(fvhGdpbPatternMissmatchEvo[uGdpb], sFolderGdpbPatt);
2078  AddHistoToVector(fvhGdpbPatternEnableEvo[uGdpb], sFolderGdpbPatt);
2079  AddHistoToVector(fvhGdpbPatternResyncEvo[uGdpb], sFolderGdpbPatt);
2081  AddHistoToVector(fvhGdpbMissmatchEvoPerTs[uGdpb], sFolderGdpbPatt);
2082  AddHistoToVector(fvhGdpbMissmatchEnaEvoPerTs[uGdpb], sFolderGdpbPatt);
2083  AddHistoToVector(fvhGdpbEnableEvoPerTs[uGdpb], sFolderGdpbPatt);
2084  AddHistoToVector(fvhGdpbResyncEvoPerTs[uGdpb], sFolderGdpbPatt);
2085  AddHistoToVector(fvhGdpbResyncEnaEvoPerTs[uGdpb], sFolderGdpbPatt);
2086  AddHistoToVector(fvhGdpbStateEvoPerTs[uGdpb], sFolderGdpbPatt);
2087  } // if( kTRUE == fbDebugMonitorMode )
2089  AddHistoToVector(fvhTokenMsgType[uGdpb], sFolderGdpbTrig);
2090  AddHistoToVector(fvhTriggerRate[uGdpb], sFolderGdpbTrig);
2091  AddHistoToVector(fvhCmdDaqVsTrig[uGdpb], sFolderGdpbTrig);
2092  AddHistoToVector(fvhStarTokenEvo[uGdpb], sFolderGdpbTrig);
2093  AddHistoToVector(fvhStarTrigGdpbTsEvo[uGdpb], sFolderGdpbTrig);
2094  AddHistoToVector(fvhStarTrigStarTsEvo[uGdpb], sFolderGdpbTrig);
2095  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
2096 
2097  /*******************************************************************/
2098  fhMsgCntEvo = new TH1I("hMsgCntEvo",
2099  "Evolution of Hit & error msgs counts vs time in run; "
2100  "Time in run [s]; Msgs Count []",
2101  fuHistoryHistoSize,
2102  0,
2103  fuHistoryHistoSize);
2104  fhHitCntEvo = new TH1I(
2105  "hHitCntEvo",
2106  "Evolution of Hit counts vs time in run; Time in run [s]; Hits Count []",
2107  fuHistoryHistoSize,
2108  0,
2109  fuHistoryHistoSize);
2110  fhErrorCntEvo = new TH1I(
2111  "hErrorCntEvo",
2112  "Evolution of Error counts vs time in run; Time in run [s]; Error Count []",
2113  fuHistoryHistoSize,
2114  0,
2115  fuHistoryHistoSize);
2116  fhLostEvtCntEvo = new TH1I("hLostEvtCntEvo",
2117  "Evolution of LostEvent counts vs time in run; "
2118  "Time in run [s]; LostEvent Count []",
2119  fuHistoryHistoSize,
2120  0,
2121  fuHistoryHistoSize);
2122 
2123  fhErrorFractEvo = new TProfile("hErrorFractEvo",
2124  "Evolution of Error Fraction vs time in run; "
2125  "Time in run [s]; Error Fract []",
2126  fuHistoryHistoSize,
2127  0,
2128  fuHistoryHistoSize);
2129  fhLostEvtFractEvo = new TProfile("hLostEvtFractEvo",
2130  "Evolution of LostEvent Fraction vs time in "
2131  "run; Time in run [s]; LostEvent Fract []",
2132  fuHistoryHistoSize,
2133  0,
2134  fuHistoryHistoSize);
2135 
2136  fhMsgCntPerMsEvo =
2137  new TH2I("hMsgCntPerMsEvo",
2138  "Evolution of Hit & error msgs counts, per MS vs time in run; "
2139  "Time in run [s]; Hits Count/MS []; MS",
2140  fuHistoryHistoSize,
2141  0,
2142  fuHistoryHistoSize,
2143  iNbBinsLog,
2144  dBinsLog);
2145  fhHitCntPerMsEvo = new TH2I("hHitCntPerMsEvo",
2146  "Evolution of Hit counts, per MS vs time in run; "
2147  "Time in run [s]; Hits Count/MS []; MS",
2148  fuHistoryHistoSize,
2149  0,
2150  fuHistoryHistoSize,
2151  iNbBinsLog,
2152  dBinsLog);
2153  fhErrorCntPerMsEvo = new TH2I("hErrorCntPerMsEvo",
2154  "Evolution of Error counts, per MS vs time in "
2155  "run; Time in run [s]; Error Count/MS []; MS",
2156  fuHistoryHistoSize,
2157  0,
2158  fuHistoryHistoSize,
2159  iNbBinsLog,
2160  dBinsLog);
2161  fhLostEvtCntPerMsEvo =
2162  new TH2I("hLostEvtCntPerMsEvo",
2163  "Evolution of LostEvent, per MS counts vs time in run; Time in "
2164  "run [s]; LostEvent Count/MS []; MS",
2165  fuHistoryHistoSize,
2166  0,
2167  fuHistoryHistoSize,
2168  iNbBinsLog,
2169  dBinsLog);
2170 
2171  fhErrorFractPerMsEvo =
2172  new TH2I("hErrorFractPerMsEvo",
2173  "Evolution of Error Fraction, per MS vs time in run; Time in run "
2174  "[s]; Error Fract/MS []; MS",
2175  fuHistoryHistoSize,
2176  0,
2177  fuHistoryHistoSize,
2178  1000,
2179  0,
2180  1);
2181  fhLostEvtFractPerMsEvo =
2182  new TH2I("hLostEvtFractPerMsEvo",
2183  "Evolution of LostEvent Fraction, per MS vs time in run; Time in "
2184  "run [s]; LostEvent Fract/MS []; MS",
2185  fuHistoryHistoSize,
2186  0,
2187  fuHistoryHistoSize,
2188  1000,
2189  0,
2190  1);
2191 
2193  AddHistoToVector(fhMsgCntEvo, sFolder);
2194  AddHistoToVector(fhHitCntEvo, sFolder);
2195  AddHistoToVector(fhErrorCntEvo, sFolder);
2196  AddHistoToVector(fhLostEvtCntEvo, sFolder);
2197 
2198  AddHistoToVector(fhErrorFractEvo, sFolder);
2199  AddHistoToVector(fhLostEvtFractEvo, sFolder);
2200 
2201  AddHistoToVector(fhHitCntPerMsEvo, sFolder);
2202  AddHistoToVector(fhErrorCntPerMsEvo, sFolder);
2203  AddHistoToVector(fhLostEvtCntPerMsEvo, sFolder);
2204  AddHistoToVector(fhErrorFractPerMsEvo, sFolder);
2205  AddHistoToVector(fhLostEvtFractPerMsEvo, sFolder);
2206 
2208  // delete dBinsLog;
2209 
2210  /*******************************************************************/
2211 
2212  /*******************************************************************/
2215  fcSummary = new TCanvas("cSummary", "gDPB Monitoring Summary");
2216  fcSummary->Divide(2, 3);
2217 
2218  // 1st Column: Messages types
2219  fcSummary->cd(1);
2220  gPad->SetGridx();
2221  gPad->SetGridy();
2222  gPad->SetLogy();
2223  fhMessType->Draw();
2224 
2225  fcSummary->cd(2);
2226  gPad->SetGridx();
2227  gPad->SetGridy();
2228  gPad->SetLogy();
2229  fhSysMessType->Draw();
2230 
2231  fcSummary->cd(3);
2232  gPad->SetGridx();
2233  gPad->SetGridy();
2234  gPad->SetLogz();
2235  fhGet4MessType->Draw("colz");
2236 
2237  // 2nd Column: GET4 Errors + Epoch flags + SCm
2238  fcSummary->cd(4);
2239  gPad->SetGridx();
2240  gPad->SetGridy();
2241  gPad->SetLogz();
2242  fhGet4ChanErrors->Draw("colz");
2243 
2244  fcSummary->cd(5);
2245  gPad->SetGridx();
2246  gPad->SetGridy();
2247  gPad->SetLogz();
2248  fhGet4EpochFlags->Draw("colz");
2249 
2250  fcSummary->cd(6);
2251  gPad->SetGridx();
2252  gPad->SetGridy();
2253  fhGet4ChanScm->Draw("colz");
2254 
2255  AddCanvasToVector(fcSummary, "canvases");
2257 
2259  fcSummaryGdpb = new TCanvas("cSummaryGdpb", "gDPB Monitoring Summary");
2260  fcSummaryGdpb->Divide(2, 3);
2261 
2262  fcSummaryGdpb->cd(1);
2263  gPad->SetGridx();
2264  gPad->SetGridy();
2265  gPad->SetLogz();
2266  fhGdpbMessType->Draw("colz");
2267 
2268  fcSummaryGdpb->cd(2);
2269  gPad->SetGridx();
2270  gPad->SetGridy();
2271  gPad->SetLogz();
2272  fhGdpbSysMessPattType->Draw("text colz");
2273 
2274  fcSummaryGdpb->cd(3);
2275  gPad->SetGridx();
2276  gPad->SetGridy();
2277  gPad->SetLogz();
2278  fhGdpbSysMessType->Draw("colz");
2279 
2280  fcSummaryGdpb->cd(5);
2281  gPad->SetGridx();
2282  gPad->SetGridy();
2283  gPad->SetLogz();
2284  fhGdpbEpochFlags->Draw("text colz");
2285 
2286  fcSummaryGdpb->cd(4);
2287  gPad->SetGridx();
2288  gPad->SetGridy();
2289  fhGdpbEpochSyncEvo->Draw("colz");
2290 
2291  fcSummaryGdpb->cd(6);
2292  gPad->SetGridx();
2293  gPad->SetGridy();
2294  gPad->SetLogz();
2295  fhGdpbEpochMissEvo->Draw("colz");
2296 
2297  AddCanvasToVector(fcSummaryGdpb, "canvases");
2299  fcStarTrigTokenType = new TCanvas("cStarTrigTokenType",
2300  "STAR trigger token message type per gDPB");
2301  fcStarTriggerRate =
2302  new TCanvas("cStarTriggerRate", "STAR trigger rate per gDPB");
2303  fcStarTrigCmdDaqVsTrig =
2304  new TCanvas("cStarTrigCmdDaqVsTrig", "STAR trigger command types per gDPB");
2305  fcStarTrigStarTokenEvo = new TCanvas("cStarTrigStarTokenEvo",
2306  "STAR trigger token evolution per gDPB");
2307  fcStarTrigGdpbTsEvo =
2308  new TCanvas("cStarTrigGdpbTsEvo", "STAR trigger gDPB TS evo per gDPB");
2309  fcStarTrigStarTsEvo =
2310  new TCanvas("cStarTrigStarTsEvo", "STAR trigger STAR TS evo per gDPB");
2311 
2312  fcStarTrigTokenType->Divide(4, 3);
2313  fcStarTriggerRate->Divide(4, 3);
2314  fcStarTrigCmdDaqVsTrig->Divide(4, 3);
2315  fcStarTrigStarTokenEvo->Divide(4, 3);
2316  fcStarTrigGdpbTsEvo->Divide(4, 3);
2317  fcStarTrigStarTsEvo->Divide(4, 3);
2318 
2319  AddCanvasToVector(fcStarTrigTokenType, "canvases");
2320  AddCanvasToVector(fcStarTriggerRate, "canvases");
2321  AddCanvasToVector(fcStarTrigCmdDaqVsTrig, "canvases");
2322  AddCanvasToVector(fcStarTrigStarTokenEvo, "canvases");
2323  AddCanvasToVector(fcStarTrigGdpbTsEvo, "canvases");
2324  AddCanvasToVector(fcStarTrigStarTsEvo, "canvases");
2325 
2326  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
2327  UInt_t uGdpbIndex = uGdpb;
2328  if (-1 < fiGdpbIndex) uGdpbIndex += fiGdpbIndex;
2329 
2330  fvcSumGdpbGet4.push_back(new TCanvas(
2331  Form("cSumGdpb%02u", uGdpbIndex),
2332  Form("Summary per GET4 or channel for gDPB %02u", uGdpbIndex)));
2333  fvcSumGdpbGet4[uGdpb]->Divide(2, 2);
2334 
2335  fvcSumGdpbGet4[uGdpb]->cd(1);
2336  gPad->SetGridx();
2337  gPad->SetGridy();
2338  gPad->SetLogz();
2339  fvhGdpbGet4MessType[uGdpb]->Draw("colz");
2340 
2341  fvcSumGdpbGet4[uGdpb]->cd(2);
2342  gPad->SetGridx();
2343  gPad->SetGridy();
2344  gPad->SetLogz();
2345  fvhGdpbGet4ChanScm[uGdpb]->Draw("colz");
2346 
2347  fvcSumGdpbGet4[uGdpb]->cd(3);
2348  gPad->SetGridx();
2349  gPad->SetGridy();
2350  gPad->SetLogz();
2351  fvhGdpbGet4ChanErrors[uGdpb]->Draw("colz");
2352 
2353  fvcSumGdpbGet4[uGdpb]->cd(4);
2354  gPad->SetGridx();
2355  gPad->SetGridy();
2356  gPad->SetLogz();
2357  fvhRemapTot_gDPB[uGdpb]->Draw("colz");
2358 
2359 
2360  AddCanvasToVector(fvcSumGdpbGet4[uGdpb], "canvases");
2361 
2362  fcStarTrigTokenType->cd(1 + uGdpb);
2363  gPad->SetGridx();
2364  gPad->SetGridy();
2365  fvhTokenMsgType[uGdpb]->Draw("hist");
2366 
2367  fcStarTriggerRate->cd(1 + uGdpb);
2368  gPad->SetGridx();
2369  gPad->SetGridy();
2370  gPad->SetLogy();
2371  fvhTriggerRate[uGdpb]->Draw("hist");
2372 
2373  fcStarTrigCmdDaqVsTrig->cd(1 + uGdpb);
2374  gPad->SetGridx();
2375  gPad->SetGridy();
2376  gPad->SetLogz();
2377  fvhCmdDaqVsTrig[uGdpb]->Draw("colz");
2378 
2379  fcStarTrigStarTokenEvo->cd(1 + uGdpb);
2380  gPad->SetGridx();
2381  gPad->SetGridy();
2382  gPad->SetLogz();
2383  fvhStarTokenEvo[uGdpb]->Draw("colz");
2384 
2385  fcStarTrigGdpbTsEvo->cd(1 + uGdpb);
2386  gPad->SetGridx();
2387  gPad->SetGridy();
2388  fvhStarTrigGdpbTsEvo[uGdpb]->Draw("hist");
2389 
2390  fcStarTrigStarTsEvo->cd(1 + uGdpb);
2391  gPad->SetGridx();
2392  gPad->SetGridy();
2393  fvhStarTrigStarTsEvo[uGdpb]->Draw("hist");
2394  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
2395  /*******************************************************************/
2396 
2397  return kTRUE;
2398 }
2399 Bool_t CbmMcbm2018MonitorAlgoTof::FillHistograms() {
2400  if (kTRUE == fbDebugMonitorMode) {
2402  // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
2403  UInt_t uGdpb = fuCurrDpbIdx;
2404  for (UInt_t uAsic = 0; uAsic < fuNrOfGet4PerGdpb; ++uAsic) {
2405  if (fvvbGdpbLastMissmatchPattern[uGdpb][uAsic]) {
2406  fvhGdpbMissmatchEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic);
2407  } // if( fvvbGdpbLastMissmatchPattern[ uGdpb ][ uAsic ] )
2408 
2409  if (fvvbGdpbLastEnablePattern[uGdpb][uAsic]) {
2410  fvhGdpbEnableEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic);
2411 
2412  if (fvvbGdpbLastMissmatchPattern[uGdpb][uAsic]) {
2413  fvhGdpbMissmatchEnaEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic);
2414  } // if( fvvbGdpbLastMissmatchPattern[ uGdpb ][ uAsic ] )
2415 
2416  if (fvvbGdpbLastResyncPattern[uGdpb][uAsic]) {
2417  fvhGdpbResyncEnaEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic);
2418  } // if( fvvbGdpbLastResyncPattern[ uGdpb ][ uAsic ] )
2419 
2421  if (fvvbGdpbLastMissmatchPattern[uGdpb][uAsic]) {
2422  if (fvvbGdpbLastResyncPattern[uGdpb][uAsic]) {
2423  fvhGdpbStateEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic, 4);
2424  } // if( fvvbGdpbLastResyncPattern[ uGdpb ][ uAsic ] )
2425  else
2426  fvhGdpbStateEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic, 2);
2427  } // if( fvvbGdpbLastMissmatchPattern[ uGdpb ][ uAsic ] )
2428  else if (fvvbGdpbLastResyncPattern[uGdpb][uAsic]) {
2429  fvhGdpbStateEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic, 3);
2430  } // else if( fvvbGdpbLastResyncPattern[ uGdpb ][ uAsic ] )
2431  else
2432  fvhGdpbStateEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic, 1);
2433  } // if( fvvbGdpbLastEnablePattern[ uGdpb ][ uAsic ] )
2434  else
2435  fvhGdpbStateEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic, 0);
2436 
2437  if (fvvbGdpbLastResyncPattern[uGdpb][uAsic]) {
2438  fvhGdpbResyncEvoPerTs[uGdpb]->Fill(fulCurrentTsIdx, uAsic);
2439  } // if( fvvbGdpbLastResyncPattern[ uGdpb ][ uAsic ] )
2440  } // Loop on gDPB and ASICs
2441  } // if( kTRUE == fbDebugMonitorMode )
2442  /*
2443  UInt_t uCountHitsInMs = 0;
2444  UInt_t uCountErrorsInMs = 0;
2445  UInt_t uCountLostEvtInMs = 0;
2446 
2447  Double_t dFractErrorsInMs = uCountErrorsInMs;
2448  Double_t dFractLostEvtInMs = uCountLostEvtInMs;
2449  dFractErrorsInMs /= ( uCountHitsInMs + uCountErrorsInMs );
2450  dFractLostEvtInMs /= ( uCountHitsInMs + uCountErrorsInMs );
2451 
2452  fhMsgCntPerMsEvo->Fill( fdMsTime - fdStartTime, uCountHitsInMs + uCountErrorsInMs );
2453  fhHitCntPerMsEvo->Fill( fdMsTime - fdStartTime, uCountHitsInMs );
2454  fhErrorCntPerMsEvo->Fill( fdMsTime - fdStartTime, uCountErrorsInMs );
2455  fhLostEvtCntPerMsEvo->Fill( fdMsTime - fdStartTime, uCountLostEvtInMs );
2456  fhErrorFractPerMsEvo->Fill( fdMsTime - fdStartTime, dFractErrorsInMs );
2457  fhLostEvtFractPerMsEvo->Fill( fdMsTime - fdStartTime, dFractLostEvtInMs );
2458 */
2459  return kTRUE;
2460 }
2461 Bool_t CbmMcbm2018MonitorAlgoTof::ResetHistograms(Bool_t bResetTime) {
2462  fhMessType->Reset();
2463  fhSysMessType->Reset();
2464  fhGet4MessType->Reset();
2465  fhGet4ChanScm->Reset();
2466  fhGet4ChanErrors->Reset();
2467  fhGet4EpochFlags->Reset();
2468  fhGdpbAsicSpiCounts->Reset();
2469  fhGdpbMessType->Reset();
2470  fhGdpbSysMessType->Reset();
2471  fhGdpbSysMessPattType->Reset();
2472  fhGdpbEpochFlags->Reset();
2473  fhGdpbEpochSyncEvo->Reset();
2474  fhGdpbEpochMissEvo->Reset();
2475  fhGdpbEndMsBufferNotEmpty->Reset();
2476  fhGdpbEndMsDataLost->Reset();
2477  fhGdpbHitRate->Reset();
2478  if (kTRUE == fbDebugMonitorMode) {
2479  fhNbMissPatternPerMs->Reset();
2480  fhPatternMissmatch->Reset();
2481  fhPatternEnable->Reset();
2482  fhPatternResync->Reset();
2483  } // if( kTRUE == fbDebugMonitorMode )
2484 
2485  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
2486  fvhGdpbGet4MessType[uGdpb]->Reset();
2487  fvhGdpbGet4ChanScm[uGdpb]->Reset();
2488  fvhGdpbGet4ChanErrors[uGdpb]->Reset();
2489  if (kTRUE == fbDebugMonitorMode) {
2490  fvhRawFt_gDPB[uGdpb]->Reset();
2491  fvhRawCt_gDPB[uGdpb]->Reset();
2492  } // if( kTRUE == fbDebugMonitorMode )
2493  fvhRemapTot_gDPB[uGdpb]->Reset();
2494  fvhRemapChCount_gDPB[uGdpb]->Reset();
2495  fvhRemapChRate_gDPB[uGdpb]->Reset();
2496  if (kTRUE == fbDebugMonitorMode) {
2497  fvhRemapChErrFract_gDPB[uGdpb]->Reset();
2498  fvhGdpbPatternMissmatchEvo[uGdpb]->Reset();
2499  fvhGdpbPatternEnableEvo[uGdpb]->Reset();
2500  fvhGdpbPatternResyncEvo[uGdpb]->Reset();
2501  fvhGdpbMissmatchEvoPerTs[uGdpb]->Reset();
2502  fvhGdpbMissmatchEnaEvoPerTs[uGdpb]->Reset();
2503  fvhGdpbEnableEvoPerTs[uGdpb]->Reset();
2504  fvhGdpbResyncEvoPerTs[uGdpb]->Reset();
2505  fvhGdpbResyncEnaEvoPerTs[uGdpb]->Reset();
2506  fvhGdpbStateEvoPerTs[uGdpb]->Reset();
2507  } // if( kTRUE == fbDebugMonitorMode )
2508  fvhTokenMsgType[uGdpb]->Reset();
2509  fvhTriggerRate[uGdpb]->Reset();
2510  fvhCmdDaqVsTrig[uGdpb]->Reset();
2511  fvhStarTokenEvo[uGdpb]->Reset();
2512  fvhStarTrigGdpbTsEvo[uGdpb]->Reset();
2513  fvhStarTrigStarTsEvo[uGdpb]->Reset();
2514  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
2515 
2516  fhMsgCntEvo->Reset();
2517  fhHitCntEvo->Reset();
2518  fhErrorCntEvo->Reset();
2519  fhLostEvtCntEvo->Reset();
2520  fhErrorFractEvo->Reset();
2521  fhLostEvtFractEvo->Reset();
2522  fhHitCntPerMsEvo->Reset();
2523  fhErrorCntPerMsEvo->Reset();
2524  fhLostEvtCntPerMsEvo->Reset();
2525  fhErrorFractPerMsEvo->Reset();
2526  fhLostEvtFractPerMsEvo->Reset();
2527 
2528  if (kTRUE == bResetTime) {
2530  fdStartTime = -1.0;
2531  } // if( kTRUE == bResetTime )
2532 
2533  return kTRUE;
2534 }
2535 void CbmMcbm2018MonitorAlgoTof::ResetEvolutionHistograms() {
2536  fhGdpbEpochSyncEvo->Reset();
2537  fhGdpbEpochMissEvo->Reset();
2538 
2539  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
2540  fvhRemapChRate_gDPB[uGdpb]->Reset();
2541  if (kTRUE == fbDebugMonitorMode) {
2542  fvhRemapChErrFract_gDPB[uGdpb]->Reset();
2543  // fvhGdpbPatternMissmatchEvo[ uGdpb ] ->Reset();
2544  // fvhGdpbPatternEnableEvo[ uGdpb ] ->Reset();
2545  // fvhGdpbPatternResyncEvo[ uGdpb ] ->Reset();
2546  fvhGdpbMissmatchEvoPerTs[uGdpb]->Reset();
2547  fvhGdpbMissmatchEnaEvoPerTs[uGdpb]->Reset();
2548  fvhGdpbEnableEvoPerTs[uGdpb]->Reset();
2549  fvhGdpbResyncEvoPerTs[uGdpb]->Reset();
2550  fvhGdpbResyncEnaEvoPerTs[uGdpb]->Reset();
2551  fvhGdpbStateEvoPerTs[uGdpb]->Reset();
2552  } // if( kTRUE == fbDebugMonitorMode )
2553  fvhTriggerRate[uGdpb]->Reset();
2554  fvhStarTokenEvo[uGdpb]->Reset();
2555  fvhStarTrigGdpbTsEvo[uGdpb]->Reset();
2556  fvhStarTrigStarTsEvo[uGdpb]->Reset();
2557  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
2558 
2559  fhMsgCntEvo->Reset();
2560  fhHitCntEvo->Reset();
2561  fhErrorCntEvo->Reset();
2562  fhLostEvtCntEvo->Reset();
2563  fhErrorFractEvo->Reset();
2564  fhLostEvtFractEvo->Reset();
2565  fhHitCntPerMsEvo->Reset();
2566  fhErrorCntPerMsEvo->Reset();
2567  fhLostEvtCntPerMsEvo->Reset();
2568  fhErrorFractPerMsEvo->Reset();
2569  fhLostEvtFractPerMsEvo->Reset();
2570 
2571  fdStartTime = -1;
2572 }
2573 // -------------------------------------------------------------------------
gdpbv100::Message::getStarTrigCmdStarD
uint32_t getStarTrigCmdStarD() const
Definition: gDpbMessv100.h:278
CbmMcbm2018MonitorAlgoTof::fhGet4ChanErrors
TH2 * fhGet4ChanErrors
Definition: CbmMcbm2018MonitorAlgoTof.h:185
gdpbv100::MSG_STAR_TRI_A
@ MSG_STAR_TRI_A
Definition: gDpbMessv100.h:63
CbmMcbm2018MonitorAlgoTof::fhPatternResync
TH2 * fhPatternResync
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:228
gdpbv100::Message
Definition: gDpbMessv100.h:133
CbmMcbm2018MonitorAlgoTof::fhGdpbHitRate
TH2 * fhGdpbHitRate
Definition: CbmMcbm2018MonitorAlgoTof.h:197
CbmMcbm2018MonitorAlgoTof::fvhCmdDaqVsTrig
std::vector< TH2 * > fvhCmdDaqVsTrig
Definition: CbmMcbm2018MonitorAlgoTof.h:258
CbmMcbm2018MonitorAlgoTof::fuDuplicatesCount
UInt_t fuDuplicatesCount
Definition: CbmMcbm2018MonitorAlgoTof.h:171
CbmMcbm2018MonitorAlgoTof::fhMessType
TH1 * fhMessType
Size in seconds of the evolution histograms.
Definition: CbmMcbm2018MonitorAlgoTof.h:180
gdpbv100::Message::getGdpbSlcType
uint32_t getGdpbSlcType() const
Definition: gDpbMessv100.h:241
CbmMcbm2018MonitorAlgoTof::fvvbGdpbLastResyncPattern
std::vector< std::vector< bool > > fvvbGdpbLastResyncPattern
Exclude from dictionnary.
Definition: CbmMcbm2018MonitorAlgoTof.h:242
gdpbv100::Message::getGdpbSysErrChanId
uint16_t getGdpbSysErrChanId() const
Definition: gDpbMessv100.h:251
CbmMcbm2018MonitorAlgoTof::CreateHistograms
Bool_t CreateHistograms()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:1348
CbmMcbm2018MonitorAlgoTof::CbmMcbm2018MonitorAlgoTof
CbmMcbm2018MonitorAlgoTof()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:38
CbmMcbm2018MonitorAlgoTof::fhGdpbEndMsDataLost
TH2 * fhGdpbEndMsDataLost
Definition: CbmMcbm2018MonitorAlgoTof.h:196
CbmMcbm2018MonitorAlgoTof::ProcessStarTrig
void ProcessStarTrig(gdpbv100::Message mess)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:1258
gdpbv100::Message::getGdpbTsMsbStarA
uint64_t getGdpbTsMsbStarA() const
Definition: gDpbMessv100.h:266
CbmMcbm2018MonitorAlgoTof::fbUseAbsoluteTime
Bool_t fbUseAbsoluteTime
Definition: CbmMcbm2018MonitorAlgoTof.h:88
gdpbv100::Message::getGdpbEpEpochNb
uint32_t getGdpbEpEpochNb() const
Definition: gDpbMessv100.h:231
CbmStar2019Algo< CbmTofDigi >::fdMsSizeInNs
Double_t fdMsSizeInNs
/‍** Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice **‍/
Definition: CbmStar2019Algo.h:117
CbmMcbm2018MonitorAlgoTof::ProcessEpSupprBuffer
void ProcessEpSupprBuffer()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:655
gdpbv100::FullMessage::GetFullTimeNs
double GetFullTimeNs() const
Definition: gDpbMessv100.h:395
CbmMcbm2018MonitorAlgoTof::fuNrOfChannelsPerFee
UInt_t fuNrOfChannelsPerFee
Number of channels in each GET4.
Definition: CbmMcbm2018MonitorAlgoTof.h:99
CbmMcbm2018MonitorAlgoTof::fhPatternMissmatch
TH2 * fhPatternMissmatch
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:226
CbmMcbm2018TofPar::ElinkIdxToGet4Idx
Int_t ElinkIdxToGet4Idx(UInt_t uElink)
Definition: CbmMcbm2018TofPar.cxx:172
gdpbv100::GET4_V2X_ERR_TOT_OVERWRT
@ GET4_V2X_ERR_TOT_OVERWRT
Definition: gDpbMessv100.h:121
CbmStar2019Algo< CbmTofDigi >::fuNbMsLoop
size_t fuNbMsLoop
Definition: CbmStar2019Algo.h:114
CbmMcbm2018MonitorAlgoTof::fvhGdpbPatternMissmatchEvo
std::vector< TH2 * > fvhGdpbPatternMissmatchEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:231
CbmMcbm2018TofPar::GetGdpbId
Int_t GetGdpbId(Int_t i)
Definition: CbmMcbm2018TofPar.h:67
CbmMcbm2018MonitorAlgoTof::fuNrOfGet4
UInt_t fuNrOfGet4
Number of channels in each FEE.
Definition: CbmMcbm2018MonitorAlgoTof.h:100
gdpbv100::Message::getGdpbSlcChan
uint32_t getGdpbSlcChan() const
Definition: gDpbMessv100.h:239
gdpbv100::Message::getGdpbEpSync
bool getGdpbEpSync() const
Definition: gDpbMessv100.h:232
CbmMcbm2018MonitorAlgoTof::ProcessMs
Bool_t ProcessMs(const fles::Timeslice &ts, size_t uMsCompIdx, size_t uMsIdx)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:376
CbmMcbm2018MonitorAlgoTof::fvhRemapChCount_gDPB
std::vector< TH1 * > fvhRemapChCount_gDPB
Definition: CbmMcbm2018MonitorAlgoTof.h:219
CbmMcbm2018TofPar.h
CbmMcbm2018MonitorAlgoTof::Reset
virtual void Reset()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:171
gdpbv100::SYS_GET4_ERROR
@ SYS_GET4_ERROR
Definition: gDpbMessv100.h:70
CbmMcbm2018MonitorAlgoTof::fUnpackPar
CbmMcbm2018TofPar * fUnpackPar
Switch ON the usage of abolute time scale for the evo histo (no start time)
Definition: CbmMcbm2018MonitorAlgoTof.h:92
CbmMcbm2018MonitorAlgoTof::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Definition: CbmMcbm2018MonitorAlgoTof.h:129
CbmMcbm2018MonitorAlgoTof::fhHitCntEvo
TH1 * fhHitCntEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:204
CbmMcbm2018MonitorAlgoTof::fvhGdpbGet4ChanScm
std::vector< TH2 * > fvhGdpbGet4ChanScm
Definition: CbmMcbm2018MonitorAlgoTof.h:200
gdpbv100::MSG_HIT
@ MSG_HIT
Definition: gDpbMessv100.h:59
CbmMcbm2018MonitorAlgoTof::fvhStarTokenEvo
std::vector< TH2 * > fvhStarTokenEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:259
CbmMcbm2018MonitorAlgoTof::fuNrOfGdpbs
UInt_t fuNrOfGdpbs
Definition: CbmMcbm2018MonitorAlgoTof.h:94
CbmMcbm2018MonitorAlgoTof::fdTsStartTime
Double_t fdTsStartTime
SysId of the current MS in TS (0 to fuTotalMsNb)
Definition: CbmMcbm2018MonitorAlgoTof.h:120
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMcbm2018MonitorAlgoTof::fvhRemapTot_gDPB
std::vector< TH2 * > fvhRemapTot_gDPB
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:218
gdpbv100::Message::getGdpbSysPattType
uint16_t getGdpbSysPattType() const
Definition: gDpbMessv100.h:259
gdpbv100::MSG_SLOWC
@ MSG_SLOWC
Definition: gDpbMessv100.h:61
CbmMcbm2018MonitorAlgoTof::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Definition: CbmMcbm2018MonitorAlgoTof.h:116
CbmMcbm2018MonitorAlgoTof::fuGet4Id
UInt_t fuGet4Id
Bin size in s for the plots with date as X axis.
Definition: CbmMcbm2018MonitorAlgoTof.h:138
CbmMcbm2018MonitorAlgoTof::fhPatternEnable
TH2 * fhPatternEnable
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:227
CbmStar2019Algo< CbmTofDigi >::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmStar2019Algo.h:113
CbmMcbm2018MonitorAlgoTof::fvhGdpbMissmatchEnaEvoPerTs
std::vector< TH2 * > fvhGdpbMissmatchEnaEvoPerTs
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:246
gdpbv100::MSG_STAR_TRI_D
@ MSG_STAR_TRI_D
Definition: gDpbMessv100.h:66
gdpbv100::Message::getMessageType
uint8_t getMessageType() const
Returns the message type. Valid for all message types. 4 bit.
Definition: gDpbMessv100.h:206
CbmMcbm2018MonitorAlgoTof::fvulGdpbTsMsb
std::vector< ULong64_t > fvulGdpbTsMsb
STAR TRIGGER detection.
Definition: CbmMcbm2018MonitorAlgoTof.h:159
CbmStar2019Algo< CbmTofDigi >::AddHistoToVector
void AddHistoToVector(TNamed *pointer, std::string sFolder="")
For monitor algos.
Definition: CbmStar2019Algo.h:80
gdpbv100::GET4_32B_SLC_START_SEU
@ GET4_32B_SLC_START_SEU
Definition: gDpbMessv100.h:104
gdpbv100::Message::getGdpbSysSubType
uint16_t getGdpbSysSubType() const
Definition: gDpbMessv100.h:245
CbmMcbm2018MonitorAlgoTof::ProcessEpochCycle
void ProcessEpochCycle(uint64_t ulCycleData)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:578
CbmMcbm2018MonitorAlgoTof::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition: CbmMcbm2018MonitorAlgoTof.h:133
CbmStar2019Algo< CbmTofDigi >::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmStar2019Algo.h:112
gdpbv100::GET4_V2X_ERR_TOKEN
@ GET4_V2X_ERR_TOKEN
Definition: gDpbMessv100.h:116
CbmMcbm2018MonitorAlgoTof::fuMsIndex
UInt_t fuMsIndex
Start Time in ns of current MS from its index field in header.
Definition: CbmMcbm2018MonitorAlgoTof.h:125
CbmMcbm2018MonitorAlgoTof::fcStarTrigStarTsEvo
TCanvas * fcStarTrigStarTsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:273
CbmMcbm2018MonitorAlgoTof::fvulCurrentEpoch
std::vector< ULong64_t > fvulCurrentEpoch
Data format control: Current time references for each GDPB: merged epoch marker, epoch cycle,...
Definition: CbmMcbm2018MonitorAlgoTof.h:142
gdpbv100::GET4_V2X_ERR_CHAN_STATE
@ GET4_V2X_ERR_CHAN_STATE
Definition: gDpbMessv100.h:114
CbmMcbm2018MonitorAlgoTof::fvbMaskedComponents
std::vector< Bool_t > fvbMaskedComponents
If ON not printout at all for critical errors.
Definition: CbmMcbm2018MonitorAlgoTof.h:86
gdpbv100::kuEpochCounterSz
const uint32_t kuEpochCounterSz
Definition: gDpbMessv100.h:40
gdpbv100::Message::isStarTrigger
bool isStarTrigger() const
Returns true is message type is MSG_STAR_TRI_A, _B, _C, _D (STAR Trigger message)
Definition: gDpbMessv100.h:329
CbmMcbm2018MonitorAlgoTof::fvhTokenMsgType
std::vector< TH1 * > fvhTokenMsgType
Definition: CbmMcbm2018MonitorAlgoTof.h:256
CbmStar2019Algo< CbmTofDigi >::fdTsFullSizeInNs
Double_t fdTsFullSizeInNs
Total size of the core MS in a TS, [nanoseconds].
Definition: CbmStar2019Algo.h:121
gdpbv100::Message::getGdpbSysErrData
uint16_t getGdpbSysErrData() const
Definition: gDpbMessv100.h:253
CbmStar2019Algo< CbmTofDigi >::fParCList
TList * fParCList
Parameter management.
Definition: CbmStar2019Algo.h:108
CbmMcbm2018MonitorAlgoTof::ResetEvolutionHistograms
void ResetEvolutionHistograms()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:2535
CbmMcbm2018MonitorAlgoTof::fuGet4Nr
UInt_t fuGet4Nr
running number (0 to fuNrOfGet4PerGdpb) of the Get4 chip of a unique GDPB for current message
Definition: CbmMcbm2018MonitorAlgoTof.h:140
gdpbv100::Message::getGdpbSysPattIndex
uint16_t getGdpbSysPattIndex() const
Definition: gDpbMessv100.h:260
CbmMcbm2018MonitorAlgoTof::fuCurrentMsSysId
uint32_t fuCurrentMsSysId
Definition: CbmMcbm2018MonitorAlgoTof.h:118
CbmMcbm2018MonitorAlgoTof::fvulStarTsMsb
std::vector< ULong64_t > fvulStarTsMsb
Definition: CbmMcbm2018MonitorAlgoTof.h:161
CbmMcbm2018MonitorAlgoTof::fhGdpbAsicSpiCounts
TH2 * fhGdpbAsicSpiCounts
Definition: CbmMcbm2018MonitorAlgoTof.h:187
CbmMcbm2018MonitorAlgoTof::fvhRemapChRate_gDPB
std::vector< TH2 * > fvhRemapChRate_gDPB
Definition: CbmMcbm2018MonitorAlgoTof.h:220
CbmStar2019Algo< CbmTofDigi >::fvMsComponentsList
std::vector< size_t > fvMsComponentsList
Parameters related to FLES containers.
Definition: CbmStar2019Algo.h:111
CbmMcbm2018MonitorAlgoTof::fhGdpbSysMessPattType
TH2 * fhGdpbSysMessPattType
Definition: CbmMcbm2018MonitorAlgoTof.h:191
CbmMcbm2018MonitorAlgoTof::fvuStarDaqCmdLast
std::vector< UInt_t > fvuStarDaqCmdLast
Definition: CbmMcbm2018MonitorAlgoTof.h:166
CbmMcbm2018MonitorAlgoTof::fvhRawCt_gDPB
std::vector< TH2 * > fvhRawCt_gDPB
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:217
CbmMcbm2018MonitorAlgoTof::fvhGdpbPatternEnableEvo
std::vector< TH2 * > fvhGdpbPatternEnableEvo
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:233
CbmMcbm2018MonitorAlgoTof::ProcessTs
Bool_t ProcessTs(const fles::Timeslice &ts)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:317
gdpbv100::GET4_V2X_ERR_DLL_LOCK
@ GET4_V2X_ERR_DLL_LOCK
Definition: gDpbMessv100.h:119
gdpbv100::GET4_V2X_ERR_FIFO_WRITE
@ GET4_V2X_ERR_FIFO_WRITE
Definition: gDpbMessv100.h:112
CbmMcbm2018MonitorAlgoTof::fhLostEvtFractEvo
TProfile * fhLostEvtFractEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:208
CbmMcbm2018MonitorAlgoTof::fhLostEvtCntPerMsEvo
TH2 * fhLostEvtCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:212
CbmMcbm2018MonitorAlgoTof::fuNrOfChannelsPerGdpb
UInt_t fuNrOfChannelsPerGdpb
Number of GET4s per GDPB.
Definition: CbmMcbm2018MonitorAlgoTof.h:102
CbmMcbm2018MonitorAlgoTof::fhGdpbMessType
TH2 * fhGdpbMessType
Definition: CbmMcbm2018MonitorAlgoTof.h:189
CbmMcbm2018MonitorAlgoTof::fmLastHit
gdpbv100::Message fmLastHit
Definition: CbmMcbm2018MonitorAlgoTof.h:172
CbmTofDetectorId_v14a.h
CbmMcbm2018MonitorAlgoTof::fuNbMissmatchPattern
std::vector< UInt_t > fuNbMissmatchPattern
Pattern messages per gDPB.
Definition: CbmMcbm2018MonitorAlgoTof.h:224
gdpbv100::Message::getStarTsLsbStarD
uint64_t getStarTsLsbStarD() const
Definition: gDpbMessv100.h:273
CbmMcbm2018TofPar::GetNrOfGdpbs
Int_t GetNrOfGdpbs()
FIXME: replace with method returning the correspondign constants! see Star2019 parameter.
Definition: CbmMcbm2018TofPar.h:66
gdpbv100::PATT_MISSMATCH
@ PATT_MISSMATCH
Definition: gDpbMessv100.h:81
CbmMcbm2018MonitorAlgoTof::fvhTriggerRate
std::vector< TH1 * > fvhTriggerRate
Definition: CbmMcbm2018MonitorAlgoTof.h:257
CbmMcbm2018MonitorAlgoTof::fhErrorFractEvo
TProfile * fhErrorFractEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:207
gdpbv100::GET4_V2X_ERR_UNKNOWN
@ GET4_V2X_ERR_UNKNOWN
Definition: gDpbMessv100.h:130
gdpbv100::MSG_STAR_TRI_C
@ MSG_STAR_TRI_C
Definition: gDpbMessv100.h:65
gdpbv100::GET4_32B_SLC_SCALER
@ GET4_32B_SLC_SCALER
Definition: gDpbMessv100.h:101
gdpbv100::Message::getGdpbSysFwErrResync
uint32_t getGdpbSysFwErrResync() const
Definition: gDpbMessv100.h:257
gdpbv100::PATT_RESYNC
@ PATT_RESYNC
Definition: gDpbMessv100.h:83
gdpbv100::GET4_V2X_ERR_EP
@ GET4_V2X_ERR_EP
Definition: gDpbMessv100.h:111
gdpbv100::Message::getData
uint64_t getData() const
Definition: gDpbMessv100.h:156
CbmMcbm2018MonitorAlgoTof::fvuStarTokenLast
std::vector< UInt_t > fvuStarTokenLast
Definition: CbmMcbm2018MonitorAlgoTof.h:165
gdpbv100::GET4_V2X_ERR_SYNC
@ GET4_V2X_ERR_SYNC
Definition: gDpbMessv100.h:109
gdpbv100::GET4_V2X_ERR_EP_CNT_SYNC
@ GET4_V2X_ERR_EP_CNT_SYNC
Definition: gDpbMessv100.h:110
CbmMcbm2018MonitorAlgoTof::fhGdpbSysMessType
TH2 * fhGdpbSysMessType
Definition: CbmMcbm2018MonitorAlgoTof.h:190
CbmStar2019Algo
Definition: CbmStar2019Algo.h:43
CbmMcbm2018MonitorAlgoTof::fvhGdpbEnableEvoPerTs
std::vector< TH2 * > fvhGdpbEnableEvoPerTs
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:248
CbmMcbm2018MonitorAlgoTof::fbDebugMonitorMode
Bool_t fbDebugMonitorMode
Control flags.
Definition: CbmMcbm2018MonitorAlgoTof.h:83
gdpbv100::GET4_V2X_ERR_SEQUENCE_ER
@ GET4_V2X_ERR_SEQUENCE_ER
Definition: gDpbMessv100.h:127
CbmMcbm2018MonitorAlgoTof::fhGet4EpochFlags
TH2 * fhGet4EpochFlags
Definition: CbmMcbm2018MonitorAlgoTof.h:186
gdpbv100::Message::getGdpbTsLsbStarB
uint64_t getGdpbTsLsbStarB() const
Definition: gDpbMessv100.h:268
CbmMcbm2018MonitorAlgoTof::fcStarTrigCmdDaqVsTrig
TCanvas * fcStarTrigCmdDaqVsTrig
Definition: CbmMcbm2018MonitorAlgoTof.h:270
CbmMcbm2018MonitorAlgoTof::kuBytesPerMessage
static const UInt_t kuBytesPerMessage
Definition: CbmMcbm2018MonitorAlgoTof.h:110
CbmMcbm2018MonitorAlgoTof::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018MonitorAlgoTof.h:131
CbmMcbm2018MonitorAlgoTof::ResetHistograms
Bool_t ResetHistograms(Bool_t bResetTime=kTRUE)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:2461
gdpbv100::Message::getStarTrigMsgIndex
uint16_t getStarTrigMsgIndex() const
Definition: gDpbMessv100.h:264
CbmMcbm2018MonitorAlgoTof::fvhGdpbStateEvoPerTs
std::vector< TH2 * > fvhGdpbStateEvoPerTs
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:254
gdpbv100::Message::getGdpbSlcEdge
uint32_t getGdpbSlcEdge() const
Definition: gDpbMessv100.h:240
gdpbv100::GET4_32B_SLC_DEADT
@ GET4_32B_SLC_DEADT
Definition: gDpbMessv100.h:102
gdpbv100::GET4_V2X_ERR_TOK_RING_ST
@ GET4_V2X_ERR_TOK_RING_ST
Definition: gDpbMessv100.h:115
CbmMcbm2018MonitorAlgoTof::fvulStarTsMid
std::vector< ULong64_t > fvulStarTsMid
Definition: CbmMcbm2018MonitorAlgoTof.h:162
CbmMcbm2018MonitorAlgoTof::fdMsTime
Double_t fdMsTime
End Time in ns of current TS Core from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoTof.h:124
CbmStar2019Algo< CbmTofDigi >::fdTsCoreSizeInNs
Double_t fdTsCoreSizeInNs
Size of a single MS, [nanoseconds].
Definition: CbmStar2019Algo.h:119
CbmMcbm2018MonitorAlgoTof::fuHistoryHistoSize
UInt_t fuHistoryHistoSize
Histograms related variables.
Definition: CbmMcbm2018MonitorAlgoTof.h:175
CbmTofAddress.h
CbmMcbm2018MonitorAlgoTof::fvulGdpbTsFullLast
std::vector< ULong64_t > fvulGdpbTsFullLast
Definition: CbmMcbm2018MonitorAlgoTof.h:163
gdpbv100::kuChipIdMergedEpoch
const uint32_t kuChipIdMergedEpoch
Definition: gDpbMessv100.h:51
CbmMcbm2018MonitorAlgoTof::fvhRawFt_gDPB
std::vector< TH2 * > fvhRawFt_gDPB
Definition: CbmMcbm2018MonitorAlgoTof.h:216
CbmMcbm2018MonitorAlgoTof::fdStartTime
Double_t fdStartTime
Starting state book-keeping.
Definition: CbmMcbm2018MonitorAlgoTof.h:152
gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG
@ GET4_V2X_ERR_ADD_RIS_EDG
Definition: gDpbMessv100.h:125
CbmMcbm2018MonitorAlgoTof::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:185
CbmMcbm2018MonitorAlgoTof::Init
virtual Bool_t Init()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:166
CbmMcbm2018MonitorAlgoTof::fvulStarTsFullLast
std::vector< ULong64_t > fvulStarTsFullLast
Definition: CbmMcbm2018MonitorAlgoTof.h:164
CbmMcbm2018MonitorAlgoTof::ProcessSysMess
void ProcessSysMess(gdpbv100::FullMessage mess)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:803
CbmMcbm2018MonitorAlgoTof::fvhGdpbResyncEnaEvoPerTs
std::vector< TH2 * > fvhGdpbResyncEnaEvoPerTs
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:252
gdpbv100::MSG_SYST
@ MSG_SYST
Definition: gDpbMessv100.h:62
CbmMcbm2018MonitorAlgoTof::fhErrorCntEvo
TH1 * fhErrorCntEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:205
CbmMcbm2018MonitorAlgoTof::fcStarTrigTokenType
TCanvas * fcStarTrigTokenType
Definition: CbmMcbm2018MonitorAlgoTof.h:268
CbmMcbm2018MonitorAlgoTof::fhMsgCntPerMsEvo
TH2 * fhMsgCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:209
CbmMcbm2018MonitorAlgoTof::fhGdpbEpochFlags
TH2 * fhGdpbEpochFlags
Definition: CbmMcbm2018MonitorAlgoTof.h:192
CbmMcbm2018MonitorAlgoTof.h
CbmMcbm2018MonitorAlgoTof::fhHitCntPerMsEvo
TH2 * fhHitCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:210
CbmMcbm2018MonitorAlgoTof::FillHistograms
Bool_t FillHistograms()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:2399
gdpbv100::Message::getStarTsMidStarC
uint64_t getStarTsMidStarC() const
Definition: gDpbMessv100.h:271
CbmMcbm2018MonitorAlgoTof::fvuStarTrigCmdLast
std::vector< UInt_t > fvuStarTrigCmdLast
Definition: CbmMcbm2018MonitorAlgoTof.h:167
CbmMcbm2018MonitorAlgoTof::fuNrOfFeePerGdpb
UInt_t fuNrOfFeePerGdpb
gDPB ID to index map
Definition: CbmMcbm2018MonitorAlgoTof.h:96
gdpbv100::GET4_V2X_ERR_TOT_RANGE
@ GET4_V2X_ERR_TOT_RANGE
Definition: gDpbMessv100.h:123
FormatMsHeaderPrintout
std::string FormatMsHeaderPrintout(const fles::MicrosliceDescriptor &msDescriptor)
Definition: CbmFormatMsHeaderPrintout.cxx:5
gdpbv100::GET4_V2X_ERR_DLL_RESET
@ GET4_V2X_ERR_DLL_RESET
Definition: gDpbMessv100.h:120
gdpbv100::GET4_V2X_ERR_SPI
@ GET4_V2X_ERR_SPI
Definition: gDpbMessv100.h:118
CbmMcbm2018MonitorAlgoTof::fvulCurrentEpochCycle
std::vector< ULong64_t > fvulCurrentEpochCycle
Current epoch index, per DPB.
Definition: CbmMcbm2018MonitorAlgoTof.h:144
CbmMcbm2018MonitorAlgoTof::fuNrOfGet4PerGdpb
UInt_t fuNrOfGet4PerGdpb
Total number of Get4 chips in the system.
Definition: CbmMcbm2018MonitorAlgoTof.h:101
CbmMcbm2018MonitorAlgoTof::fiGdpbIndex
Int_t fiGdpbIndex
Definition: CbmMcbm2018MonitorAlgoTof.h:87
CbmMcbm2018MonitorAlgoTof::fvvbGdpbLastEnablePattern
std::vector< std::vector< bool > > fvvbGdpbLastEnablePattern
Exclude from dictionnary.
Definition: CbmMcbm2018MonitorAlgoTof.h:240
CbmMcbm2018MonitorAlgoTof::fcStarTrigStarTokenEvo
TCanvas * fcStarTrigStarTokenEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:271
gdpbv100::GET4_V2X_ERR_READ_INIT
@ GET4_V2X_ERR_READ_INIT
Definition: gDpbMessv100.h:108
CbmMcbm2018MonitorAlgoTof::fcStarTriggerRate
TCanvas * fcStarTriggerRate
Definition: CbmMcbm2018MonitorAlgoTof.h:269
gdpbv100::Message::getGdpbSysPattPattern
uint32_t getGdpbSysPattPattern() const
Definition: gDpbMessv100.h:261
CbmMcbm2018MonitorAlgoTof::fdTsStopTimeCore
Double_t fdTsStopTimeCore
Time in ns of current TS from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoTof.h:122
GenerateLogBinArray
std::vector< double > GenerateLogBinArray(uint32_t uNbDecadesLog, uint32_t uNbStepsDecade, uint32_t uNbSubStepsInStep, uint32_t &uNbBinsLog)
Definition: CbmFlesHistosTools.cxx:6
CbmMcbm2018TofPar
Definition: CbmMcbm2018TofPar.h:18
CbmMcbm2018MonitorAlgoTof::ProcessEpoch
void ProcessEpoch(gdpbv100::Message mess)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:603
CbmMcbm2018MonitorAlgoTof::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:302
CbmMcbm2018TofPar::GetNrOfChannelsPerGet4
Int_t GetNrOfChannelsPerGet4()
Definition: CbmMcbm2018TofPar.h:70
CbmMcbm2018TofPar::GetSizeMsInNs
Double_t GetSizeMsInNs()
Definition: CbmMcbm2018TofPar.h:81
gdpbv100::MSG_EPOCH
@ MSG_EPOCH
Definition: gDpbMessv100.h:60
gdpbv100::Message::getGdpbSysUnkwData
uint32_t getGdpbSysUnkwData() const
Definition: gDpbMessv100.h:255
CbmMcbm2018MonitorAlgoTof::~CbmMcbm2018MonitorAlgoTof
~CbmMcbm2018MonitorAlgoTof()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:160
CbmMcbm2018MonitorAlgoTof::fhLostEvtCntEvo
TH1 * fhLostEvtCntEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:206
gdpbv100::GET4_V2X_ERR_LOST_EVT
@ GET4_V2X_ERR_LOST_EVT
Definition: gDpbMessv100.h:113
CbmMcbm2018MonitorAlgoTof::fvvbGdpbLastMissmatchPattern
std::vector< std::vector< bool > > fvvbGdpbLastMissmatchPattern
Definition: CbmMcbm2018MonitorAlgoTof.h:238
CbmMcbm2018MonitorAlgoTof::fcSummaryGdpb
TCanvas * fcSummaryGdpb
Definition: CbmMcbm2018MonitorAlgoTof.h:266
CbmMcbm2018MonitorAlgoTof::fvhGdpbGet4MessType
std::vector< TH2 * > fvhGdpbGet4MessType
Definition: CbmMcbm2018MonitorAlgoTof.h:199
gdpbv100::kulEpochCycleFieldSz
const uint64_t kulEpochCycleFieldSz
Definition: gDpbMessv100.h:49
CbmMcbm2018MonitorAlgoTof::fhGdpbEndMsBufferNotEmpty
TH1 * fhGdpbEndMsBufferNotEmpty
Definition: CbmMcbm2018MonitorAlgoTof.h:195
gdpbv100::Message::getGdpbHitIs24b
uint16_t getGdpbHitIs24b() const
Definition: gDpbMessv100.h:218
CbmMcbm2018MonitorAlgoTof::fvulGdpbTsLsb
std::vector< ULong64_t > fvulGdpbTsLsb
Definition: CbmMcbm2018MonitorAlgoTof.h:160
CbmMcbm2018MonitorAlgoTof::InitParameters
Bool_t InitParameters()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:203
gdpbv100::Message::getGdpbEpEpochLoss
bool getGdpbEpEpochLoss() const
Definition: gDpbMessv100.h:234
gdpbv100::Message::getGdpbGenChipId
uint16_t getGdpbGenChipId() const
Definition: gDpbMessv100.h:214
CbmMcbm2018MonitorAlgoTof::fhErrorCntPerMsEvo
TH2 * fhErrorCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:211
gdpbv100::GET4_V2X_ERR_READOUT_ERR
@ GET4_V2X_ERR_READOUT_ERR
Definition: gDpbMessv100.h:117
CbmFlesHistosTools.h
CbmMcbm2018MonitorAlgoTof::fhGdpbEpochSyncEvo
TH2 * fhGdpbEpochSyncEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:193
CbmMcbm2018MonitorAlgoTof::fuNrOfChannelsPerGet4
UInt_t fuNrOfChannelsPerGet4
Number of GET4s per FEE.
Definition: CbmMcbm2018MonitorAlgoTof.h:98
gdpbv100::Message::getGdpbEpDataLoss
bool getGdpbEpDataLoss() const
Definition: gDpbMessv100.h:233
gdpbv100::MSG_STAR_TRI_B
@ MSG_STAR_TRI_B
Definition: gDpbMessv100.h:64
gdpbv100::Message::getGdpbSysErrEdge
bool getGdpbSysErrEdge() const
Definition: gDpbMessv100.h:252
gdpbv100::SYS_PATTERN
@ SYS_PATTERN
Definition: gDpbMessv100.h:76
CbmMcbm2018TofPar::GetNrOfFeePerGdpb
static constexpr UInt_t GetNrOfFeePerGdpb()
Definition: CbmMcbm2018TofPar.h:60
CbmMcbm2018MonitorAlgoTof::ProcessHit
void ProcessHit(gdpbv100::FullMessage mess)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:723
gdpbv100::Message::getGdpbSlcData
uint32_t getGdpbSlcData() const
Definition: gDpbMessv100.h:242
CbmMcbm2018MonitorAlgoTof::fhMsgCntEvo
TH1 * fhMsgCntEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:203
gdpbv100::Message::getGdpbHitFullTs
uint32_t getGdpbHitFullTs() const
Definition: gDpbMessv100.h:220
gdpbv100::GET4_32B_SLC_SPIREAD
@ GET4_32B_SLC_SPIREAD
Definition: gDpbMessv100.h:103
CbmStar2019Algo< CbmTofDigi >::AddCanvasToVector
void AddCanvasToVector(TCanvas *pointer, std::string sFolder="")
Definition: CbmStar2019Algo.h:87
gdpbv100::FullMessage
Definition: gDpbMessv100.h:362
CbmMcbm2018MonitorAlgoTof::ProcessPattern
void ProcessPattern(gdpbv100::Message mess)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:1091
CbmMcbm2018MonitorAlgoTof::fbEpochSinceLastHit
Bool_t fbEpochSinceLastHit
Duplicate Hits detection.
Definition: CbmMcbm2018MonitorAlgoTof.h:170
CbmMcbm2018TofPar::Get4ChanToPadiChan
Int_t Get4ChanToPadiChan(UInt_t uChannelInFee)
Definition: CbmMcbm2018TofPar.cxx:147
CbmMcbm2018MonitorAlgoTof::fvhGdpbPatternResyncEvo
std::vector< TH2 * > fvhGdpbPatternResyncEvo
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:235
CbmMcbm2018MonitorAlgoTof::fhLostEvtFractPerMsEvo
TH2 * fhLostEvtFractPerMsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:214
gdpbv100::Message::getStarTokenStarD
uint32_t getStarTokenStarD() const
Definition: gDpbMessv100.h:280
CbmMcbm2018MonitorAlgoTof::fhSysMessType
TH1 * fhSysMessType
Definition: CbmMcbm2018MonitorAlgoTof.h:181
CbmMcbm2018MonitorAlgoTof::fcSummary
TCanvas * fcSummary
Canvases.
Definition: CbmMcbm2018MonitorAlgoTof.h:265
CbmMcbm2018MonitorAlgoTof::fvhStarTrigStarTsEvo
std::vector< TProfile * > fvhStarTrigStarTsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:261
CbmMcbm2018MonitorAlgoTof::fvhGdpbResyncEvoPerTs
std::vector< TH2 * > fvhGdpbResyncEvoPerTs
Debug histo, only in DebugMonitorMode.
Definition: CbmMcbm2018MonitorAlgoTof.h:250
CbmMcbm2018MonitorAlgoTof::fhGet4MessType
TH2 * fhGet4MessType
Definition: CbmMcbm2018MonitorAlgoTof.h:183
gdpbv100::Message::getStarTsMsbStarB
uint64_t getStarTsMsbStarB() const
Definition: gDpbMessv100.h:269
gdpbv100::Message::getGdpbHitChanId
uint16_t getGdpbHitChanId() const
Definition: gDpbMessv100.h:219
CbmMcbm2018MonitorAlgoTof::fhErrorFractPerMsEvo
TH2 * fhErrorFractPerMsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:213
CbmMcbm2018MonitorAlgoTof::fuNrOfGet4PerFee
UInt_t fuNrOfGet4PerFee
Number of FEBs per GDPB.
Definition: CbmMcbm2018MonitorAlgoTof.h:97
gdpbv100::Message::getGdpbEpMissmatch
bool getGdpbEpMissmatch() const
Definition: gDpbMessv100.h:235
CbmMcbm2018MonitorAlgoTof::fvulCurrentEpochFull
std::vector< ULong64_t > fvulCurrentEpochFull
Epoch cycle from the Ms Start message and Epoch counter flip.
Definition: CbmMcbm2018MonitorAlgoTof.h:145
CbmMcbm2018MonitorAlgoTof::fhNbMissPatternPerMs
TH2 * fhNbMissPatternPerMs
Definition: CbmMcbm2018MonitorAlgoTof.h:225
CbmMcbm2018MonitorAlgoTof::fGdpbIdIndexMap
std::map< UInt_t, UInt_t > fGdpbIdIndexMap
Total number of GDPBs in the system.
Definition: CbmMcbm2018MonitorAlgoTof.h:95
CbmMcbm2018MonitorAlgoTof::Finish
virtual void Finish()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:172
gdpbv100::PATT_ENABLE
@ PATT_ENABLE
Definition: gDpbMessv100.h:82
CbmMcbm2018TofPar::GetNrOfGet4PerFee
Int_t GetNrOfGet4PerFee()
Definition: CbmMcbm2018TofPar.h:69
CbmMcbm2018MonitorAlgoTof::fbIgnoreCriticalErrors
Bool_t fbIgnoreCriticalErrors
Switch ON the filling of a additional set of histograms.
Definition: CbmMcbm2018MonitorAlgoTof.h:85
CbmMcbm2018MonitorAlgoTof::ProcessSlowCtrl
void ProcessSlowCtrl(gdpbv100::Message mess)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:1190
gdpbv100::GET4_V2X_ERR_UNPAIR_FALL
@ GET4_V2X_ERR_UNPAIR_FALL
Definition: gDpbMessv100.h:126
CbmMcbm2018MonitorAlgoTof::fvhGdpbGet4ChanErrors
std::vector< TH2 * > fvhGdpbGet4ChanErrors
Definition: CbmMcbm2018MonitorAlgoTof.h:201
CbmMcbm2018MonitorAlgoTof::ProcessError
void ProcessError(gdpbv100::FullMessage mess)
Definition: CbmMcbm2018MonitorAlgoTof.cxx:847
gdpbv100::SYS_GET4_SYNC_MISS
@ SYS_GET4_SYNC_MISS
Definition: gDpbMessv100.h:73
CbmStar2019Algo< CbmTofDigi >::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmStar2019Algo.h:116
CbmMcbm2018MonitorAlgoTof::fvhGdpbMissmatchEvoPerTs
std::vector< TH2 * > fvhGdpbMissmatchEvoPerTs
Exclude from dictionnary.
Definition: CbmMcbm2018MonitorAlgoTof.h:244
gdpbv100::Message::getGdpbSysErrUnused
uint16_t getGdpbSysErrUnused() const
Definition: gDpbMessv100.h:249
gdpbv100::Message::getGdpbHit32Tot
uint16_t getGdpbHit32Tot() const
Definition: gDpbMessv100.h:227
CbmMcbm2018MonitorAlgoTof::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Definition: CbmMcbm2018MonitorAlgoTof.h:115
CbmMcbm2018MonitorAlgoTof::fvhRemapChErrFract_gDPB
std::vector< TProfile2D * > fvhRemapChErrFract_gDPB
Definition: CbmMcbm2018MonitorAlgoTof.h:221
CbmMcbm2018MonitorAlgoTof::fhGdpbEpochMissEvo
TH2 * fhGdpbEpochMissEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:194
CbmMcbm2018MonitorAlgoTof::fvhStarTrigGdpbTsEvo
std::vector< TProfile * > fvhStarTrigGdpbTsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:260
CbmFormatMsHeaderPrintout.h
CbmMcbm2018MonitorAlgoTof::fvmEpSupprBuffer
std::vector< gdpbv100::Message > fvmEpSupprBuffer
Epoch + Epoch Cycle.
Definition: CbmMcbm2018MonitorAlgoTof.h:148
gdpbv100::GET4_V2X_ERR_EVT_DISCARD
@ GET4_V2X_ERR_EVT_DISCARD
Definition: gDpbMessv100.h:124
CbmMcbm2018MonitorAlgoTof::fhGet4ChanScm
TH2 * fhGet4ChanScm
Definition: CbmMcbm2018MonitorAlgoTof.h:184
CbmMcbm2018MonitorAlgoTof::fvcSumGdpbGet4
std::vector< TCanvas * > fvcSumGdpbGet4
Definition: CbmMcbm2018MonitorAlgoTof.h:267
gdpbv100::Message::getStarDaqCmdStarD
uint32_t getStarDaqCmdStarD() const
Definition: gDpbMessv100.h:279
CbmMcbm2018TofPar::GetPadiThresholdVal
Double_t GetPadiThresholdVal(UInt_t uCode)
Definition: CbmMcbm2018TofPar.cxx:201
gdpbv100::GET4_V2X_ERR_EPOCH_OVERF
@ GET4_V2X_ERR_EPOCH_OVERF
Definition: gDpbMessv100.h:128
gdpbv100::SYS_GDPB_UNKWN
@ SYS_GDPB_UNKWN
Definition: gDpbMessv100.h:71
CbmMcbm2018MonitorAlgoTof::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:179
CbmMcbm2018MonitorAlgoTof::GetParList
TList * GetParList()
Definition: CbmMcbm2018MonitorAlgoTof.cxx:196
CbmMcbm2018MonitorAlgoTof::fcStarTrigGdpbTsEvo
TCanvas * fcStarTrigGdpbTsEvo
Definition: CbmMcbm2018MonitorAlgoTof.h:272