CbmRoot
CbmMcbm2018MonitorAlgoTofPulser.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018MonitorAlgoTofPulser -----
4 // ----- Created 12.10.2019 by P.-A. Loizeau -----
5 // ----- -----
6 // -----------------------------------------------------------------------------
7 
9 
11 #include "CbmMcbm2018TofPar.h"
12 
13 #include "FairLogger.h"
14 #include "FairRootManager.h"
15 #include "FairRun.h"
16 #include "FairRunOnline.h"
17 #include "FairRuntimeDb.h"
18 
19 #include "TCanvas.h"
20 #include "TH1.h"
21 #include "TH2.h"
22 #include "TList.h"
23 #include "TPaveStats.h"
24 #include "TProfile.h"
25 #include "TROOT.h"
26 #include "TString.h"
27 
28 #include <fstream>
29 #include <iomanip>
30 #include <iostream>
31 #include <stdint.h>
32 
33 // -------------------------------------------------------------------------
35  : CbmStar2019Algo()
36  ,
38  fvbMaskedComponents()
39  , fiGdpbIndex(-1)
40  , fuUpdateFreqTs(100)
41  , fUnpackPar(nullptr)
42  , fuNrOfGdpbs(0)
43  , fGdpbIdIndexMap()
44  , fuNrOfFeePerGdpb(0)
45  , fuNrOfGet4PerFee(0)
46  , fuNrOfChannelsPerGet4(0)
47  , fuNrOfChannelsPerFee(0)
48  , fuNrOfGet4(0)
49  , fuNrOfGet4PerGdpb(0)
50  , fuNrOfChannelsPerGdpb(0)
51  , fuPulserMinTot(90)
52  , fuPulserMaxTot(110)
53  , fuPulserChannel(3)
54  , fulCurrentTsIdx(0)
55  , fulCurrentMsIdx(0)
56  , fdTsStartTime(-1.0)
57  , fdTsStopTimeCore(-1.0)
58  , fdMsTime(-1.0)
59  , fuMsIndex(0)
60  , fuCurrentEquipmentId(0)
61  , fuCurrDpbId(0)
62  , fuCurrDpbIdx(0)
63  , fuGet4Id(0)
64  , fuGet4Nr(0)
65  , fvulCurrentEpoch()
66  , fvulCurrentEpochCycle()
67  , fvulCurrentEpochFull()
68  , fvmEpSupprBuffer()
69  , fvvbFeeHitFound()
70  , fvvdFeeHits()
71  , dMinDt(0.0)
72  , dMaxDt(0.0)
73  , fdStartTime(-1.0)
74  , fuHistoryHistoSize(1800)
75  , fvvhFeePairPulserTimeDiff()
76  , fhPulserTimeDiffMean(nullptr)
77  , fhPulserTimeDiffRms(nullptr)
78  , fhPulserTimeDiffRmsZoom(nullptr)
79  , fhPulserRmsGdpbToRefEvo(nullptr)
80  , fhPulserRmsGbtxToRefEvo(nullptr) {}
83  fvmEpSupprBuffer.clear();
84 }
85 
86 // -------------------------------------------------------------------------
88  LOG(info) << "Initializing mCBM T0 2019 monitor algo";
89 
90  return kTRUE;
91 }
95 
97 }
98 
99 // -------------------------------------------------------------------------
101  LOG(info) << "Init parameter containers for CbmMcbm2018MonitorAlgoTofPulser";
102  Bool_t initOK = ReInitContainers();
103 
104  return initOK;
105 }
107  LOG(info) << "**********************************************";
108  LOG(info)
109  << "ReInit parameter containers for CbmMcbm2018MonitorAlgoTofPulser";
110 
111  fUnpackPar = (CbmMcbm2018TofPar*) fParCList->FindObject("CbmMcbm2018TofPar");
112  if (nullptr == fUnpackPar) return kFALSE;
113 
114  Bool_t initOK = InitParameters();
115 
116  return initOK;
117 }
119  if (nullptr == fParCList) fParCList = new TList();
120  fUnpackPar = new CbmMcbm2018TofPar("CbmMcbm2018TofPar");
121  fParCList->Add(fUnpackPar);
122 
123  return fParCList;
124 }
126 
128  LOG(info) << "Nr. of Tof GDPBs: " << fuNrOfGdpbs;
129 
131  LOG(info) << "Nr. of FEES per Tof GDPB: " << fuNrOfFeePerGdpb;
132 
134  LOG(info) << "Nr. of GET4 per Tof FEE: " << fuNrOfGet4PerFee;
135 
137  LOG(info) << "Nr. of channels per GET4: " << fuNrOfChannelsPerGet4;
138 
140  LOG(info) << "Nr. of channels per FEE: " << fuNrOfChannelsPerFee;
141 
143  LOG(info) << "Nr. of GET4s: " << fuNrOfGet4;
144 
146  LOG(info) << "Nr. of GET4s per GDPB: " << fuNrOfGet4PerGdpb;
147 
149  LOG(info) << "Nr. of channels per GDPB: " << fuNrOfChannelsPerGdpb;
150 
151  fGdpbIdIndexMap.clear();
152  for (UInt_t i = 0; i < fuNrOfGdpbs; ++i) {
154  LOG(info) << "GDPB Id of TOF " << i << " : " << std::hex
155  << fUnpackPar->GetGdpbId(i) << std::dec;
156  } // for( UInt_t i = 0; i < fuNrOfGdpbs; ++i )
157 
160  LOG(info) << "Timeslice parameters: each MS is " << fdMsSizeInNs << " ns";
161 
163  if (-1 < fiGdpbIndex) {
164  if (fuNrOfGdpbs <= static_cast<UInt_t>(fiGdpbIndex))
165  LOG(fatal) << "Selected gDPB out of bounds relative to parameter file: "
166  << fiGdpbIndex << " VS " << fuNrOfGdpbs;
167  else
168  LOG(info) << "Selected gDPB " << fiGdpbIndex
169  << " for single gDPB analysis";
170  fuNrOfGdpbs = 1;
171  fGdpbIdIndexMap.clear();
173  } // if( -1 < fiGdpbIndex )
174 
176  fvulCurrentEpoch.resize(fuNrOfGdpbs, 0);
180  fvvdFeeHits.resize(fuNrOfGdpbs);
181  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
182  fvvbFeeHitFound[uGdpb].resize(fuNrOfFeePerGdpb, kFALSE);
183  fvvdFeeHits[uGdpb].resize(fuNrOfFeePerGdpb, 0.0);
184  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
185 
186 
187  return kTRUE;
188 }
189 // -------------------------------------------------------------------------
190 
192  size_t component,
193  UShort_t usDetectorId) {
195  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsList.size(); ++uCompIdx)
196  if (component == fvMsComponentsList[uCompIdx]) return;
197 
199  fvMsComponentsList.push_back(component);
200 
201  LOG(info)
202  << "CbmMcbm2018MonitorAlgoTofPulser::AddMsComponentToList => Component "
203  << component << " with detector ID 0x" << std::hex << usDetectorId
204  << std::dec << " added to list";
205 }
206 // -------------------------------------------------------------------------
207 
208 Bool_t CbmMcbm2018MonitorAlgoTofPulser::ProcessTs(const fles::Timeslice& ts) {
209  fulCurrentTsIdx = ts.index();
210  fdTsStartTime = static_cast<Double_t>(ts.descriptor(0, 0).idx);
211 
213  if (0 == fulCurrentTsIdx) return kTRUE;
214 
216  if (-1.0 == fdTsCoreSizeInNs) {
217  fuNbCoreMsPerTs = ts.num_core_microslices();
218  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
221  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
222  << " Core MS and " << fuNbOverMsPerTs
223  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
224  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
225 
228  if (kFALSE == fbIgnoreOverlapMs) fuNbMsLoop += fuNbOverMsPerTs;
229  LOG(info) << "In each TS " << fuNbMsLoop << " MS will be looped over";
230  } // if( -1.0 == fdTsCoreSizeInNs )
231 
234  // LOG(info) << Form( "TS %5d Start %12f Stop %12f", fulCurrentTsIdx, fdTsStartTime, fdTsStopTimeCore );
235 
237  for (fuMsIndex = 0; fuMsIndex < fuNbMsLoop; fuMsIndex++) {
239  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size();
240  ++uMsCompIdx) {
241  UInt_t uMsComp = fvMsComponentsList[uMsCompIdx];
242 
243  if (kFALSE == ProcessMs(ts, uMsComp, fuMsIndex)) {
244  LOG(error) << "Failed to process ts " << fulCurrentTsIdx << " MS "
245  << fuMsIndex << " for component " << uMsComp;
246  return kFALSE;
247  } // if( kFALSE == ProcessMs( ts, uMsCompIdx, fuMsIndex ) )
248  } // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
249 
251  FillHistograms();
252  } // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
253 
254  return kTRUE;
255 }
256 
257 Bool_t CbmMcbm2018MonitorAlgoTofPulser::ProcessMs(const fles::Timeslice& ts,
258  size_t uMsCompIdx,
259  size_t uMsIdx) {
260  auto msDescriptor = ts.descriptor(uMsCompIdx, uMsIdx);
261  fuCurrentEquipmentId = msDescriptor.eq_id;
262  const uint8_t* msContent =
263  reinterpret_cast<const uint8_t*>(ts.content(uMsCompIdx, uMsIdx));
264 
265  uint32_t uSize = msDescriptor.size;
266  fulCurrentMsIdx = msDescriptor.idx;
267  fuCurrentMsSysId = static_cast<uint32_t>(msDescriptor.sys_id);
268  fdMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
269  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
270  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
271 
272  if (-1.0 == fdStartTime) fdStartTime = fdMsTime;
273 
274  if (0 == fvbMaskedComponents.size())
275  fvbMaskedComponents.resize(ts.num_components(), kFALSE);
276 
277  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
278  // fuCurrDpbIdx = fDpbIdIndexMap[ fuCurrDpbId ];
279 
281  auto it = fGdpbIdIndexMap.find(fuCurrDpbId);
282  if (it == fGdpbIdIndexMap.end()) {
283  if (kFALSE == fvbMaskedComponents[uMsCompIdx]) {
284  LOG(info)
285  << "---------------------------------------------------------------";
286  LOG(info) << FormatMsHeaderPrintout(msDescriptor);
287  LOG(warning) << "Could not find the gDPB index for AFCK id 0x" << std::hex
288  << fuCurrDpbId << std::dec << " in timeslice "
289  << fulCurrentTsIdx << " in microslice " << uMsIdx
290  << " component " << uMsCompIdx << "\n"
291  << "If valid this index has to be added in the TOF "
292  "parameter file in the DbpIdArray field";
293  fvbMaskedComponents[uMsCompIdx] = kTRUE;
294  } // if( kFALSE == fvbMaskedComponents[ uMsComp ] )
295  else
296  return kTRUE;
297 
300 
301  return kFALSE;
302  } // if( it == fGdpbIdIndexMap.end() )
303  else
305 
306  // If not integer number of message in input buffer, print warning/error
307  if (0 != (uSize % kuBytesPerMessage))
308  LOG(error) << "The input microslice buffer does NOT "
309  << "contain only complete nDPB messages!";
310 
311  // Compute the number of complete messages in the input microslice buffer
312  uint32_t uNbMessages =
313  (uSize - (uSize % kuBytesPerMessage)) / kuBytesPerMessage;
314 
315  // Prepare variables for the loop on contents
316  Int_t messageType = -111;
317  const uint64_t* pInBuff = reinterpret_cast<const uint64_t*>(msContent);
318  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
319  // Fill message
320  uint64_t ulData = static_cast<uint64_t>(pInBuff[uIdx]);
321 
323  if (0 == uIdx) {
324  ProcessEpochCycle(ulData);
325  continue;
326  } // if( 0 == uIdx )
327 
328  gdpbv100::Message mess(ulData);
330  messageType = mess.getMessageType();
331 
334  if (0x90 == fuCurrentMsSysId) fuGet4Id = mess.getGdpbGenChipId();
336 
337  if (fuNrOfGet4PerGdpb <= fuGet4Id && !mess.isStarTrigger()
339  LOG(warning) << "Message with Get4 ID too high: " << fuGet4Id << " VS "
340  << fuNrOfGet4PerGdpb << " set in parameters.";
341 
342  switch (messageType) {
343  case gdpbv100::MSG_HIT: {
344  if (mess.getGdpbHitIs24b()) {
346  LOG(fatal) << "This monitor does not support 24b hit messages!!!.";
347  continue;
348  } // if( getGdpbHitIs24b() )
349  else {
350  fvmEpSupprBuffer.push_back(mess);
351  } // else of if( getGdpbHitIs24b() )
352  break;
353  } // case gdpbv100::MSG_HIT:
354  case gdpbv100::MSG_EPOCH: {
356  ProcessEpoch(mess);
357  } // if this epoch message is a merged one valid for all chips
358  else {
360  LOG(fatal) << "This event builder does not support unmerged epoch "
361  "messages!!!.";
362  continue;
363  } // if single chip epoch message
364  break;
365  } // case gdpbv100::MSG_EPOCH:
366  case gdpbv100::MSG_SLOWC:
367  case gdpbv100::MSG_SYST:
373  break;
374  } // case not hit or epoch
375  default:
376  LOG(fatal) << "Message type " << std::hex << std::setw(2)
377  << static_cast<uint16_t>(messageType)
378  << " not included in Get4 data format.";
379  } // switch( mess.getMessageType() )
380  } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
381 
382  return kTRUE;
383 }
384 
385 // -------------------------------------------------------------------------
387  ULong64_t ulEpochCycleVal = ulCycleData & gdpbv100::kulEpochCycleFieldSz;
388 
389  if (!(ulEpochCycleVal == fvulCurrentEpochCycle[fuCurrDpbIdx]
390  || ulEpochCycleVal == fvulCurrentEpochCycle[fuCurrDpbIdx] + 1)
391  && 0 < fulCurrentMsIdx) {
392  LOG(warning) << "CbmMcbm2018MonitorAlgoTofPulser::ProcessEpochCycle => "
393  << " Missmatch in epoch cycles detected for Gdpb "
394  << fuCurrDpbIdx
395  << ", probably fake cycles due to epoch index corruption! "
396  << Form(" Current cycle 0x%09llX New cycle 0x%09llX",
398  ulEpochCycleVal);
399  } // if epoch cycle did not stay constant or increase by exactly 1, except if first MS of the TS
400  if (ulEpochCycleVal != fvulCurrentEpochCycle[fuCurrDpbIdx]) {
401  LOG(info) << "CbmMcbm2018MonitorAlgoTofPulser::ProcessEpochCycle => "
402  << " New epoch cycle for Gdpb " << fuCurrDpbIdx
403  << Form(": Current cycle 0x%09llX New cycle 0x%09llX",
405  ulEpochCycleVal);
406  } // if( ulEpochCycleVal != fvulCurrentEpochCycle[fuCurrDpbIdx] )
407  fvulCurrentEpochCycle[fuCurrDpbIdx] = ulEpochCycleVal;
408 
409  return;
410 }
412  ULong64_t ulEpochNr = mess.getGdpbEpEpochNb();
413  /*
414  Bool_t bSyncFlag = ( 1 == mess.getGdpbEpSync() );
415  Bool_t bDataLoss = ( 1 == mess.getGdpbEpDataLoss() );
416  Bool_t bEpochLoss = ( 1 == mess.getGdpbEpEpochLoss() );
417  Bool_t bMissmMatch = ( 1 == mess.getGdpbEpMissmatch() );
418 */
419  fvulCurrentEpoch[fuCurrDpbIdx] = ulEpochNr;
421  ulEpochNr
423 
426 }
427 // -------------------------------------------------------------------------
429  Int_t iBufferSize = fvmEpSupprBuffer.size();
430 
431  if (0 == iBufferSize) return;
432 
433  LOG(debug) << "Now processing stored messages for for gDPB " << fuCurrDpbIdx
434  << " with epoch number " << (fvulCurrentEpoch[fuCurrDpbIdx] - 1);
435 
438  std::stable_sort(fvmEpSupprBuffer.begin(), fvmEpSupprBuffer.end());
439 
441  ULong64_t ulCurEpochGdpbGet4 = fvulCurrentEpochFull[fuCurrDpbIdx];
442 
444  if (0 == ulCurEpochGdpbGet4) return;
445 
447  ulCurEpochGdpbGet4--;
448 
449  Int_t messageType = -111;
450  for (Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++) {
451  messageType = fvmEpSupprBuffer[iMsgIdx].getMessageType();
452 
454  fvmEpSupprBuffer[iMsgIdx].getGdpbGenChipId());
456  if (0x90 == fuCurrentMsSysId)
457  fuGet4Id = fvmEpSupprBuffer[iMsgIdx].getGdpbGenChipId();
459 
461  gdpbv100::FullMessage fullMess(fvmEpSupprBuffer[iMsgIdx],
462  ulCurEpochGdpbGet4);
463 
465  switch (messageType) {
466  case gdpbv100::MSG_HIT: {
467  ProcessHit(fullMess);
468  break;
469  } // case gdpbv100::MSG_HIT:
470  case gdpbv100::MSG_SLOWC:
471  case gdpbv100::MSG_SYST:
472  case gdpbv100::MSG_EPOCH:
478  break;
479  default:
480  LOG(error) << "Message type " << std::hex << std::setw(2)
481  << static_cast<uint16_t>(messageType)
482  << " not included in Get4 unpacker.";
483  } // switch( mess.getMessageType() )
484  } // for( Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++ )
485 
486  fvmEpSupprBuffer.clear();
487 }
488 // -------------------------------------------------------------------------
490  UInt_t uChannel = mess.getGdpbHitChanId();
491  UInt_t uTot = mess.getGdpbHit32Tot();
492 
496  // UInt_t uFts = mess.getGdpbHitFullTs() % 112;
497  // UInt_t uCts = mess.getGdpbHitFullTs() / 112;
498 
499  // UInt_t uChannelNr = fuGet4Id * fuNrOfChannelsPerGet4 + uChannel;
500  UInt_t uChannelNrInFee =
502  UInt_t uFeeNr = (fuGet4Id / fuNrOfGet4PerFee);
503  // UInt_t uFeeNrInSys = fuCurrDpbIdx * fuNrOfFeePerGdpb + uFeeNr;
504  // UInt_t uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee + fUnpackPar->Get4ChanToPadiChan( uChannelNrInFee );
505  UInt_t uRemappedChanNrInFee = fUnpackPar->Get4ChanToPadiChan(uChannelNrInFee);
506  // UInt_t uGbtxNr = (uFeeNr / fUnpackPar->GetNrOfFeePerGbtx());
507  // UInt_t uFeeInGbtx = (uFeeNr % fUnpackPar->GetNrOfFeePerGbtx());
508  // UInt_t uGbtxNrInSys = fuCurrDpbIdx * fUnpackPar->GetNrOfGbtxPerGdpb() + uGbtxNr;
509 
510  // UInt_t uChanInSyst = fuCurrDpbIdx * fuNrOfChannelsPerGdpb + uChannelNr;
511  // UInt_t uRemappedChannelNrInSys = fuCurrDpbIdx * fuNrOfChannelsPerGdpb
512  // + uFeeNr * fuNrOfChannelsPerFee
513  // + fUnpackPar->Get4ChanToPadiChan( uChannelNrInFee );
514 
515  // ULong_t ulHitTime = mess.getMsgFullTime( mess.getExtendedEpoch() );
516  Double_t dHitTime = mess.GetFullTimeNs();
517  // Double_t dHitTot = uTot; // in bins
518 
519  if (fuPulserChannel == uRemappedChanNrInFee && fuPulserMinTot < uTot
520  && uTot < fuPulserMaxTot) {
521  fvvbFeeHitFound[fuCurrDpbIdx][uFeeNr] = kTRUE;
522  fvvdFeeHits[fuCurrDpbIdx][uFeeNr] = dHitTime;
523  } // if( fuPulserChannel == uRemappedChanNrInFee && fuPulserMinTot < uTot && uTot < fuPulserMaxTot )
524 }
525 // -------------------------------------------------------------------------
526 
528  std::string sFolder = "mTofMoni";
529 
530  LOG(info) << "create Histos for mTof monitoring ";
531 
532  /*******************************************************************/
533  UInt_t uNbBinsDt =
534  kuNbBinsDt
535  + 1; // To account for extra bin due to shift by 1/2 bin of both ranges
536  dMinDt =
537  -1. * (kuNbBinsDt * gdpbv100::kdBinSize / 2.) - gdpbv100::kdBinSize / 2.;
538  dMaxDt =
540 
541  std::cout << " Bin size " << gdpbv100::kdBinSize << std::endl;
542  std::cout << " Epo bins " << gdpbv100::kuEpochInBins << std::endl;
543  std::cout << " Epo size " << gdpbv100::kdEpochInPs << std::endl;
544  std::cout << " Epo size " << gdpbv100::kdEpochInNs << std::endl;
545  /*******************************************************************/
548  for (UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; ++uFeeA) {
549  UInt_t uGdpbA = uFeeA / (fuNrOfFeePerGdpb);
550  if (-1 != fiGdpbIndex) uGdpbA = fiGdpbIndex;
552  UInt_t uFeeIndexA = uFeeA;
553  // UInt_t uFeeIdA = uFeeA - ( fuNrOfFeePerGdpb * uGdpbA );
554  UInt_t uFeeIdA = uFeeIndexA - (3 * 6 * uGdpbA);
555 
557  for (UInt_t uFeeB = 0; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs; ++uFeeB) {
558 
559  if (uFeeA < uFeeB) {
561  UInt_t uFeeIndexB = uFeeB;
562 
563  UInt_t uGdpbB = uFeeB / (fuNrOfFeePerGdpb);
564  if (-1 != fiGdpbIndex) uGdpbB = fiGdpbIndex;
565  // UInt_t uFeeIdB = uFeeB - ( fuNrOfFeePerGdpb * uGdpbB );
566  UInt_t uFeeIdB = uFeeIndexB - (3 * 6 * uGdpbB);
567  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB] =
568  new TH1I(Form("hFeePairPulserTimeDiff_s%02u_f%1u_s%02u_f%1u",
569  uGdpbA,
570  uFeeIdA,
571  uGdpbB,
572  uFeeIdB),
573  Form("Time difference for pulser on gDPB %02u FEE %1u and "
574  "gDPB %02u FEE %1u; DeltaT [ps]; Counts",
575  uGdpbA,
576  uFeeIdA,
577  uGdpbB,
578  uFeeIdB),
579  uNbBinsDt,
580  dMinDt,
581  dMaxDt);
582 
584  Form("TofDt/s%03u", uFeeIndexA));
585  } // if( uFeeA < uFeeB )
586  else
587  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB] = NULL;
588  } // for( UInt_t uFeeB = 0; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs; ++uFeeB )
589  } // for( UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; ++uFeeA )
590 
592  UInt_t uTotalNbFee = fuNrOfFeePerGdpb * fuNrOfGdpbs;
593  // Double_t dGdpbMin = -0.5;
594  // Double_t dGdpbMax = fuNrOfGdpbs;
595  fhPulserTimeDiffMean = new TH2D(
596  "hPulserTimeDiffMean",
597  "Time difference Mean for each FEE pairs; FEE A; FEE B ; Mean [ps]",
598  uTotalNbFee - 1,
599  -0.5,
600  uTotalNbFee - 1.5,
601  uTotalNbFee - 1,
602  0.5,
603  uTotalNbFee - 0.5);
604 
606  new TH2D("hPulserTimeDiffRms",
607  "Time difference RMS for each FEE pairs; FEE A; FEE B ; RMS [ps]",
608  uTotalNbFee - 1,
609  -0.5,
610  uTotalNbFee - 1.5,
611  uTotalNbFee - 1,
612  0.5,
613  uTotalNbFee - 0.5);
614 
616  new TH2D("hPulserTimeDiffRmsZoom",
617  "Time difference RMS for each FEE pairs after zoom on peak; FEE "
618  "A; FEE B ; RMS [ps]",
619  uTotalNbFee - 1,
620  -0.5,
621  uTotalNbFee - 1.5,
622  uTotalNbFee - 1,
623  0.5,
624  uTotalNbFee - 0.5);
625 
626 
628  new TH2D("hPulserRmsGdpbToRefEvo",
629  "Evo. of Time difference RMS for selected FEE of each gDPb to the "
630  "1st; Time in run [s] A; gDPB ; RMS [ps]",
632  0,
634  fuNrOfGdpbs - 1,
635  0.5,
636  fuNrOfGdpbs - 0.5);
637 
639  new TH2D("hPulserTimeDiffRmsZoom",
640  "Evo. of Time difference RMS for selected FEE pairs of each GBTx "
641  "to the 1st in same gDPB; Time in run [s] A; FEE ; RMS [ps]",
643  0,
645  uTotalNbFee - 1,
646  0.5,
647  uTotalNbFee - 0.5);
648 
653  /*******************************************************************/
654 
655  /*******************************************************************/
658  fcSummary = new TCanvas("cSummary", "Pulser Monitoring Summary");
659  fcSummary->Divide(3);
660 
661  fcSummary->cd(1);
662  gPad->SetGridx();
663  gPad->SetGridy();
664  fhPulserTimeDiffMean->Draw("colz");
665 
666  fcSummary->cd(2);
667  gPad->SetGridx();
668  gPad->SetGridy();
669  fhPulserTimeDiffRms->Draw("colz");
670 
671  fcSummary->cd(3);
672  gPad->SetGridx();
673  gPad->SetGridy();
674  fhPulserTimeDiffRmsZoom->Draw("colz");
675 
676  AddCanvasToVector(fcSummary, "canvases");
678  /*******************************************************************/
679 
680  return kTRUE;
681 }
686  && fuNbCoreMsPerTs - 1 == fuMsIndex) {
687  fhPulserTimeDiffMean->Reset();
688  fhPulserTimeDiffRms->Reset();
689  fhPulserTimeDiffRmsZoom->Reset();
690  } // if( 1 == fulCurrentTsIdx % fuUpdateFreqTs && fuNbCoreMsPerTs - 1 == fuMsIndex )
691 
692  for (UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeA++) {
693  UInt_t uGdpbA = uFeeA / (fuNrOfFeePerGdpb);
694  UInt_t uFeeIdA = uFeeA - (fuNrOfFeePerGdpb * uGdpbA);
695 
697  if (kFALSE == fvvbFeeHitFound[uGdpbA][uFeeIdA]) continue;
698 
699  for (UInt_t uFeeB = uFeeA + 1; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs;
700  uFeeB++) {
701  UInt_t uGdpbB = uFeeB / (fuNrOfFeePerGdpb);
702  UInt_t uFeeIdB = uFeeB - (fuNrOfFeePerGdpb * uGdpbB);
703 
705  if (kFALSE == fvvbFeeHitFound[uGdpbB][uFeeIdB]) continue;
706 
707  Double_t dTimeDiff =
708  1e3 * (fvvdFeeHits[uGdpbB][uFeeIdB] - fvvdFeeHits[uGdpbA][uFeeIdA]);
709  if (TMath::Abs(dTimeDiff) < kdMaxDtPulserPs) {
710  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->Fill(dTimeDiff);
711  } // f( TMath::Abs( dTimeDiff ) < kdMaxDtPulserPs )
712 
715  && fuNbCoreMsPerTs - 1 == fuMsIndex) {
717  UInt_t uFeeIndexA = uFeeA;
718  UInt_t uFeeIndexB = uFeeB;
719  fhPulserTimeDiffMean->Fill(
720  uFeeIndexA,
721  uFeeIndexB,
722  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetMean());
723  fhPulserTimeDiffRms->Fill(
724  uFeeIndexA,
725  uFeeIndexB,
726  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetRMS());
727 
729  Int_t iBinWithMax =
730  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetMaximumBin();
731  Double_t dNbCounts =
732  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->Integral();
733 
735  Double_t dPeakPos =
736  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetXaxis()->GetBinCenter(
737  iBinWithMax);
738  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetXaxis()->SetRangeUser(
739  dPeakPos - kdFitZoomWidthPs, dPeakPos + kdFitZoomWidthPs);
740 
742  Double_t dZoomCounts =
743  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->Integral();
744 
746  if ((dZoomCounts / dNbCounts) < 0.8) {
747  fhPulserTimeDiffRmsZoom->Fill(uFeeIndexA, uFeeIndexB, 0.0);
748  // LOG(warning) << "CbmMcbm2018MonitorAlgoTofPulser::FillHistograms => Zoom too strong, "
749  // << "more than 20% loss for FEE pair " << uFeeA << " and " << uFeeB << " !!! ";
750  } // if( ( dZoomCounts / dNbCounts ) < 0.8 )
751  else
753  uFeeIndexA,
754  uFeeIndexB,
755  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetRMS());
756 
758  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetXaxis()->UnZoom();
759  /*
760  LOG(info) << "Stats FEE A " << std::setw(3) << uFeeA
761  << " FEE B " << std::setw(3) << uFeeB
762  << Form( " %5.0f %f", fvvhFeePairPulserTimeDiff[ uFeeA ][ uFeeB ]->GetMean(),
763  fvvhFeePairPulserTimeDiff[ uFeeA ][ uFeeB ]->GetRMS() );
764 */
765  } // if( 1 == fulCurrentTsIdx % fuUpdateFreqTs && fuNbCoreMsPerTs - 1 == fuMsIndex )
766  } // for( UInt_t uFeeB = uFeeA + 1; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeB++)
767 
769  fvvbFeeHitFound[uGdpbA][uFeeIdA] = kFALSE;
770  } // for( UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeA++)
771 
772  return kTRUE;
773 }
775  fhPulserTimeDiffMean->Reset();
776  fhPulserTimeDiffRms->Reset();
777  fhPulserTimeDiffRmsZoom->Reset();
778 
779  for (UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeA++) {
780  UInt_t uGdpbA = uFeeA / (fuNrOfFeePerGdpb);
781  UInt_t uFeeIdA = uFeeA - (fuNrOfFeePerGdpb * uGdpbA);
782 
783  for (UInt_t uFeeB = uFeeA + 1; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs;
784  uFeeB++) {
785  // UInt_t uGdpbB = uFeeB / ( fuNrOfFeePerGdpb );
786  // UInt_t uFeeIdB = uFeeB - ( fuNrOfFeePerGdpb * uGdpbB );
787 
788  if (nullptr == fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]) continue;
789 
791  UInt_t uFeeIndexA = uFeeA;
792  UInt_t uFeeIndexB = uFeeB;
793  fhPulserTimeDiffMean->Fill(
794  uFeeIndexA,
795  uFeeIndexB,
796  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetMean());
797  fhPulserTimeDiffRms->Fill(
798  uFeeIndexA,
799  uFeeIndexB,
800  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetRMS());
801 
803  Int_t iBinWithMax =
804  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetMaximumBin();
805  Double_t dNbCounts = fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->Integral();
806 
808  Double_t dPeakPos =
809  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetXaxis()->GetBinCenter(
810  iBinWithMax);
811  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetXaxis()->SetRangeUser(
812  dPeakPos - kdFitZoomWidthPs, dPeakPos + kdFitZoomWidthPs);
813 
815  Double_t dZoomCounts =
816  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->Integral();
817 
819  if ((dZoomCounts / dNbCounts) < 0.8) {
820  fhPulserTimeDiffRmsZoom->Fill(uFeeIndexA, uFeeIndexB, 0.0);
821  LOG(warning) << "CbmMcbm2018MonitorAlgoTofPulser::FillHistograms => "
822  "Zoom too strong, "
823  << "more than 20% loss for FEE pair " << uFeeA << " and "
824  << uFeeB << " !!! ";
825  continue;
826  } // if( ( dZoomCounts / dNbCounts ) < 0.8 )
827  else
829  uFeeIndexA,
830  uFeeIndexB,
831  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetRMS());
832 
833 
835  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetXaxis()->UnZoom();
836 
837  LOG(info) << "Stats FEE A " << std::setw(3) << uFeeIndexA << " FEE B "
838  << std::setw(3) << uFeeIndexB
839  << Form(" %5.0f %f",
840  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetMean(),
841  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->GetRMS());
842 
843  } // for( UInt_t uFeeB = uFeeA + 1; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeB++)
844 
846  fvvbFeeHitFound[uGdpbA][uFeeIdA] = kFALSE;
847  } // for( UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeA++)
848 
849  return kTRUE;
850 }
852  for (UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeA++) {
853  for (UInt_t uFeeB = uFeeA + 1; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs;
854  uFeeB++) {
855  fvvhFeePairPulserTimeDiff[uFeeA][uFeeB]->Reset();
856  } // for( UInt_t uFeeB = uFeeA + 1; uFeeB < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeB++)
857  } // for( UInt_t uFeeA = 0; uFeeA < fuNrOfFeePerGdpb * fuNrOfGdpbs; uFeeA++)
858  fhPulserTimeDiffMean->Reset();
859  fhPulserTimeDiffRms->Reset();
860  fhPulserTimeDiffRmsZoom->Reset();
861 
862  fdStartTime = -1.0;
863 
864  return kTRUE;
865 }
866 // -------------------------------------------------------------------------
gdpbv100::MSG_STAR_TRI_A
@ MSG_STAR_TRI_A
Definition: gDpbMessv100.h:63
gdpbv100::Message
Definition: gDpbMessv100.h:133
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfGet4
UInt_t fuNrOfGet4
Number of channels in each FEE.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:85
CbmMcbm2018MonitorAlgoTofPulser::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:101
CbmMcbm2018MonitorAlgoTofPulser::fvulCurrentEpochCycle
std::vector< ULong64_t > fvulCurrentEpochCycle
Current epoch index, per DPB.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:125
CbmMcbm2018MonitorAlgoTofPulser::ProcessTs
Bool_t ProcessTs(const fles::Timeslice &ts)
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:208
gdpbv100::Message::getGdpbEpEpochNb
uint32_t getGdpbEpEpochNb() const
Definition: gDpbMessv100.h:231
CbmStar2019Algo< CbmTofDigi >::fdMsSizeInNs
Double_t fdMsSizeInNs
/‍** Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice **‍/
Definition: CbmStar2019Algo.h:117
CbmMcbm2018MonitorAlgoTofPulser::UpdateStats
Bool_t UpdateStats()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:774
CbmMcbm2018MonitorAlgoTofPulser::fdTsStopTimeCore
Double_t fdTsStopTimeCore
Time in ns of current TS from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:107
CbmMcbm2018MonitorAlgoTofPulser::fuPulserChannel
UInt_t fuPulserChannel
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:92
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfChannelsPerFee
UInt_t fuNrOfChannelsPerFee
Number of channels in each GET4.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:84
CbmMcbm2018MonitorAlgoTofPulser::dMinDt
Double_t dMinDt
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:139
gdpbv100::FullMessage::GetFullTimeNs
double GetFullTimeNs() const
Definition: gDpbMessv100.h:395
CbmMcbm2018TofPar::ElinkIdxToGet4Idx
Int_t ElinkIdxToGet4Idx(UInt_t uElink)
Definition: CbmMcbm2018TofPar.cxx:172
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfChannelsPerGet4
UInt_t fuNrOfChannelsPerGet4
Number of GET4s per FEE.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:83
CbmStar2019Algo< CbmTofDigi >::fuNbMsLoop
size_t fuNbMsLoop
Definition: CbmStar2019Algo.h:114
CbmMcbm2018TofPar::GetGdpbId
Int_t GetGdpbId(Int_t i)
Definition: CbmMcbm2018TofPar.h:67
CbmMcbm2018MonitorAlgoTofPulser::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:115
CbmMcbm2018TofPar.h
CbmMcbm2018MonitorAlgoTofPulser::ProcessHit
void ProcessHit(gdpbv100::FullMessage mess)
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:489
gdpbv100::MSG_HIT
@ MSG_HIT
Definition: gDpbMessv100.h:59
CbmMcbm2018MonitorAlgoTofPulser::ProcessEpoch
void ProcessEpoch(gdpbv100::Message mess)
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:411
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
gdpbv100::MSG_SLOWC
@ MSG_SLOWC
Definition: gDpbMessv100.h:61
CbmMcbm2018MonitorAlgoTofPulser::fvvdFeeHits
std::vector< std::vector< Double_t > > fvvdFeeHits
[ gDPB ][ FEE ]
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:133
CbmMcbm2018MonitorAlgoTofPulser::FillHistograms
Bool_t FillHistograms()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:682
CbmMcbm2018MonitorAlgoTofPulser::fdStartTime
Double_t fdStartTime
Starting time and time evolution book-keeping.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:143
CbmStar2019Algo< CbmTofDigi >::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmStar2019Algo.h:113
GetRMS
static Double_t GetRMS(const char *name)
Definition: GenNoiseElectrons.cxx:34
CbmMcbm2018MonitorAlgoTofPulser::dMaxDt
Double_t dMaxDt
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:140
gdpbv100::MSG_STAR_TRI_D
@ MSG_STAR_TRI_D
Definition: gDpbMessv100.h:66
gdpbv100::Message::getMessageType
uint8_t getMessageType() const
Returns the message type. Valid for all message types. 4 bit.
Definition: gDpbMessv100.h:206
CbmStar2019Algo< CbmTofDigi >::AddHistoToVector
void AddHistoToVector(TNamed *pointer, std::string sFolder="")
For monitor algos.
Definition: CbmStar2019Algo.h:80
CbmMcbm2018MonitorAlgoTofPulser::ResetHistograms
Bool_t ResetHistograms()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:851
CbmMcbm2018MonitorAlgoTofPulser::CbmMcbm2018MonitorAlgoTofPulser
CbmMcbm2018MonitorAlgoTofPulser()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:34
CbmMcbm2018MonitorAlgoTofPulser::ProcessEpochCycle
void ProcessEpochCycle(uint64_t ulCycleData)
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:386
CbmStar2019Algo< CbmTofDigi >::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmStar2019Algo.h:112
CbmMcbm2018MonitorAlgoTofPulser::kuNbBinsDt
const UInt_t kuNbBinsDt
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:138
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfFeePerGdpb
UInt_t fuNrOfFeePerGdpb
gDPB ID to index map
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:81
gdpbv100::kdEpochInNs
const double kdEpochInNs
Definition: gDpbMessv100.h:37
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfGdpbs
UInt_t fuNrOfGdpbs
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:79
gdpbv100::kuEpochCounterSz
const uint32_t kuEpochCounterSz
Definition: gDpbMessv100.h:40
gdpbv100::Message::isStarTrigger
bool isStarTrigger() const
Returns true is message type is MSG_STAR_TRI_A, _B, _C, _D (STAR Trigger message)
Definition: gDpbMessv100.h:329
CbmStar2019Algo< CbmTofDigi >::fdTsFullSizeInNs
Double_t fdTsFullSizeInNs
Total size of the core MS in a TS, [nanoseconds].
Definition: CbmStar2019Algo.h:121
CbmStar2019Algo< CbmTofDigi >::fParCList
TList * fParCList
Parameter management.
Definition: CbmStar2019Algo.h:108
gdpbv100::kdEpochInPs
const double kdEpochInPs
Definition: gDpbMessv100.h:35
CbmMcbm2018MonitorAlgoTofPulser::~CbmMcbm2018MonitorAlgoTofPulser
~CbmMcbm2018MonitorAlgoTofPulser()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:81
CbmMcbm2018MonitorAlgoTofPulser::InitParameters
Bool_t InitParameters()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:125
CbmStar2019Algo< CbmTofDigi >::fvMsComponentsList
std::vector< size_t > fvMsComponentsList
Parameters related to FLES containers.
Definition: CbmStar2019Algo.h:111
CbmMcbm2018MonitorAlgoTofPulser::ProcessEpSupprBuffer
void ProcessEpSupprBuffer()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:428
CbmMcbm2018MonitorAlgoTofPulser::Finish
virtual void Finish()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:93
CbmMcbm2018MonitorAlgoTofPulser::fvmEpSupprBuffer
std::vector< gdpbv100::Message > fvmEpSupprBuffer
Epoch + Epoch Cycle.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:129
CbmMcbm2018MonitorAlgoTofPulser::ProcessMs
Bool_t ProcessMs(const fles::Timeslice &ts, size_t uMsCompIdx, size_t uMsIdx)
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:257
CbmMcbm2018MonitorAlgoTofPulser::fUnpackPar
CbmMcbm2018TofPar * fUnpackPar
Settings from parameter file.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:77
CbmMcbm2018MonitorAlgoTofPulser::kuBytesPerMessage
static const UInt_t kuBytesPerMessage
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:96
CbmMcbm2018MonitorAlgoTofPulser::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:117
CbmMcbm2018MonitorAlgoTofPulser::fuPulserMinTot
UInt_t fuPulserMinTot
Number of channels per GDPB.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:90
CbmMcbm2018TofPar::GetNrOfGdpbs
Int_t GetNrOfGdpbs()
FIXME: replace with method returning the correspondign constants! see Star2019 parameter.
Definition: CbmMcbm2018TofPar.h:66
CbmMcbm2018MonitorAlgoTofPulser::fhPulserRmsGbtxToRefEvo
TH2 * fhPulserRmsGbtxToRefEvo
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:154
CbmMcbm2018MonitorAlgoTofPulser::fhPulserRmsGdpbToRefEvo
TH2 * fhPulserRmsGdpbToRefEvo
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:153
CbmMcbm2018MonitorAlgoTofPulser.h
gdpbv100::MSG_STAR_TRI_C
@ MSG_STAR_TRI_C
Definition: gDpbMessv100.h:65
CbmMcbm2018MonitorAlgoTofPulser::Reset
virtual void Reset()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:92
CbmMcbm2018MonitorAlgoTofPulser::fuUpdateFreqTs
UInt_t fuUpdateFreqTs
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:74
CbmStar2019Algo
Definition: CbmStar2019Algo.h:43
CbmMcbm2018MonitorAlgoTofPulser::fGdpbIdIndexMap
std::map< UInt_t, UInt_t > fGdpbIdIndexMap
Total number of GDPBs in the system.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:80
CbmMcbm2018MonitorAlgoTofPulser::fvulCurrentEpochFull
std::vector< ULong64_t > fvulCurrentEpochFull
Epoch cycle from the Ms Start message and Epoch counter flip.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:126
CbmMcbm2018MonitorAlgoTofPulser::fhPulserTimeDiffRms
TH2 * fhPulserTimeDiffRms
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:151
CbmMcbm2018MonitorAlgoTofPulser::CreateHistograms
Bool_t CreateHistograms()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:527
CbmStar2019Algo< CbmTofDigi >::fdTsCoreSizeInNs
Double_t fdTsCoreSizeInNs
Size of a single MS, [nanoseconds].
Definition: CbmStar2019Algo.h:119
CbmMcbm2018MonitorAlgoTofPulser::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:100
gdpbv100::kuChipIdMergedEpoch
const uint32_t kuChipIdMergedEpoch
Definition: gDpbMessv100.h:51
CbmMcbm2018MonitorAlgoTofPulser::fvbMaskedComponents
std::vector< Bool_t > fvbMaskedComponents
Control flags.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:72
gdpbv100::MSG_SYST
@ MSG_SYST
Definition: gDpbMessv100.h:62
CbmMcbm2018MonitorAlgoTofPulser::fdTsStartTime
Double_t fdTsStartTime
SysId of the current MS in TS (0 to fuTotalMsNb)
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:105
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfGet4PerGdpb
UInt_t fuNrOfGet4PerGdpb
Total number of Get4 chips in the system.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:86
CbmMcbm2018MonitorAlgoTofPulser::fdMsTime
Double_t fdMsTime
End Time in ns of current TS Core from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:109
CbmMcbm2018MonitorAlgoTofPulser::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:106
CbmMcbm2018MonitorAlgoTofPulser::fuGet4Nr
UInt_t fuGet4Nr
running number (0 to fuNrOfGet4PerGdpb) of the Get4 chip of a unique GDPB for current message
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:121
CbmMcbm2018MonitorAlgoTofPulser::fvvbFeeHitFound
std::vector< std::vector< Bool_t > > fvvbFeeHitFound
Storing the time of the last hit for each MS in each of the FEE.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:132
CbmMcbm2018MonitorAlgoTofPulser::GetParList
TList * GetParList()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:118
CbmMcbm2018MonitorAlgoTofPulser::fuGet4Id
UInt_t fuGet4Id
Index of the DPB from which the MS currently unpacked is coming.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:119
FormatMsHeaderPrintout
std::string FormatMsHeaderPrintout(const fles::MicrosliceDescriptor &msDescriptor)
Definition: CbmFormatMsHeaderPrintout.cxx:5
gdpbv100::kdBinSize
const double kdBinSize
Definition: gDpbMessv100.h:30
CbmMcbm2018MonitorAlgoTofPulser::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:191
CbmMcbm2018TofPar
Definition: CbmMcbm2018TofPar.h:18
CbmMcbm2018TofPar::GetNrOfChannelsPerGet4
Int_t GetNrOfChannelsPerGet4()
Definition: CbmMcbm2018TofPar.h:70
CbmMcbm2018TofPar::GetSizeMsInNs
Double_t GetSizeMsInNs()
Definition: CbmMcbm2018TofPar.h:81
gdpbv100::MSG_EPOCH
@ MSG_EPOCH
Definition: gDpbMessv100.h:60
CbmMcbm2018MonitorAlgoTofPulser::kdFitZoomWidthPs
const Double_t kdFitZoomWidthPs
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:141
gdpbv100::kulEpochCycleFieldSz
const uint64_t kulEpochCycleFieldSz
Definition: gDpbMessv100.h:49
CbmMcbm2018MonitorAlgoTofPulser::fcSummary
TCanvas * fcSummary
Canvases.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:157
gdpbv100::Message::getGdpbHitIs24b
uint16_t getGdpbHitIs24b() const
Definition: gDpbMessv100.h:218
gdpbv100::Message::getGdpbGenChipId
uint16_t getGdpbGenChipId() const
Definition: gDpbMessv100.h:214
gdpbv100::kuEpochInBins
const uint32_t kuEpochInBins
Definition: gDpbMessv100.h:32
gdpbv100::MSG_STAR_TRI_B
@ MSG_STAR_TRI_B
Definition: gDpbMessv100.h:64
CbmMcbm2018MonitorAlgoTofPulser::fuHistoryHistoSize
UInt_t fuHistoryHistoSize
Time of first MS.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:144
CbmMcbm2018MonitorAlgoTofPulser::fuMsIndex
UInt_t fuMsIndex
Start Time in ns of current MS from its index field in header.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:110
CbmMcbm2018TofPar::GetNrOfFeePerGdpb
static constexpr UInt_t GetNrOfFeePerGdpb()
Definition: CbmMcbm2018TofPar.h:60
CbmStar2019Algo< CbmTofDigi >::AddCanvasToVector
void AddCanvasToVector(TCanvas *pointer, std::string sFolder="")
Definition: CbmStar2019Algo.h:87
gdpbv100::FullMessage
Definition: gDpbMessv100.h:362
CbmMcbm2018TofPar::Get4ChanToPadiChan
Int_t Get4ChanToPadiChan(UInt_t uChannelInFee)
Definition: CbmMcbm2018TofPar.cxx:147
CbmMcbm2018MonitorAlgoTofPulser::fvvhFeePairPulserTimeDiff
std::vector< std::vector< TH1 * > > fvvhFeePairPulserTimeDiff
Size in seconds of the evolution histograms.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:149
CbmMcbm2018MonitorAlgoTofPulser::fuCurrentMsSysId
uint32_t fuCurrentMsSysId
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:103
CbmMcbm2018MonitorAlgoTofPulser::fhPulserTimeDiffMean
TH2 * fhPulserTimeDiffMean
[ FEE A ][ FEE B ]
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:150
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfGet4PerFee
UInt_t fuNrOfGet4PerFee
Number of FEBs per GDPB.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:82
CbmMcbm2018MonitorAlgoTofPulser::Init
virtual Bool_t Init()
Definition: CbmMcbm2018MonitorAlgoTofPulser.cxx:87
CbmMcbm2018MonitorAlgoTofPulser::fhPulserTimeDiffRmsZoom
TH2 * fhPulserTimeDiffRmsZoom
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:152
CbmMcbm2018MonitorAlgoTofPulser::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:100
CbmMcbm2018MonitorAlgoTofPulser::kdMaxDtPulserPs
const Double_t kdMaxDtPulserPs
[ gDPB ][ FEE ]
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:137
CbmMcbm2018MonitorAlgoTofPulser::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:113
gdpbv100::Message::getGdpbHitChanId
uint16_t getGdpbHitChanId() const
Definition: gDpbMessv100.h:219
CbmMcbm2018MonitorAlgoTofPulser::fvulCurrentEpoch
std::vector< ULong64_t > fvulCurrentEpoch
Data format control: Current time references for each GDPB: merged epoch marker, epoch cycle,...
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:123
CbmMcbm2018MonitorAlgoTofPulser::fuPulserMaxTot
UInt_t fuPulserMaxTot
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:91
CbmMcbm2018TofPar::GetNrOfGet4PerFee
Int_t GetNrOfGet4PerFee()
Definition: CbmMcbm2018TofPar.h:69
CbmStar2019Algo< CbmTofDigi >::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmStar2019Algo.h:116
gdpbv100::Message::getGdpbHit32Tot
uint16_t getGdpbHit32Tot() const
Definition: gDpbMessv100.h:227
CbmMcbm2018MonitorAlgoTofPulser::fuNrOfChannelsPerGdpb
UInt_t fuNrOfChannelsPerGdpb
Number of GET4s per GDPB.
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:87
CbmFormatMsHeaderPrintout.h
CbmMcbm2018MonitorAlgoTofPulser::fiGdpbIndex
Int_t fiGdpbIndex
Definition: CbmMcbm2018MonitorAlgoTofPulser.h:73