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