CbmRoot
CbmMcbm2018UnpackerAlgoTof.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018UnpackerAlgoTof -----
4 // ----- Created 10.02.2019 by P.-A. Loizeau -----
5 // ----- -----
6 // -----------------------------------------------------------------------------
7 
8 #include "CbmMcbm2018UnpackerAlgoTof.h"
9 
10 #include "CbmFormatDecHexPrintout.h"
11 #include "CbmFormatMsHeaderPrintout.h"
12 #include "CbmMcbm2018TofPar.h"
13 #include "CbmTofAddress.h"
14 #include "CbmTofDetectorId_v14a.h" // in cbmdata/tof
15 
16 #include <Logger.h>
17 
18 #include "TCanvas.h"
19 #include "TH1.h"
20 #include "TH2.h"
21 #include "TList.h"
22 #include "TProfile.h"
23 #include "TROOT.h"
24 #include "TString.h"
25 
26 #include <fstream>
27 #include <iomanip>
28 #include <iostream>
29 #include <stdint.h>
30 #include <vector>
31 
32 /*
33 static Int_t NMappingWarnings=100;
34 static uint32_t pat_mess[8]={8*0};
35 std::vector< std::vector <uint32_t> > Pat_Request;
36 std::vector<Bool_t> bGdpbOK;
37 static Bool_t bEnableOut=kFALSE;
38 static Int_t fiMsGood=0;
39 static Int_t fiMsBad=0;
40 */
41 // -------------------------------------------------------------------------
42 CbmMcbm2018UnpackerAlgoTof::CbmMcbm2018UnpackerAlgoTof()
43  : CbmStar2019Algo()
44  ,
46  fbMonitorMode(kFALSE)
47  , fbDebugMonitorMode(kFALSE)
48  , fvbMaskedComponents()
49  , fUnpackPar(nullptr)
50  , fuNrOfGdpbs(0)
51  , fGdpbIdIndexMap()
52  , fuNrOfFeePerGdpb(0)
53  , fuNrOfGet4PerFee(0)
54  , fuNrOfChannelsPerGet4(0)
55  , fuNrOfChannelsPerFee(0)
56  , fuNrOfGet4(0)
57  , fuNrOfGet4PerGdpb(0)
58  , fuNrOfChannelsPerGdpb(0)
59  , fuNrOfGbtx(0)
60  , fuNrOfModules(0)
61  , fviNrOfRpc()
62  , fviRpcType()
63  , fviRpcSide()
64  , fviModuleId()
65  , fviRpcChUId()
66  , fdTimeOffsetNs(0.0)
67  , fuDiamondDpbIdx(99)
68  , fulCurrentTsIdx(0)
69  , fulCurrentMsIdx(0)
70  , fuCurrentMsSysId(0)
71  , fdTsStartTime(-1.0)
72  , fdTsStopTimeCore(-1.0)
73  , fdMsTime(-1.0)
74  , fuMsIndex(0)
75  , fuCurrentEquipmentId(0)
76  , fuCurrDpbId(0)
77  , fuCurrDpbIdx(0)
78  , fuGet4Id(0)
79  , fuGet4Nr(0)
80  , fvulCurrentEpoch()
81  , fvulCurrentEpochCycle()
82  , fvulCurrentEpochFull()
83  , fdStartTime(0.0)
84  , fdStartTimeMsSz(0.0)
85  , ftStartTimeUnix(std::chrono::steady_clock::now())
86  , fvvmEpSupprBuffer()
87  , fvulGdpbTsMsb()
88  , fvulGdpbTsLsb()
89  , fvulStarTsMsb()
90  , fvulStarTsMid()
91  , fvulGdpbTsFullLast()
92  , fvulStarTsFullLast()
93  , fvuStarTokenLast()
94  , fvuStarDaqCmdLast()
95  , fvuStarTrigCmdLast()
96  , fdRefTime(0.)
97  , fdLastDigiTime(0.)
98  , fdFirstDigiTimeDif(0.)
99  , fdEvTime0(0.)
100  , fhRawTDigEvT0(nullptr)
101  , fhRawTDigRef0(nullptr)
102  , fhRawTDigRef(nullptr)
103  , fhRawTRefDig0(nullptr)
104  , fhRawTRefDig1(nullptr)
105  , fhRawDigiLastDigi(nullptr)
106  , fhRawTotCh()
107  , fhChCount()
108  , fhChCountRemap()
109  , fvbChanThere()
110  , fhChanCoinc()
111  , fhDetChanCoinc(nullptr) {}
112 CbmMcbm2018UnpackerAlgoTof::~CbmMcbm2018UnpackerAlgoTof() {
114  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
115  fvvmEpSupprBuffer[uGdpb].clear();
116  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
117  if (nullptr != fParCList) delete fParCList;
118  if (nullptr != fUnpackPar) delete fUnpackPar;
119 }
120 
121 // -------------------------------------------------------------------------
122 Bool_t CbmMcbm2018UnpackerAlgoTof::Init() {
123  LOG(info) << "Initializing mCBM TOF 2019 unpacker algo";
124 
125  return kTRUE;
126 }
127 void CbmMcbm2018UnpackerAlgoTof::Reset() {}
128 void CbmMcbm2018UnpackerAlgoTof::Finish() {
129  /*
131  LOG(INFO)<<"<I> MS statistics - Good: " << fiMsGood <<", Bad: " << fiMsBad;
132 */
134 }
135 
136 // -------------------------------------------------------------------------
137 Bool_t CbmMcbm2018UnpackerAlgoTof::InitContainers() {
138  LOG(info) << "Init parameter containers for CbmMcbm2018UnpackerAlgoTof";
139 
140  Bool_t initOK = ReInitContainers();
141 
142  return initOK;
143 }
144 Bool_t CbmMcbm2018UnpackerAlgoTof::ReInitContainers() {
145  LOG(info) << "**********************************************";
146  LOG(info) << "ReInit parameter containers for CbmMcbm2018UnpackerAlgoTof";
147 
148  fUnpackPar = (CbmMcbm2018TofPar*) fParCList->FindObject("CbmMcbm2018TofPar");
149  if (nullptr == fUnpackPar) {
150  LOG(ERROR) << " CbmMcbm2018TofPar not found ";
151  return kFALSE;
152  }
153  Bool_t initOK = InitParameters();
154 
155  return initOK;
156 }
157 TList* CbmMcbm2018UnpackerAlgoTof::GetParList() {
158  if (nullptr == fParCList) fParCList = new TList();
159  fUnpackPar = new CbmMcbm2018TofPar("CbmMcbm2018TofPar");
160  fParCList->Add(fUnpackPar);
161 
162  return fParCList;
163 }
164 Bool_t CbmMcbm2018UnpackerAlgoTof::InitParameters() {
165  LOG(INFO) << "InitParameters from " << fUnpackPar;
166  fdMsSizeInNs = fUnpackPar->GetSizeMsInNs();
167 
168  fuNrOfGdpbs = fUnpackPar->GetNrOfGdpbs();
169  LOG(info) << "Nr. of Tof GDPBs: " << fuNrOfGdpbs;
170 
171  fuNrOfFeePerGdpb = fUnpackPar->GetNrOfFeesPerGdpb();
172  LOG(info) << "Nr. of FEES per Tof GDPB: " << fuNrOfFeePerGdpb;
173 
174  fuNrOfGet4PerFee = fUnpackPar->GetNrOfGet4PerFee();
175  LOG(info) << "Nr. of GET4 per Tof FEE: " << fuNrOfGet4PerFee;
176 
177  fuNrOfChannelsPerGet4 = fUnpackPar->GetNrOfChannelsPerGet4();
178  LOG(info) << "Nr. of channels per GET4: " << fuNrOfChannelsPerGet4;
179 
180  fuNrOfChannelsPerFee = fuNrOfGet4PerFee * fuNrOfChannelsPerGet4;
181  LOG(info) << "Nr. of channels per FEE: " << fuNrOfChannelsPerFee;
182 
183  fuNrOfGet4 = fuNrOfGdpbs * fuNrOfFeePerGdpb * fuNrOfGet4PerFee;
184  LOG(info) << "Nr. of GET4s: " << fuNrOfGet4;
185 
186  fuNrOfGet4PerGdpb = fuNrOfFeePerGdpb * fuNrOfGet4PerFee;
187  LOG(info) << "Nr. of GET4s per GDPB: " << fuNrOfGet4PerGdpb;
188 
189  fuNrOfChannelsPerGdpb = fuNrOfGet4PerGdpb * fuNrOfChannelsPerGet4;
190  LOG(info) << "Nr. of channels per GDPB: " << fuNrOfChannelsPerGdpb;
191 
192  fGdpbIdIndexMap.clear();
193  for (UInt_t i = 0; i < fuNrOfGdpbs; ++i) {
194  fGdpbIdIndexMap[fUnpackPar->GetGdpbId(i)] = i;
195  LOG(info) << "GDPB Id of TOF " << i << " : " << std::hex
196  << fUnpackPar->GetGdpbId(i) << std::dec;
197  } // for( UInt_t i = 0; i < fuNrOfGdpbs; ++i )
198 
199  fuNrOfGbtx = fUnpackPar->GetNrOfGbtx();
200  LOG(info) << "Nr. of GBTx: " << fuNrOfGbtx;
201 
202  fviRpcType.resize(fuNrOfGbtx);
203  fviModuleId.resize(fuNrOfGbtx);
204  fviNrOfRpc.resize(fuNrOfGbtx);
205  fviRpcSide.resize(fuNrOfGbtx);
206  for (UInt_t uGbtx = 0; uGbtx < fuNrOfGbtx; ++uGbtx) {
207  fviNrOfRpc[uGbtx] = fUnpackPar->GetNrOfRpc(uGbtx);
208  fviRpcType[uGbtx] = fUnpackPar->GetRpcType(uGbtx);
209  fviRpcSide[uGbtx] = fUnpackPar->GetRpcSide(uGbtx);
210  fviModuleId[uGbtx] = fUnpackPar->GetModuleId(uGbtx);
211  } // for( UInt_t uGbtx = 0; uGbtx < fuNrOfGbtx; ++uGbtx)
212 
213  UInt_t uNrOfChannels = fuNrOfGet4 * fuNrOfChannelsPerGet4;
214  LOG(info) << "Nr. of possible Tof channels: " << uNrOfChannels;
215 
216  // CbmTofDetectorId* fTofId = new CbmTofDetectorId_v14a();
217  fviRpcChUId.resize(uNrOfChannels);
218  UInt_t iCh = 0;
219  for (UInt_t iGbtx = 0; iGbtx < fuNrOfGbtx; ++iGbtx) {
220  switch (fviRpcType[iGbtx]) {
221 
222  case 0: // CBM modules
223  if (fviRpcSide[iGbtx] < 2) { // mTof modules
224  const Int_t RpcMap[5] = {4, 2, 0, 3, 1};
225  for (Int_t iRpc = 0; iRpc < fviNrOfRpc[iGbtx]; iRpc++) {
226  Int_t iStrMax = 32;
227  Int_t iChNext = 1;
228 
229  for (Int_t iStr = 0; iStr < iStrMax; iStr++) {
230  Int_t iStrMap = iStr;
231  Int_t iRpcMap = RpcMap[iRpc];
232 
233  if (fviRpcSide[iGbtx] == 0) iStrMap = 31 - iStr;
234  if (fviModuleId[iGbtx] > -1)
235  fviRpcChUId[iCh] =
236  CbmTofAddress::GetUniqueAddress(fviModuleId[iGbtx],
237  iRpcMap,
238  iStrMap,
239  fviRpcSide[iGbtx],
240  fviRpcType[iGbtx]);
241  else
242  fviRpcChUId[iCh] = 0;
243  // LOG(debug)<<Form("Map Ch %d to Address 0x%08x",iCh,fviRpcChUId[iCh]);
244  iCh += iChNext;
245  }
246  }
247  }
248  break;
249 
250  case 1: // STAR eTOF modules
251  if (fviRpcSide[iGbtx] < 2) { // mTof modules
252  const Int_t RpcMap[3] = {0, 1, 2};
253  for (Int_t iRpc = 0; iRpc < fviNrOfRpc[iGbtx]; iRpc++) {
254  Int_t iStrMax = 32;
255  Int_t iChNext = 1;
256 
257  for (Int_t iStr = 0; iStr < iStrMax; iStr++) {
258  Int_t iStrMap = iStr;
259  Int_t iRpcMap = RpcMap[iRpc];
260 
261  if (fviRpcSide[iGbtx] == 0) iStrMap = 31 - iStr;
262  if (fviModuleId[iGbtx] > -1)
263  fviRpcChUId[iCh] =
264  CbmTofAddress::GetUniqueAddress(fviModuleId[iGbtx],
265  iRpcMap,
266  iStrMap,
267  fviRpcSide[iGbtx],
268  fviRpcType[iGbtx]);
269  else
270  fviRpcChUId[iCh] = 0;
271  // LOG(DEBUG)<<Form("Map Ch %d to Address 0x%08x",iCh,fviRpcChUId[iCh]);
272  iCh += iChNext;
273  }
274  }
275  }
276  iCh += 64;
277  break;
278 
280  case 5: {
281  LOG(info) << " Map diamond at GBTX - iCh = " << iCh;
282  for (UInt_t uFee = 0; uFee < fUnpackPar->GetNrOfFeePerGbtx(); ++uFee) {
283  for (UInt_t uCh = 0; uCh < fUnpackPar->GetNrOfChannelsPerFee();
284  ++uCh) {
285  /*
286  if( uFee < 4 && 0 == uCh ) {
287  fviRpcChUId[ iCh ] = CbmTofAddress::GetUniqueAddress(
288  fviModuleId[iGbtx],
289  0, uFee + 4 * fviRpcSide[iGbtx],
290  0, fviRpcType[iGbtx] );
291  LOG(info) << Form( "Map T0 Ch %d to Address 0x%08x", iCh, fviRpcChUId[iCh] );
292  }
293  else fviRpcChUId[ iCh ] = 0;
294 */
295 
297  if (0 == uFee && 1 == fviNrOfRpc[iGbtx]) {
298  switch (uCh % 8) {
299  case 0:
300  case 2:
301  case 4: {
306  UInt_t uChannelT0 = uCh / 8 + 4 * fviRpcSide[iGbtx];
307  fviRpcChUId[iCh] = CbmTofAddress::GetUniqueAddress(
308  fviModuleId[iGbtx], 0, uChannelT0, 0, fviRpcType[iGbtx]);
309  LOG(info) << Form("T0 channel: %u from GBTx %2u Fee %2u "
310  "Channel %2u, indx %d address %08x",
311  uChannelT0,
312  iGbtx,
313  uFee,
314  uCh,
315  iCh,
316  fviRpcChUId[iCh]);
317  break;
318  } // Valid T0 channel
319  default: {
320  fviRpcChUId[iCh] = 0;
321  } // Invalid T0 channel
322  } // switch( uCh % 4 )
323  } // if( 0 == uFee )
324 
325  iCh++;
326  } // for( UInt_t uCh = 0; uCh < fUnpackPar->GetNrOfChannelsPerFee(); ++uCh )
327  } // for( UInt_t uFee = 0; uFee < fUnpackPar->GetNrOfFeePerGbtx(); ++uFee )
328  } // if( 5 == fviRpcType[iGbtx] )
329  break;
330 
331  case 78: // cern-20-gap + ceramic module
332  {
333  LOG(info) << " Map CERN 20 gap at GBTX - iCh = " << iCh;
334  const Int_t StrMap[32] = {0, 1, 2, 3, 4, 31, 5, 6, 7, 30, 8,
335  9, 10, 29, 11, 12, 13, 14, 28, 15, 16, 17,
336  18, 27, 26, 25, 24, 23, 22, 21, 20, 19};
337  Int_t iModuleId = 0;
338  Int_t iModuleType = 7;
339  Int_t iRpcMap = 0;
340  for (Int_t iFeet = 0; iFeet < 2; iFeet++) {
341  for (Int_t iStr = 0; iStr < 32; iStr++) {
342  Int_t iStrMap = 31 - 12 - StrMap[iStr];
343  Int_t iSideMap = iFeet;
344  if (iStrMap < 20)
345  fviRpcChUId[iCh] = CbmTofAddress::GetUniqueAddress(
346  iModuleId, iRpcMap, iStrMap, iSideMap, iModuleType);
347  else
348  fviRpcChUId[iCh] = 0;
349  iCh++;
350  }
351  }
352 
353  LOG(info) << " Map end CERN 20 gap at GBTX - iCh = " << iCh;
354  }
355  // fall through is intended
356  case 8: // ceramics
357  {
358  Int_t iModuleId = 0;
359  Int_t iModuleType = 8;
360  for (Int_t iRpc = 0; iRpc < 8; iRpc++) {
361  fviRpcChUId[iCh] = CbmTofAddress::GetUniqueAddress(
362  iModuleId, 7 - iRpc, 0, 0, iModuleType);
363  iCh++;
364  }
365  iCh += (24 + 2 * 32);
366  }
367 
368  LOG(info) << " Map end ceramics box at GBTX - iCh = " << iCh;
369  break;
370 
371  case 9: // Star2 boxes
372  {
373  LOG(info) << " Map Star2 box at GBTX - iCh = " << iCh;
374  const Int_t iRpc[5] = {1, -1, 1, 0, 0};
375  const Int_t iSide[5] = {1, -1, 0, 1, 0};
376  for (Int_t iFeet = 0; iFeet < 5; iFeet++) {
377  for (Int_t iStr = 0; iStr < 32; iStr++) {
378  Int_t iStrMap = iStr;
379  Int_t iRpcMap = iRpc[iFeet];
380  Int_t iSideMap = iSide[iFeet];
381  if (iSideMap == 0) iStrMap = 31 - iStr;
382  if (iSideMap > -1)
383  fviRpcChUId[iCh] =
384  CbmTofAddress::GetUniqueAddress(fviModuleId[iGbtx],
385  iRpcMap,
386  iStrMap,
387  iSideMap,
388  fviRpcType[iGbtx]);
389  else
390  fviRpcChUId[iCh] = 0;
391  iCh++;
392  }
393  }
394  } break;
395 
396  case 6: // Buc box
397  {
398  LOG(info) << " Map Buc box at GBTX - iCh = " << iCh;
399  const Int_t iRpc[5] = {0, -1, 0, 1, 1};
400  const Int_t iSide[5] = {1, -1, 0, 1, 0};
401  for (Int_t iFeet = 0; iFeet < 5; iFeet++) {
402  for (Int_t iStr = 0; iStr < 32; iStr++) {
403  Int_t iStrMap = iStr;
404  Int_t iRpcMap = iRpc[iFeet];
405  Int_t iSideMap = iSide[iFeet];
406  switch (fviRpcSide[iGbtx]) {
407  case 0:; break;
408  case 1: // HD cosmic 2019, Buc2018, v18n
409  iStrMap = 31 - iStr;
410  iRpcMap = 1 - iRpcMap;
411  break;
412  case 2: // v18m_cosmicHD
413  // iStrMap=31-iStr;
414  iSideMap = 1 - iSideMap;
415  break;
416  case 3:
417  iStrMap = 31 - iStr;
418  iRpcMap = 1 - iRpcMap;
419  iSideMap = 1 - iSideMap;
420  break;
421  case 4: // HD cosmic 2019, Buc2018, v18o
422  iRpcMap = 1 - iRpcMap;
423  break;
424  case 5: // HD cosmic 2020, Buc2018, v20a
425  iStrMap = 31 - iStr;
426  break;
427  default:;
428  }
429  if (iSideMap > -1)
430  fviRpcChUId[iCh] =
431  CbmTofAddress::GetUniqueAddress(fviModuleId[iGbtx],
432  iRpcMap,
433  iStrMap,
434  iSideMap,
435  fviRpcType[iGbtx]);
436  else
437  fviRpcChUId[iCh] = 0;
438 
439  iCh++;
440  }
441  }
442  } break;
443 
444  case -1:
445  LOG(info) << " Found unused GBTX link at iCh = " << iCh;
446  iCh += 160;
447  break;
448 
449  default: LOG(error) << "Invalid Tof Type specifier ";
450  }
451  }
452  TString sPrintout = "";
453  for (UInt_t uCh = 0; uCh < uNrOfChannels; ++uCh) {
454  if (0 == uCh % 8) sPrintout += "\n";
455  if (0 == uCh % fuNrOfChannelsPerGdpb)
456  sPrintout += Form("\n Gdpb %u\n", uCh / fuNrOfChannelsPerGdpb);
457  sPrintout += Form(" 0x%08x", fviRpcChUId[uCh]);
458  } // for( UInt_t i = 0; i < uNrOfChannels; ++i)
459  LOG(info) << sPrintout;
460 
461  // Request masks
462  /*
463  LOG(INFO) << " Load " << fUnpackPar->GetNrReqPattern() << " GET4 Request masks for " << fuNrOfGdpbs << " Gdpbs ";
464  if(fUnpackPar->GetNrReqPattern()>0){
465  bGdpbOK.resize(fuNrOfGdpbs);
466  Pat_Request.resize(fuNrOfGdpbs);
467  Int_t iInd=0;
468  for(Int_t iGdpb=0; iGdpb<fuNrOfGdpbs; iGdpb++) {
469  bGdpbOK[iGdpb]=kTRUE;
470  Pat_Request[iGdpb].resize(fUnpackPar->GetNrReqPattern());
471  for (Int_t iPat=0; iPat<fUnpackPar->GetNrReqPattern(); iPat++) {
472  UInt_t PatGet4=fUnpackPar->GetReqPattern(iInd++);
473  for( UInt_t uBit = 0; uBit < 32; ++uBit ) {
474  if( ( PatGet4 >> uBit ) & 0x1 ) {
475  UInt_t iGet4=iPat*32+uBit;
476  UInt_t uElink=fUnpackPar->Get4IdxToElinkIdx(iGet4);
477  UInt_t ubit=uElink%32;
478  UInt_t iEPat=(uElink-ubit)/32;
479  Pat_Request[iGdpb][iEPat] |= (0x1 << ubit);
480  }
481  }
482  }
483  }
484  }
485  */
487  fvulCurrentEpoch.resize(fuNrOfGdpbs, 0);
488  fvulCurrentEpochCycle.resize(fuNrOfGdpbs, 0);
489  fvulCurrentEpochFull.resize(fuNrOfGdpbs, 0);
490 
492  fvulGdpbTsMsb.resize(fuNrOfGdpbs);
493  fvulGdpbTsLsb.resize(fuNrOfGdpbs);
494  fvulStarTsMsb.resize(fuNrOfGdpbs);
495  fvulStarTsMid.resize(fuNrOfGdpbs);
496  fvulGdpbTsFullLast.resize(fuNrOfGdpbs);
497  fvulStarTsFullLast.resize(fuNrOfGdpbs);
498  fvuStarTokenLast.resize(fuNrOfGdpbs);
499  fvuStarDaqCmdLast.resize(fuNrOfGdpbs);
500  fvuStarTrigCmdLast.resize(fuNrOfGdpbs);
501  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb) {
502  fvulGdpbTsMsb[uGdpb] = 0;
503  fvulGdpbTsLsb[uGdpb] = 0;
504  fvulStarTsMsb[uGdpb] = 0;
505  fvulStarTsMid[uGdpb] = 0;
506  fvulGdpbTsFullLast[uGdpb] = 0;
507  fvulStarTsFullLast[uGdpb] = 0;
508  fvuStarTokenLast[uGdpb] = 0;
509  fvuStarDaqCmdLast[uGdpb] = 0;
510  fvuStarTrigCmdLast[uGdpb] = 0;
511  } // for (Int_t iGdpb = 0; iGdpb < fuNrOfGdpbs; ++iGdpb)
512 
514  fvvmEpSupprBuffer.resize(fuNrOfGdpbs);
515 
516  return kTRUE;
517 }
518 // -------------------------------------------------------------------------
519 
520 void CbmMcbm2018UnpackerAlgoTof::AddMsComponentToList(size_t component,
521  UShort_t usDetectorId) {
523  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsList.size(); ++uCompIdx)
524  if (component == fvMsComponentsList[uCompIdx]) return;
525 
527  fvMsComponentsList.push_back(component);
528 
529  LOG(info) << "CbmMcbm2018UnpackerAlgoTof::AddMsComponentToList => Component "
530  << component << " with detector ID 0x" << std::hex << usDetectorId
531  << std::dec << " added to list";
532 }
533 // -------------------------------------------------------------------------
534 
535 Bool_t CbmMcbm2018UnpackerAlgoTof::ProcessTs(const fles::Timeslice& ts) {
536  fulCurrentTsIdx = ts.index();
537  fdTsStartTime = static_cast<Double_t>(ts.descriptor(0, 0).idx);
538  LOG(DEBUG) << "ProcessTs " << fulCurrentTsIdx;
539 
541  if (0 == fulCurrentTsIdx) { return kTRUE; } // if( 0 == fulCurrentTsIdx )
542 
544  if (-1.0 == fdTsCoreSizeInNs) {
545  fuNbCoreMsPerTs = ts.num_core_microslices();
546  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
547  fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
548  fdTsFullSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs + fuNbOverMsPerTs);
549  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
550  << " Core MS and " << fuNbOverMsPerTs
551  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
552  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
553 
555  fuNbMsLoop = fuNbCoreMsPerTs;
556  if (kFALSE == fbIgnoreOverlapMs) fuNbMsLoop += fuNbOverMsPerTs;
557  LOG(info) << "In each TS " << fuNbMsLoop << " MS will be looped over";
558  } // if( -1.0 == fdTsCoreSizeInNs )
559 
561  fdTsStopTimeCore = fdTsStartTime + fdTsCoreSizeInNs;
562  // LOG(info) << Form( "TS %5d Start %12f Stop %12f", fulCurrentTsIdx, fdTsStartTime, fdTsStopTimeCore );
563 
565  for (fuMsIndex = 0; fuMsIndex < fuNbMsLoop; fuMsIndex++) {
567  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size();
568  ++uMsCompIdx) {
569  UInt_t uMsComp = fvMsComponentsList[uMsCompIdx];
570 
571  if (kFALSE == ProcessMs(ts, uMsComp, fuMsIndex)) {
572  LOG(error) << "Failed to process ts " << fulCurrentTsIdx << " MS "
573  << fuMsIndex << " for component " << uMsComp;
574  return kFALSE;
575  } // if( kFALSE == ProcessMs( ts, uMsCompIdx, fuMsIndex ) )
576  } // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
577  } // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
578 
580  if (fbMonitorMode) {
581  if (kFALSE == FillHistograms()) {
582  LOG(error) << "Failed to fill histos in ts " << fulCurrentTsIdx;
583  return kFALSE;
584  } // if( kFALSE == FillHistograms() )
585 
586  fhVectorSize->Fill(fulCurrentTsIdx, fDigiVect.size());
587  fhVectorCapacity->Fill(fulCurrentTsIdx, fDigiVect.capacity());
588  } // if( fbMonitorMode )
589 
590  if (fuTsMaxVectorSize < fDigiVect.size()) {
591  fuTsMaxVectorSize = fDigiVect.size() * fdCapacityIncFactor;
592  fDigiVect.shrink_to_fit();
593  fDigiVect.reserve(fuTsMaxVectorSize);
594  } // if( fuTsMaxVectorSize < fDigiVect.size() )
595  /*
596  if(!bEnableOut) {
597  LOG(DEBUG) << "Ts "<< fulCurrentTsIdx << " removed ";
598  fiMsBad++;
599  fDigiVect.clear();
600  }else {
601  LOG(DEBUG) << "Ts "<< fulCurrentTsIdx << " accepted ";
602  fiMsGood++;
603  }
604 */
606  sort(fDigiVect.begin(),
607  fDigiVect.end(),
608  [](const CbmTofDigi& a, const CbmTofDigi& b) -> bool {
609  return a.GetTime() < b.GetTime();
610  });
611 
612  return kTRUE;
613 }
614 
615 Bool_t CbmMcbm2018UnpackerAlgoTof::ProcessMs(const fles::Timeslice& ts,
616  size_t uMsCompIdx,
617  size_t uMsIdx) {
618  auto msDescriptor = ts.descriptor(uMsCompIdx, uMsIdx);
619  fuCurrentEquipmentId = msDescriptor.eq_id;
620  const uint8_t* msContent =
621  reinterpret_cast<const uint8_t*>(ts.content(uMsCompIdx, uMsIdx));
622 
623  uint32_t uSize = msDescriptor.size;
624  fulCurrentMsIdx = msDescriptor.idx;
625  // Double_t dMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
626  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
627  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
628 
629  if (0 == fvbMaskedComponents.size())
630  fvbMaskedComponents.resize(ts.num_components(), kFALSE);
631 
632  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
633  // fuCurrDpbIdx = fDpbIdIndexMap[ fuCurrDpbId ];
634 
636  auto it = fGdpbIdIndexMap.find(fuCurrDpbId);
637  if (it == fGdpbIdIndexMap.end()) {
638  if (kFALSE == fvbMaskedComponents[uMsCompIdx]) {
639  LOG(info)
640  << "---------------------------------------------------------------";
641  LOG(info) << FormatMsHeaderPrintout(msDescriptor);
642  LOG(warning) << "Could not find the gDPB index for AFCK id 0x" << std::hex
643  << fuCurrDpbId << std::dec << " in timeslice "
644  << fulCurrentTsIdx << " in microslice " << uMsIdx
645  << " component " << uMsCompIdx << "\n"
646  << "If valid this index has to be added in the TOF "
647  "parameter file in the DbpIdArray field";
648  fvbMaskedComponents[uMsCompIdx] = kTRUE;
649  } // if( kFALSE == fvbMaskedComponents[ uMsComp ] )
650  else
651  return kTRUE;
652 
655 
656  return kFALSE;
657  } // if( it == fGdpbIdIndexMap.end() )
658  else
659  fuCurrDpbIdx = fGdpbIdIndexMap[fuCurrDpbId];
660 
661  fuCurrentMsSysId = static_cast<unsigned int>(msDescriptor.sys_id);
662 
663  // If not integer number of message in input buffer, print warning/error
664  if (0 != (uSize % sizeof(gdpbv100::Message)))
665  LOG(error) << "The input microslice buffer does NOT "
666  << "contain only complete gDPB messages!";
667 
668  // Compute the number of complete messages in the input microslice buffer
669  uint32_t uNbMessages =
670  (uSize - (uSize % sizeof(gdpbv100::Message))) / sizeof(gdpbv100::Message);
671 
672  // Prepare variables for the loop on contents
673  Int_t messageType = -111;
674  const uint64_t* pInBuff =
675  reinterpret_cast<const uint64_t*>(msContent); // for epoch cycle
676  const gdpbv100::Message* pMess =
677  reinterpret_cast<const gdpbv100::Message*>(pInBuff);
678  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
680  if (0 == uIdx) {
681  ProcessEpochCycle(pInBuff[uIdx]);
682  continue;
683  } // if( 0 == uIdx )
684 
686  messageType = pMess[uIdx].getMessageType();
687 
688  fuGet4Id = fUnpackPar->ElinkIdxToGet4Idx(pMess[uIdx].getGdpbGenChipId());
689  if (fuDiamondDpbIdx == fuCurrDpbIdx || 0x90 == fuCurrentMsSysId)
690  fuGet4Id = pMess[uIdx].getGdpbGenChipId();
691  fuGet4Nr = (fuCurrDpbIdx * fuNrOfGet4PerGdpb) + fuGet4Id;
692 
693  if (fuNrOfGet4PerGdpb <= fuGet4Id && !pMess[uIdx].isStarTrigger()
694  && (gdpbv100::kuChipIdMergedEpoch != fuGet4Id))
695  LOG(warning) << "Message with Get4 ID too high: " << fuGet4Id << " VS "
696  << fuNrOfGet4PerGdpb << " set in parameters.";
697 
698  /*
699  if( 1 == uIdx && gdpbv100::MSG_EPOCH != messageType )
700  LOG(warning) << " in timeslice " << fulCurrentTsIdx
701  << " in microslice " << fuMsIndex
702  << " component " << uMsCompIdx
703  << " first message is not an epoch: type " << messageType;
704 
705  if( uNbMessages - 1 == uIdx && gdpbv100::MSG_EPOCH != messageType )
706  LOG(warning) << " in timeslice " << fulCurrentTsIdx
707  << " in microslice " << fuMsIndex
708  << " component " << uMsCompIdx
709  << " last message is not an epoch: type " << messageType;
710 */
717  if (1 == uIdx && gdpbv100::MSG_EPOCH != messageType) {
718  LOG(debug) << " CbmMcbm2018UnpackerAlgoTof ==> In timeslice "
719  << fulCurrentTsIdx << " in microslice " << fuMsIndex
720  << " component " << uMsCompIdx
721  << " first message is not an epoch: type " << messageType
722  << " -> It will be ignored! ";
723  continue;
724  } // if( 1 == uIdx && gdpbv100::MSG_EPOCH != messageType )
725 
726  switch (messageType) {
727  case gdpbv100::MSG_HIT: {
728  if (pMess[uIdx].getGdpbHitIs24b()) {
729  LOG(error) << "This event builder does not support 24b hit message!!!"
730  << " Message " << uIdx << "/" << uNbMessages << " 0x"
731  << FormatHexPrintout(pMess[uIdx].getData(), '0', 16);
732  continue;
733  } // if( getGdpbHitIs24b() )
734  else {
735  fvvmEpSupprBuffer[fuCurrDpbIdx].push_back(pMess[uIdx]);
736  } // else of if( getGdpbHitIs24b() )
737  break;
738  } // case gdpbv100::MSG_HIT:
739  case gdpbv100::MSG_EPOCH: {
740  if (gdpbv100::kuChipIdMergedEpoch == fuGet4Id) {
741  ProcessEpoch(pMess[uIdx], uIdx);
742  } // if this epoch message is a merged one valid for all chips
743  else {
745  LOG(debug2) << "This event builder does not support unmerged epoch "
746  "messages!!!.";
747  continue;
748  } // if single chip epoch message
749  break;
750  } // case gdpbv100::MSG_EPOCH:
751  case gdpbv100::MSG_SLOWC: {
752  fvvmEpSupprBuffer[fuCurrDpbIdx].push_back(pMess[uIdx]);
753  break;
754  } // case gdpbv100::MSG_SLOWC:
755  case gdpbv100::MSG_SYST: {
756  fvvmEpSupprBuffer[fuCurrDpbIdx].push_back(pMess[uIdx]);
757  break;
758  } // case gdpbv100::MSG_SYST:
759  case gdpbv100::MSG_STAR_TRI_A:
760  case gdpbv100::MSG_STAR_TRI_B:
761  case gdpbv100::MSG_STAR_TRI_C:
762  case gdpbv100::MSG_STAR_TRI_D: {
763  ProcessStarTrigger(pMess[uIdx]);
764 
767  /*
768  if( gdpbv100::MSG_STAR_TRI_A == messageType )
769  {
770  } // if( gdpbv100::MSG_STAR_TRI_A == messageType )
771 */
772  break;
773  } // case gdpbv100::MSG_STAR_TRI_A-D
774  default:
775  LOG(error) << "Message type " << std::hex << std::setw(2)
776  << static_cast<uint16_t>(messageType)
777  << " not included in Get4 unpacker.";
778  } // switch( mess.getMessageType() )
779  } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
780 
786  ProcessEndOfMsEpoch();
787 
788  return kTRUE;
789 }
790 
791 // -------------------------------------------------------------------------
792 void CbmMcbm2018UnpackerAlgoTof::ProcessEpochCycle(
793  const uint64_t& ulCycleData) {
794  ULong64_t ulEpochCycleVal = ulCycleData & gdpbv100::kulEpochCycleFieldSz;
795 
796  if (!(ulEpochCycleVal == fvulCurrentEpochCycle[fuCurrDpbIdx]
797  || ulEpochCycleVal == fvulCurrentEpochCycle[fuCurrDpbIdx] + 1)
798  && 0 < fulCurrentMsIdx) {
799  LOG(warning) << "CbmMcbm2018UnpackerAlgoTof::ProcessEpochCycle => "
800  << " Missmatch in epoch cycles detected for Gdpb "
801  << fuCurrDpbIdx
802  << ", probably fake cycles due to epoch index corruption! "
803  << Form(" Current cycle 0x%09llX New cycle 0x%09llX",
804  fvulCurrentEpochCycle[fuCurrDpbIdx],
805  ulEpochCycleVal);
806  } // if epoch cycle did not stay constant or increase by exactly 1, except if first MS of the TS
807  if (ulEpochCycleVal != fvulCurrentEpochCycle[fuCurrDpbIdx]) {
808  LOG(info) << "CbmMcbm2018UnpackerAlgoTof::ProcessEpochCycle => "
809  << " New epoch cycle for Gdpb " << fuCurrDpbIdx
810  << Form(": Current cycle 0x%09llX New cycle 0x%09llX",
811  fvulCurrentEpochCycle[fuCurrDpbIdx],
812  ulEpochCycleVal);
813  } // if( ulEpochCycleVal != fvulCurrentEpochCycle[fuCurrDpbIdx] )
814  fvulCurrentEpochCycle[fuCurrDpbIdx] = ulEpochCycleVal;
815 
816  return;
817 }
818 void CbmMcbm2018UnpackerAlgoTof::ProcessEpoch(const gdpbv100::Message& mess,
819  uint32_t /*uMesgIdx*/) {
820  ULong64_t ulEpochNr = mess.getGdpbEpEpochNb();
821  /*
822  if( ( 6 == fulCurrentTsIdx && 2 == fuCurrDpbIdx ) ||
823  ( 57 == fulCurrentTsIdx && 0 == fuCurrDpbIdx ) )
824  LOG(info) << Form( "Gdpb %d TS %3llu MS %3u Msg %4u Ep %08llx",
825  fuCurrDpbIdx, fulCurrentTsIdx, fuMsIndex, uMesgIdx, ulEpochNr );
826 
827  if( !( ulEpochNr == fvulCurrentEpoch[ fuCurrDpbIdx ] + 1 ||
828 // ulEpochNr == fvulCurrentEpoch[ fuCurrDpbIdx ] || // For the fake "closing epoch"
829  ( 0 == ulEpochNr && gdpbv100::kuEpochCounterSz == fvulCurrentEpoch[ fuCurrDpbIdx ] )
830  )
831  )
832  {
833  Int_t iDiff = ulEpochNr;
834  iDiff -= fvulCurrentEpoch[ fuCurrDpbIdx ];
835  LOG(info) << "CbmMcbm2018UnpackerAlgoTof::ProcessEpoch => "
836  << " Non consecutive epochs for Gdpb " << fuCurrDpbIdx
837  << " in TS " << fulCurrentTsIdx
838  << " MS " << fuMsIndex
839  << " Msg " << uMesgIdx
840  << Form( " : old Ep %08llx new Ep %08llx Diff %d ", fvulCurrentEpoch[ fuCurrDpbIdx ], ulEpochNr, iDiff )
841  << std::endl;
842  } // if epoch neither +1 nor equal nor overflow
843 */
844  /*
847  if( 0 < fvulCurrentEpoch[ fuCurrDpbIdx ] && ulEpochNr < fvulCurrentEpoch[ fuCurrDpbIdx ] &&
848  1 < uMesgIdx )
849  {
850  LOG(info) << "CbmMcbm2018UnpackerAlgoTof::ProcessEpoch => "
851  << " New epoch cycle for Gdpb " << fuCurrDpbIdx
852  << Form( ": Current cycle 0x%09llX New cycle 0x%09llX", fvulCurrentEpochCycle[fuCurrDpbIdx], fvulCurrentEpochCycle[fuCurrDpbIdx] + 1 )
853  << Form( "(old Ep %08llx new Ep %08llx)", fvulCurrentEpoch[ fuCurrDpbIdx ], ulEpochNr )
854  << std::endl;
855  fvulCurrentEpochCycle[ fuCurrDpbIdx ]++;
856  } // if( 0 < fvulCurrentEpoch[ fuCurrDpbIdx ] && ulEpochNr < fvulCurrentEpoch[ fuCurrDpbIdx ] && 1 < uMesgIdx)
857 */
858  fvulCurrentEpoch[fuCurrDpbIdx] = ulEpochNr;
859  fvulCurrentEpochFull[fuCurrDpbIdx] =
860  ulEpochNr
861  + (gdpbv100::kuEpochCounterSz + 1) * fvulCurrentEpochCycle[fuCurrDpbIdx];
862 
863  /*
866  if( 0 < ulEpochNr )
867  mess.setGdpbEpEpochNb( ulEpochNr - 1 );
868  else mess.setGdpbEpEpochNb( gdpbv100::kuEpochCounterSz );
869 */
871  ProcessEpSupprBuffer();
872 }
873 void CbmMcbm2018UnpackerAlgoTof::ProcessEndOfMsEpoch() {
875  ULong64_t ulEpochNr =
876  (fvulCurrentEpoch[fuCurrDpbIdx] + 1) % gdpbv100::kuEpochCounterSz;
877 
878  if (0 < fvulCurrentEpoch[fuCurrDpbIdx]
879  && ulEpochNr < fvulCurrentEpoch[fuCurrDpbIdx]) {
880  LOG(info) << "CbmMcbm2018UnpackerAlgoTof::ProcessEndOfMsEpoch => "
881  << " New epoch cycle for Gdpb " << fuCurrDpbIdx
882  << Form(": Current cycle 0x%09llX New cycle 0x%09llX",
883  fvulCurrentEpochCycle[fuCurrDpbIdx],
884  fvulCurrentEpochCycle[fuCurrDpbIdx] + 1)
885  << Form("(old Ep %08llx new Ep %08llx)",
886  fvulCurrentEpoch[fuCurrDpbIdx],
887  ulEpochNr);
888  fvulCurrentEpochCycle[fuCurrDpbIdx]++;
889  } // if( 0 < fvulCurrentEpoch[ fuCurrDpbIdx ] && ulEpochNr < fvulCurrentEpoch[ fuCurrDpbIdx ] )
890  /*
891  fvulCurrentEpoch[ fuCurrDpbIdx ] = ulEpochNr;
892  fvulCurrentEpochFull[ fuCurrDpbIdx ] = ulEpochNr + ( gdpbv100::kuEpochCounterSz + 1 ) * fvulCurrentEpochCycle[ fuCurrDpbIdx ];
893 */
894  fvulCurrentEpochFull[fuCurrDpbIdx] =
895  ulEpochNr
896  + (gdpbv100::kuEpochCounterSz + 1) * fvulCurrentEpochCycle[fuCurrDpbIdx];
897 
899  ProcessEpSupprBuffer();
900 }
901 void CbmMcbm2018UnpackerAlgoTof::ProcessStarTrigger(
902  const gdpbv100::Message& mess) {
903  Int_t iMsgIndex = mess.getStarTrigMsgIndex();
904 
905  switch (iMsgIndex) {
906  case 0: fvulGdpbTsMsb[fuCurrDpbIdx] = mess.getGdpbTsMsbStarA(); break;
907  case 1:
908  fvulGdpbTsLsb[fuCurrDpbIdx] = mess.getGdpbTsLsbStarB();
909  fvulStarTsMsb[fuCurrDpbIdx] = mess.getStarTsMsbStarB();
910  break;
911  case 2: fvulStarTsMid[fuCurrDpbIdx] = mess.getStarTsMidStarC(); break;
912  case 3: {
913  ULong64_t ulNewGdpbTsFull =
914  (fvulGdpbTsMsb[fuCurrDpbIdx] << 24) + (fvulGdpbTsLsb[fuCurrDpbIdx]);
915  ULong64_t ulNewStarTsFull = (fvulStarTsMsb[fuCurrDpbIdx] << 48)
916  + (fvulStarTsMid[fuCurrDpbIdx] << 8)
917  + mess.getStarTsLsbStarD();
918  UInt_t uNewToken = mess.getStarTokenStarD();
919  UInt_t uNewDaqCmd = mess.getStarDaqCmdStarD();
920  UInt_t uNewTrigCmd = mess.getStarTrigCmdStarD();
921 
922  if ((uNewToken == fvuStarTokenLast[fuCurrDpbIdx])
923  && (ulNewGdpbTsFull == fvulGdpbTsFullLast[fuCurrDpbIdx])
924  && (ulNewStarTsFull == fvulStarTsFullLast[fuCurrDpbIdx])
925  && (uNewDaqCmd == fvuStarDaqCmdLast[fuCurrDpbIdx])
926  && (uNewTrigCmd == fvuStarTrigCmdLast[fuCurrDpbIdx])) {
927  UInt_t uTrigWord = ((fvuStarTrigCmdLast[fuCurrDpbIdx] & 0x00F) << 16)
928  + ((fvuStarDaqCmdLast[fuCurrDpbIdx] & 0x00F) << 12)
929  + ((fvuStarTokenLast[fuCurrDpbIdx] & 0xFFF));
930  LOG(warning) << "Possible error: identical STAR tokens found twice in "
931  "a row => ignore 2nd! "
932  << " TS " << fulCurrentTsIdx << " gDBB #" << fuCurrDpbIdx
933  << " "
934  << Form("token = %5u ", fvuStarTokenLast[fuCurrDpbIdx])
935  << Form("gDPB ts = %12llu ",
936  fvulGdpbTsFullLast[fuCurrDpbIdx])
937  << Form("STAR ts = %12llu ",
938  fvulStarTsFullLast[fuCurrDpbIdx])
939  << Form("DAQ cmd = %2u ", fvuStarDaqCmdLast[fuCurrDpbIdx])
940  << Form("TRG cmd = %2u ", fvuStarTrigCmdLast[fuCurrDpbIdx])
941  << Form("TRG Wrd = %5x ", uTrigWord);
942  return;
943  } // if exactly same message repeated
944 
945  // GDPB TS counter reset detection
946  if (ulNewGdpbTsFull < fvulGdpbTsFullLast[fuCurrDpbIdx])
947  LOG(debug) << "Probable reset of the GDPB TS: old = "
948  << Form("%16llu", fvulGdpbTsFullLast[fuCurrDpbIdx])
949  << " new = " << Form("%16llu", ulNewGdpbTsFull)
950  << " Diff = -"
951  << Form("%8llu",
952  fvulGdpbTsFullLast[fuCurrDpbIdx] - ulNewGdpbTsFull)
953  << " GDPB #" << Form("%2u", fuCurrDpbIdx);
954 
955  // STAR TS counter reset detection
956  if (ulNewStarTsFull < fvulStarTsFullLast[fuCurrDpbIdx])
957  LOG(debug) << "Probable reset of the STAR TS: old = "
958  << Form("%16llu", fvulStarTsFullLast[fuCurrDpbIdx])
959  << " new = " << Form("%16llu", ulNewStarTsFull)
960  << " Diff = -"
961  << Form("%8llu",
962  fvulStarTsFullLast[fuCurrDpbIdx] - ulNewStarTsFull)
963  << " GDPB #" << Form("%2u", fuCurrDpbIdx);
964 
966  if (fulCurrentMsIdx < fuNbCoreMsPerTs) {
967  fvulGdpbTsFullLast[fuCurrDpbIdx] = ulNewGdpbTsFull;
968  fvulStarTsFullLast[fuCurrDpbIdx] = ulNewStarTsFull;
969  fvuStarTokenLast[fuCurrDpbIdx] = uNewToken;
970  fvuStarDaqCmdLast[fuCurrDpbIdx] = uNewDaqCmd;
971  fvuStarTrigCmdLast[fuCurrDpbIdx] = uNewTrigCmd;
972  } // if( fuCurrentMs < fuNbCoreMsPerTs )
973 
975  /*
976  Double_t dTot = 1.;
977  Double_t dTime = fulGdpbTsFullLast * 6.25;
978  if( 0. == fdFirstDigiTimeDif && 0. != fdLastDigiTime )
979  {
980  fdFirstDigiTimeDif = dTime - fdLastDigiTime;
981  LOG(info) << "Reference fake digi time shift initialized to " << fdFirstDigiTimeDif;
982  } // if( 0. == fdFirstDigiTimeDif && 0. != fdLastDigiTime )
983 
984  // dTime -= fdFirstDigiTimeDif;
985 
986  LOG(debug) << "Insert fake digi with time " << dTime << ", Tot " << dTot;
987  fhRawTRefDig0->Fill( dTime - fdLastDigiTime);
988  fhRawTRefDig1->Fill( dTime - fdLastDigiTime);
989 
990  fDigi = new CbmTofDigiExp(0x00005006, dTime, dTot); // fake start counter signal
991  fBuffer->InsertData<CbmTofDigi>(fDigi);
992 */
993  break;
994  } // case 3
995  default: LOG(error) << "Unknown Star Trigger messageindex: " << iMsgIndex;
996  } // switch( iMsgIndex )
997 }
998 // -------------------------------------------------------------------------
999 void CbmMcbm2018UnpackerAlgoTof::ProcessEpSupprBuffer() {
1000  Int_t iBufferSize = fvvmEpSupprBuffer[fuCurrDpbIdx].size();
1001 
1002  if (0 == iBufferSize) return;
1003 
1004  LOG(debug) << "Now processing stored messages for for gDPB " << fuCurrDpbIdx
1005  << " with epoch number " << (fvulCurrentEpoch[fuCurrDpbIdx] - 1);
1006 
1009  // std::stable_sort( fvvmEpSupprBuffer[ fuCurrDpbIdx ].begin(), fvvmEpSupprBuffer[ fuCurrDpbIdx ].end() );
1010 
1012  ULong64_t ulCurEpochGdpbGet4 = fvulCurrentEpochFull[fuCurrDpbIdx];
1013 
1015  if (0 == ulCurEpochGdpbGet4) return;
1016 
1018  ulCurEpochGdpbGet4--;
1019 
1020  Int_t messageType = -111;
1021  for (Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++) {
1022  messageType = fvvmEpSupprBuffer[fuCurrDpbIdx][iMsgIdx].getMessageType();
1023 
1024  fuGet4Id = fUnpackPar->ElinkIdxToGet4Idx(
1025  fvvmEpSupprBuffer[fuCurrDpbIdx][iMsgIdx].getGdpbGenChipId());
1026  if (fuDiamondDpbIdx == fuCurrDpbIdx || 0x90 == fuCurrentMsSysId)
1027  fuGet4Id = fvvmEpSupprBuffer[fuCurrDpbIdx][iMsgIdx].getGdpbGenChipId();
1028  fuGet4Nr = (fuCurrDpbIdx * fuNrOfGet4PerGdpb) + fuGet4Id;
1029 
1031  gdpbv100::FullMessage fullMess(fvvmEpSupprBuffer[fuCurrDpbIdx][iMsgIdx],
1032  ulCurEpochGdpbGet4);
1033 
1035  switch (messageType) {
1036  case gdpbv100::MSG_HIT: {
1037  ProcessHit(fullMess);
1038  break;
1039  } // case gdpbv100::MSG_HIT:
1040  case gdpbv100::MSG_SLOWC: {
1041  ProcessSlCtrl(fullMess);
1042  break;
1043  } // case gdpbv100::MSG_SLOWC:
1044  case gdpbv100::MSG_SYST: {
1045  ProcessSysMess(fullMess);
1046  break;
1047  } // case gdpbv100::MSG_SYST:
1048  case gdpbv100::MSG_EPOCH:
1049  case gdpbv100::MSG_STAR_TRI_A:
1050  case gdpbv100::MSG_STAR_TRI_B:
1051  case gdpbv100::MSG_STAR_TRI_C:
1052  case gdpbv100::MSG_STAR_TRI_D:
1054  break;
1055  default:
1056  LOG(error) << "Message type " << std::hex << std::setw(2)
1057  << static_cast<uint16_t>(messageType)
1058  << " not included in Get4 unpacker.";
1059  } // switch( mess.getMessageType() )
1060  } // for( Int_t iMsgIdx = 0; iMsgIdx < iBufferSize; iMsgIdx++ )
1061 
1062  fvvmEpSupprBuffer[fuCurrDpbIdx].clear();
1063 }
1064 // -------------------------------------------------------------------------
1065 void CbmMcbm2018UnpackerAlgoTof::ProcessHit(const gdpbv100::FullMessage& mess) {
1066  UInt_t uChannel = mess.getGdpbHitChanId();
1067  UInt_t uTot = mess.getGdpbHit32Tot();
1068 
1069  // In 32b mode the coarse counter is already computed back to 112 FTS bins
1070  // => need to hide its contribution from the Finetime
1071  // => FTS = Fullt TS modulo 112
1072  // UInt_t uFts = mess.getGdpbHitFullTs() % 112;
1073 
1074  UInt_t uChannelNr = fuGet4Id * fuNrOfChannelsPerGet4 + uChannel;
1075  UInt_t uChannelNrInFee =
1076  (fuGet4Id % fuNrOfGet4PerFee) * fuNrOfChannelsPerGet4 + uChannel;
1077  UInt_t uFeeNr = (fuGet4Id / fuNrOfGet4PerFee);
1078  UInt_t uFeeNrInSys = fuCurrDpbIdx * fuNrOfFeePerGdpb + uFeeNr;
1079  UInt_t uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee
1080  + fUnpackPar->Get4ChanToPadiChan(uChannelNrInFee);
1081  // UInt_t uGbtxNr = (uFeeNr / fUnpackPar->GetNrOfFeePerGbtx());
1082  // UInt_t uFeeInGbtx = (uFeeNr % fUnpackPar->GetNrOfFeePerGbtx());
1083  // UInt_t uGbtxNrInSys = fuCurrDpbIdx * fUnpackPar->GetNrOfGbtxPerGdpb() + uGbtxNr;
1084 
1085  // UInt_t uChanInSyst = fuCurrDpbIdx * fuNrOfChannelsPerGdpb + uChannelNr;
1086  UInt_t uRemappedChannelNrInSys =
1087  fuCurrDpbIdx * fuNrOfChannelsPerGdpb + uFeeNr * fuNrOfChannelsPerFee
1088  + fUnpackPar->Get4ChanToPadiChan(uChannelNrInFee);
1090  if (fuDiamondDpbIdx == fuCurrDpbIdx || 0x90 == fuCurrentMsSysId) {
1091  uRemappedChannelNr = uChannelNr;
1092  uRemappedChannelNrInSys =
1093  fuCurrDpbIdx * fUnpackPar->GetNrOfChannelsPerGdpb() + uChannelNr;
1094  } // if( fuDiamondDpbIdx == fuCurrDpbIdx || 0x90 == fuCurrentMsSysId )
1095 
1096  // ULong_t ulHitTime = mess.getMsgFullTime( mess.getExtendedEpoch() );
1097  Double_t dHitTime = mess.GetFullTimeNs();
1098  Double_t dHitTot = uTot; // in bins
1099 
1100  // Histograms filling
1101  if (kTRUE == fbMonitorMode) {
1102  fhRawTotCh[fuCurrDpbIdx]->Fill(uRemappedChannelNr, dHitTot);
1103  fhChCount[fuCurrDpbIdx]->Fill(uChannelNr);
1104  fhChCountRemap[fuCurrDpbIdx]->Fill(uRemappedChannelNr);
1105  } // if( kTRUE == fbMonitorMode )
1106 
1107  /*
1108  if( fUnpackPar->GetNumberOfChannels() < uChanInSyst )
1109  {
1110  LOG(fatal) << "Invalid mapping index " << uChanInSyst
1111  << " VS " << fUnpackPar->GetNumberOfChannels()
1112  <<", from " << fuCurrDpbIdx
1113  <<", " << fuGet4Id
1114  <<", " << uChannel;
1115  return;
1116  } // if( fUnpackPar->GetNumberOfChannels() < uChanUId )
1117 */
1118  if (fviRpcChUId.size() < uRemappedChannelNrInSys) {
1119  LOG(fatal) << "Invalid mapping index " << uRemappedChannelNrInSys << " VS "
1120  << fviRpcChUId.size() << ", from GdpbNr " << fuCurrDpbIdx
1121  << ", Get4 " << fuGet4Id << ", Ch " << uChannel << ", ChNr "
1122  << uChannelNr << ", ChNrIF " << uChannelNrInFee << ", FiS "
1123  << uFeeNrInSys;
1124  return;
1125  } // if( fviRpcChUId.size() < uRemappedChannelNrInSys )
1126 
1127  UInt_t uChanUId = fviRpcChUId[uRemappedChannelNrInSys];
1128  /*
1129  if( 5 == fviRpcType[uGbtxNrInSys] )
1130  LOG(info) << "T0 mapping index " << uRemappedChannelNrInSys
1131  << " UID " << std::hex << std::setw(8) << uChanUId << std::dec
1132  << ", from GdpbNr " << fuCurrDpbIdx
1133  << ", Get4 " << fuGet4Id
1134  << ", Ch " << uChannel
1135  << ", ChNr " << uChannelNr
1136  << ", ChNrIF " << uChannelNrInFee
1137  << ", FiS " << uFeeNrInSys
1138  << ", GBTx " << uGbtxNrInSys;
1139 */
1140  /*
1141  if( 0 == uChanUId ) {
1142  if( 0 < NMappingWarnings-- )
1143  LOG(warning) << "Unused data item at " << uRemappedChannelNrInSys
1144  << ", from GdpbNr " << fuCurrDpbIdx
1145  << ", Get4 " << fuGet4Id
1146  << ", Ch " << uChannel
1147  << ", ChNr " << uChannelNr
1148  << ", ChNrIF " << uChannelNrInFee
1149  << ", FiS " << uFeeNrInSys
1150  ;
1151  return; // Hit not mapped to digi
1152  }
1153 */
1155  if (0x90 != fuCurrentMsSysId) dHitTime -= fdTimeOffsetNs;
1156 
1157  LOG(debug)
1158  << Form("Insert 0x%08x digi with time ", uChanUId) << dHitTime
1159  << Form(", Tot %4.0f", dHitTot)
1160  // << " into buffer with " << fBuffer->GetSize() << " data from "
1161  // << Form("%11.1f to %11.1f ", fBuffer->GetTimeFirst(), fBuffer->GetTimeLast())
1162 
1163  << " at epoch " << mess.getExtendedEpoch();
1164 
1165  // CbmTofDigi digi( uChanUId, dHitTime, dHitTot );
1166  // fDigiVect.emplace_back( digi );
1167  fDigiVect.emplace_back(uChanUId, dHitTime, dHitTot);
1168 }
1169 // -------------------------------------------------------------------------
1170 void CbmMcbm2018UnpackerAlgoTof::ProcessSlCtrl(
1171  const gdpbv100::FullMessage& /*mess*/) {}
1172 // -------------------------------------------------------------------------
1173 void CbmMcbm2018UnpackerAlgoTof::ProcessSysMess(
1174  const gdpbv100::FullMessage& mess) {
1175  switch (mess.getGdpbSysSubType()) {
1176  case gdpbv100::SYS_GET4_ERROR: {
1177  ProcessError(mess);
1178  break;
1179  } // case gdpbv100::SYSMSG_GET4_EVENT
1180  case gdpbv100::SYS_GDPB_UNKWN: {
1181  LOG(debug) << "Unknown GET4 message, data: " << std::hex << std::setw(8)
1182  << mess.getGdpbSysUnkwData() << std::dec
1183  << " Full message: " << std::hex << std::setw(16)
1184  << mess.getData() << std::dec;
1185  break;
1186  } // case gdpbv100::SYS_GDPB_UNKWN:
1187  case gdpbv100::SYS_GET4_SYNC_MISS: {
1188  if (mess.getGdpbSysFwErrResync())
1189  LOG(info) << Form("GET4 Resynchronization: Get4:0x%04x ",
1190  mess.getGdpbGenChipId())
1191  << fuCurrDpbIdx;
1192  else
1193  LOG(info) << "GET4 synchronization pulse missing in gDPB "
1194  << fuCurrDpbIdx;
1195  break;
1196  } // case gdpbv100::SYS_GET4_SYNC_MISS:
1197  case gdpbv100::SYS_PATTERN: {
1198  ProcessPattern(mess);
1199  break;
1200  } // case gdpbv100::SYS_PATTERN:
1201  default: {
1202  LOG(info) << "Crazy system message, subtype " << mess.getGdpbSysSubType();
1203  break;
1204  } // default
1205  } // switch( mess.getGdpbSysSubType() )
1206 }
1207 void CbmMcbm2018UnpackerAlgoTof::ProcessError(
1208  const gdpbv100::FullMessage& mess) {
1209  uint32_t uErrorType = mess.getGdpbSysErrData();
1210 
1211  switch (uErrorType) {
1212  case gdpbv100::GET4_V2X_ERR_READ_INIT:
1213  case gdpbv100::GET4_V2X_ERR_SYNC:
1214  case gdpbv100::GET4_V2X_ERR_EP_CNT_SYNC:
1215  case gdpbv100::GET4_V2X_ERR_EP:
1216  case gdpbv100::GET4_V2X_ERR_FIFO_WRITE:
1217  case gdpbv100::GET4_V2X_ERR_CHAN_STATE:
1218  case gdpbv100::GET4_V2X_ERR_TOK_RING_ST:
1219  case gdpbv100::GET4_V2X_ERR_TOKEN:
1220  case gdpbv100::GET4_V2X_ERR_READOUT_ERR:
1221  case gdpbv100::GET4_V2X_ERR_DLL_LOCK:
1222  case gdpbv100::GET4_V2X_ERR_DLL_RESET:
1224  break;
1225  case gdpbv100::GET4_V2X_ERR_SPI:
1227  break;
1228  case gdpbv100::GET4_V2X_ERR_LOST_EVT:
1229  case gdpbv100::GET4_V2X_ERR_TOT_OVERWRT:
1230  case gdpbv100::GET4_V2X_ERR_TOT_RANGE:
1231  case gdpbv100::GET4_V2X_ERR_EVT_DISCARD:
1232  case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG:
1233  case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL:
1234  case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER:
1236  break;
1237  case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF: break;
1238  case gdpbv100::GET4_V2X_ERR_UNKNOWN:
1240  break;
1241  default:
1243  break;
1244  } // switch( uErrorType )
1245 
1246  return;
1247 }
1248 
1249 void CbmMcbm2018UnpackerAlgoTof::ProcessPattern(
1250  const gdpbv100::FullMessage& mess) {
1251  uint16_t usType = mess.getGdpbSysPattType();
1252  uint16_t usIndex = mess.getGdpbSysPattIndex();
1253  uint32_t uPattern = mess.getGdpbSysPattPattern();
1254 
1255  switch (usType) {
1256  case gdpbv100::PATT_MISSMATCH: {
1257  LOG(debug) << Form(
1258  "Missmatch pattern message => Type %u, Index %2d, Pattern 0x%08X",
1259  usType,
1260  usIndex,
1261  uPattern);
1262  /*
1263  if(usIndex==7) {
1264  TString Tok;
1265  if (bEnableOut) Tok="Ena";
1266  else Tok="Dis";
1267  LOG(DEBUG) << Form( "Mismatch pat in TS %llu, MS %llu, Gdpb %u, T %u, Pattern 0x%08X %08X %08X %08X %08X %08X %08X %08X ",
1268  fulCurrentTsIdx, fulCurrentMsIdx, fuCurrDpbIdx, usType,
1269  pat_mess[0], pat_mess[1], pat_mess[2], pat_mess[3], pat_mess[4], pat_mess[5], pat_mess[6], pat_mess[7] )
1270  << Tok;
1271  }
1272  break;
1273 */
1274  } // case gdpbv100::PATT_MISSMATCH:
1275 
1276  case gdpbv100::PATT_ENABLE: {
1277  LOG(debug2) << Form(
1278  "Enable pattern message => Type %d, Index %2d, Pattern 0x%08X",
1279  usType,
1280  usIndex,
1281  uPattern);
1282  /*
1283  for( UInt_t uBit = 0; uBit < 32; ++uBit )
1284  if( ( uPattern >> uBit ) & 0x1 )
1285  {
1286  fhPatternEnable->Fill( 32 * usIndex + uBit, fuCurrDpbIdx );
1287  fvhGdpbPatternEnableEvo[ fuCurrDpbIdx ]->Fill( fulCurrentTsIndex, 32 * usIndex + uBit );
1288  } // if( ( uPattern >> uBit ) & 0x1 )
1289 */
1290  break;
1291  } // case gdpbv100::PATT_ENABLE:
1292 
1293  case gdpbv100::PATT_RESYNC: {
1294  LOG(debug) << Form(
1295  "RESYNC pattern message => Type %d, Index %2d, Pattern 0x%08X",
1296  usType,
1297  usIndex,
1298  uPattern);
1299 
1300  break;
1301  } // case gdpbv100::PATT_RESYNC:
1302  default: {
1303  LOG(debug) << "Crazy pattern message, subtype " << usType;
1304  break;
1305  } // default
1306  } // switch( usType )
1307  /*
1308  if(usIndex==7) {
1309  bEnableOut=kTRUE;
1310 // for(Int_t iGdpb=0; iGdpb<fUnpackPar->GetNrOfGdpbs(); iGdpb++) {
1311 // bEnableOut &= bGdpbOK[iGdpb];
1312 // }
1313  }
1314 */
1315  return;
1316 }
1317 // -------------------------------------------------------------------------
1318 
1319 Bool_t CbmMcbm2018UnpackerAlgoTof::CreateHistograms() {
1320  std::string sFolder = "Tof_Raw_gDPB";
1321 
1322  LOG(info) << "create Histos for " << fuNrOfGdpbs << " gDPBs ";
1323 
1324  fhRawTDigEvT0 =
1325  new TH1F(Form("Raw_TDig-EvT0"),
1326  Form("Raw digi time difference to 1st digi ; time [ns]; cts"),
1327  500,
1328  0,
1329  100.);
1330 
1331  fhRawTDigRef0 =
1332  new TH1F(Form("Raw_TDig-Ref0"),
1333  Form("Raw digi time difference to Ref ; time [ns]; cts"),
1334  6000,
1335  -10000,
1336  50000);
1337 
1338  fhRawTDigRef =
1339  new TH1F(Form("Raw_TDig-Ref"),
1340  Form("Raw digi time difference to Ref ; time [ns]; cts"),
1341  6000,
1342  -1000,
1343  5000);
1344 
1345  fhRawTRefDig0 =
1346  new TH1F(Form("Raw_TRef-Dig0"),
1347  Form("Raw Ref time difference to last digi ; time [ns]; cts"),
1348  9999,
1349  -50000,
1350  50000);
1351 
1352  fhRawTRefDig1 =
1353  new TH1F(Form("Raw_TRef-Dig1"),
1354  Form("Raw Ref time difference to last digi ; time [ns]; cts"),
1355  9999,
1356  -5000,
1357  5000);
1358 
1359  fhRawDigiLastDigi =
1360  new TH1F(Form("Raw_Digi-LastDigi"),
1361  Form("Raw Digi time difference to last digi ; time [ns]; cts"),
1362  9999,
1363  -5000,
1364  5000);
1365 
1367  AddHistoToVector(fhRawTDigEvT0, sFolder);
1368  AddHistoToVector(fhRawTDigRef0, sFolder);
1369  AddHistoToVector(fhRawTDigRef, sFolder);
1370  AddHistoToVector(fhRawTRefDig0, sFolder);
1371  AddHistoToVector(fhRawTRefDig1, sFolder);
1372  AddHistoToVector(fhRawDigiLastDigi, sFolder);
1373 
1374  fhRawTotCh.resize(fuNrOfGdpbs);
1375  fhChCount.resize(fuNrOfGdpbs);
1376  fhChCountRemap.resize(fuNrOfGdpbs);
1377  fhChanCoinc.resize(fuNrOfGdpbs);
1378  for (UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; uGdpb++) {
1379  fhRawTotCh[uGdpb] =
1380  new TH2F(Form("Raw_Tot_gDPB_%02u", uGdpb),
1381  Form("Raw TOT gDPB %02u; channel; TOT [bin]", uGdpb),
1382  fuNrOfGet4PerGdpb * 4,
1383  0.,
1384  fuNrOfGet4PerGdpb * 4,
1385  256,
1386  0.,
1387  256.);
1388 
1389  fhChCount[uGdpb] =
1390  new TH1I(Form("ChCount_gDPB_%02u", uGdpb),
1391  Form("Channel counts gDPB %02u; channel; Hits", uGdpb),
1392  fuNrOfChannelsPerGdpb,
1393  0.,
1394  fuNrOfChannelsPerGdpb);
1395 
1396  fhChCountRemap[uGdpb] = new TH1I(
1397  Form("ChCountRemap_gDPB_%02u", uGdpb),
1398  Form("Remapped channel counts gDPB %02u; Remapped channel; Hits", uGdpb),
1399  fuNrOfChannelsPerGdpb,
1400  0.,
1401  fuNrOfChannelsPerGdpb);
1402 
1403  fhChanCoinc[uGdpb] =
1404  new TH2F(Form("fhChanCoinc_%02u", uGdpb),
1405  Form("Channels Coincidence %02u; Left; Right", uGdpb),
1406  fuNrOfChannelsPerGdpb,
1407  0.,
1408  fuNrOfChannelsPerGdpb,
1409  fuNrOfChannelsPerGdpb,
1410  0.,
1411  fuNrOfChannelsPerGdpb);
1412 
1414  AddHistoToVector(fhRawTotCh[uGdpb], sFolder);
1415  AddHistoToVector(fhChCount[uGdpb], sFolder);
1416  AddHistoToVector(fhChCountRemap[uGdpb], sFolder);
1417  AddHistoToVector(fhChanCoinc[uGdpb], sFolder);
1418  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; uGdpb ++)
1419 
1420  fhVectorSize =
1421  new TH1I("fhVectorSize",
1422  "Size of the vector VS TS index; TS index; Size [bytes]",
1423  10000,
1424  0.,
1425  10000.);
1426  fhVectorCapacity =
1427  new TH1I("fhVectorCapacity",
1428  "Size of the vector VS TS index; TS index; Size [bytes]",
1429  10000,
1430  0.,
1431  10000.);
1432  AddHistoToVector(fhVectorSize, sFolder);
1433  AddHistoToVector(fhVectorCapacity, sFolder);
1434 
1435  /*
1437  Double_t w = 10;
1438  Double_t h = 10;
1439 
1441  fcEventBuildStats = new TCanvas( "cEvtBuildStats", "Event building statistics", w, h);
1442  if( kTRUE == fbDebugMonitorMode )
1443  fcEventBuildStats->Divide( 2, 3 );
1444  else fcEventBuildStats->Divide( 2, 2 );
1445 
1446  fcEventBuildStats->cd( 1 );
1447  gPad->SetGridx();
1448  gPad->SetGridy();
1449  gPad->SetLogy();
1450  fhEventNbPerTs->Draw();
1451 
1452  fcEventBuildStats->cd( 2 );
1453  gPad->SetGridx();
1454  gPad->SetGridy();
1455  gPad->SetLogy();
1456  fhEventSizeDistribution->Draw();
1457 
1458  fcEventBuildStats->cd( 3 );
1459  gPad->SetGridx();
1460  gPad->SetGridy();
1461  gPad->SetLogy();
1462  fhEventSizeEvolution->Draw();
1463 
1464  fcEventBuildStats->cd( 4 );
1465  gPad->SetGridx();
1466  gPad->SetGridy();
1467  gPad->SetLogy();
1468  fhEventNbEvolution->Draw();
1469 
1470  if( kTRUE == fbDebugMonitorMode )
1471  {
1472  fcEventBuildStats->cd( 5 );
1473  gPad->SetGridx();
1474  gPad->SetGridy();
1475  gPad->SetLogy();
1476  fhEventNbDistributionInTs->Draw();
1477 
1478  fcEventBuildStats->cd( 6 );
1479  gPad->SetGridx();
1480  gPad->SetGridy();
1481  gPad->SetLogy();
1482  fhEventSizeDistributionInTs->Draw();
1483  } // if( kTRUE == fbDebugMonitorMode )
1484 
1485  AddCanvasToVector( fcEventBuildStats, "canvases" );
1486 */
1487  return kTRUE;
1488 }
1489 Bool_t CbmMcbm2018UnpackerAlgoTof::FillHistograms() {
1490  /*
1491  UInt_t uNbEvents = fvEventsBuffer.size();
1492  fhEventNbPerTs->Fill( uNbEvents );
1493 
1494  for( UInt_t uEvent = 0; uEvent < uNbEvents; ++uEvent )
1495  {
1496  UInt_t uEventSize = fvEventsBuffer[ uEvent ].GetEventSize();
1497  Double_t dEventTimeSec = fvEventsBuffer[ uEvent ].GetEventTimeSec();
1498  Double_t dEventTimeMin = dEventTimeSec / 60.0;
1499 
1500  fhEventSizeDistribution->Fill( uEventSize );
1501  fhEventSizeEvolution->Fill( dEventTimeMin, uEventSize );
1502  fhEventNbEvolution->Fill( dEventTimeMin );
1503 
1504  if( kTRUE == fbDebugMonitorMode )
1505  {
1506  Double_t dEventTimeInTs = ( fvEventsBuffer[ uEvent ].GetTrigger().GetFullGdpbTs() * gdpbv100::kdClockCycleSizeNs
1507  - fdTsStartTime ) / 1000.0;
1508 
1509  fhEventNbDistributionInTs->Fill( dEventTimeInTs );
1510  fhEventSizeDistributionInTs->Fill( dEventTimeInTs, uEventSize );
1511  } // if( kTRUE == fbDebugMonitorMode )
1512  } // for( UInt_t uEvent = 0; uEvent < uNbEvents; ++uEvent )
1513 */
1514  return kTRUE;
1515 }
1516 Bool_t CbmMcbm2018UnpackerAlgoTof::ResetHistograms() {
1517  /*
1518  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1519  {
1520  fvhHitsTimeToTriggerRaw[ uGdpb ]->Reset();
1521  fvhHitsTimeToTriggerSel[ uGdpb ]->Reset();
1522 
1523  if( kTRUE == fbDebugMonitorMode )
1524  {
1525  fvhHitsTimeToTriggerSelVsDaq[ uGdpb ]->Reset();
1526  fvhHitsTimeToTriggerSelVsTrig[ uGdpb ]->Reset();
1527  fvhTriggerDt[ uGdpb ]->Reset();
1528  fvhTriggerDistributionInTs[ uGdpb ]->Reset();
1529  fvhTriggerDistributionInMs[ uGdpb ]->Reset();
1530  fvhMessDistributionInMs[ uGdpb ]->Reset();
1531  } // if( kTRUE == fbDebugMonitorMode )
1532  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1533 
1535  fhEventNbPerTs->Reset();
1536  fhEventSizeDistribution->Reset();
1537  fhEventSizeEvolution->Reset();
1538  fhEventNbEvolution->Reset();
1539 
1540  if( kTRUE == fbDebugMonitorMode )
1541  {
1542  fhEventNbDistributionInTs->Reset();
1543  fhEventSizeDistributionInTs->Reset();
1544  fhRawTriggersStats->Reset();
1545  fhMissingTriggersEvolution->Reset();
1546  } // if( kTRUE == fbDebugMonitorMode )
1547 */
1548  return kTRUE;
1549 }
1550 // -------------------------------------------------------------------------
gdpbv100::Message::getStarTrigCmdStarD
uint32_t getStarTrigCmdStarD() const
Definition: gDpbMessv100.h:278
CbmMcbm2018UnpackerAlgoTof::fUnpackPar
CbmMcbm2018TofPar * fUnpackPar
Settings from parameter file.
Definition: CbmMcbm2018UnpackerAlgoTof.h:84
CbmMcbm2018UnpackerAlgoTof::fhChCount
std::vector< TH1 * > fhChCount
Definition: CbmMcbm2018UnpackerAlgoTof.h:176
gdpbv100::MSG_STAR_TRI_A
@ MSG_STAR_TRI_A
Definition: gDpbMessv100.h:63
CbmMcbm2018TofPar::GetNrOfChannelsPerGdpb
static constexpr UInt_t GetNrOfChannelsPerGdpb()
Definition: CbmMcbm2018TofPar.h:55
gdpbv100::Message
Definition: gDpbMessv100.h:133
CbmMcbm2018UnpackerAlgoTof::InitParameters
Bool_t InitParameters()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:164
CbmMcbm2018UnpackerAlgoTof::fdTsStopTimeCore
Double_t fdTsStopTimeCore
Time in ns of current TS from the index of the first MS first component.
Definition: CbmMcbm2018UnpackerAlgoTof.h:120
gdpbv100::FormatHexPrintout
std::string FormatHexPrintout(uint64_t ulVal, char cFill=0, uint uWidth=0, bool bUppercase=false)
Definition: gDpbMessv100.cxx:30
CbmMcbm2018UnpackerAlgoTof::fvulGdpbTsFullLast
std::vector< ULong64_t > fvulGdpbTsFullLast
Definition: CbmMcbm2018UnpackerAlgoTof.h:158
CbmFormatDecHexPrintout.h
gdpbv100::Message::getGdpbTsMsbStarA
uint64_t getGdpbTsMsbStarA() const
Definition: gDpbMessv100.h:266
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
gdpbv100::FullMessage::GetFullTimeNs
double GetFullTimeNs() const
Definition: gDpbMessv100.h:395
CbmMcbm2018UnpackerAlgoTof::fviModuleId
std::vector< Int_t > fviModuleId
Definition: CbmMcbm2018UnpackerAlgoTof.h:101
CbmMcbm2018UnpackerAlgoTof::ProcessStarTrigger
void ProcessStarTrigger(const gdpbv100::Message &mess)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:901
CbmMcbm2018TofPar::ElinkIdxToGet4Idx
Int_t ElinkIdxToGet4Idx(UInt_t uElink)
Definition: CbmMcbm2018TofPar.cxx:172
gdpbv100::GET4_V2X_ERR_TOT_OVERWRT
@ GET4_V2X_ERR_TOT_OVERWRT
Definition: gDpbMessv100.h:121
CbmStar2019Algo< CbmTofDigi >::fuNbMsLoop
size_t fuNbMsLoop
Definition: CbmStar2019Algo.h:114
CbmMcbm2018UnpackerAlgoTof::fbMonitorMode
Bool_t fbMonitorMode
Control flags.
Definition: CbmMcbm2018UnpackerAlgoTof.h:78
CbmMcbm2018TofPar::GetGdpbId
Int_t GetGdpbId(Int_t i)
Definition: CbmMcbm2018TofPar.h:67
CbmMcbm2018TofPar.h
CbmMcbm2018UnpackerAlgoTof::CbmMcbm2018UnpackerAlgoTof
CbmMcbm2018UnpackerAlgoTof()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:42
gdpbv100::SYS_GET4_ERROR
@ SYS_GET4_ERROR
Definition: gDpbMessv100.h:70
CbmMcbm2018UnpackerAlgoTof::Finish
virtual void Finish()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:128
CbmMcbm2018UnpackerAlgoTof::fhRawTotCh
std::vector< TH2 * > fhRawTotCh
Definition: CbmMcbm2018UnpackerAlgoTof.h:175
gdpbv100::MSG_HIT
@ MSG_HIT
Definition: gDpbMessv100.h:59
CbmMcbm2018UnpackerAlgoTof::ProcessEndOfMsEpoch
void ProcessEndOfMsEpoch()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:873
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
gdpbv100::Message::getGdpbSysPattType
uint16_t getGdpbSysPattType() const
Definition: gDpbMessv100.h:259
gdpbv100::MSG_SLOWC
@ MSG_SLOWC
Definition: gDpbMessv100.h:61
CbmStar2019Algo< CbmTofDigi >::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmStar2019Algo.h:113
CbmMcbm2018UnpackerAlgoTof::ProcessEpoch
void ProcessEpoch(const gdpbv100::Message &mess, uint32_t uMesgIdx)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:818
CbmMcbm2018UnpackerAlgoTof::fhRawTDigEvT0
TH1 * fhRawTDigEvT0
Definition: CbmMcbm2018UnpackerAlgoTof.h:169
gdpbv100::FullMessage::getExtendedEpoch
uint64_t getExtendedEpoch() const
Definition: gDpbMessv100.h:393
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
CbmMcbm2018TofPar::GetNrOfChannelsPerFee
static constexpr UInt_t GetNrOfChannelsPerFee()
Definition: CbmMcbm2018TofPar.h:51
CbmStar2019Algo< CbmTofDigi >::AddHistoToVector
void AddHistoToVector(TNamed *pointer, std::string sFolder="")
For monitor algos.
Definition: CbmStar2019Algo.h:80
gdpbv100::Message::getGdpbSysSubType
uint16_t getGdpbSysSubType() const
Definition: gDpbMessv100.h:245
CbmMcbm2018UnpackerAlgoTof::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:137
CbmStar2019Algo< CbmTofDigi >::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmStar2019Algo.h:112
CbmMcbm2018UnpackerAlgoTof::fvulStarTsFullLast
std::vector< ULong64_t > fvulStarTsFullLast
Definition: CbmMcbm2018UnpackerAlgoTof.h:159
CbmMcbm2018TofPar::GetNrOfFeePerGbtx
static constexpr UInt_t GetNrOfFeePerGbtx()
Definition: CbmMcbm2018TofPar.h:49
CbmMcbm2018UnpackerAlgoTof::fvulStarTsMid
std::vector< ULong64_t > fvulStarTsMid
Definition: CbmMcbm2018UnpackerAlgoTof.h:157
gdpbv100::GET4_V2X_ERR_TOKEN
@ GET4_V2X_ERR_TOKEN
Definition: gDpbMessv100.h:116
CbmMcbm2018UnpackerAlgoTof::fuNrOfChannelsPerGet4
UInt_t fuNrOfChannelsPerGet4
Number of GET4s per FEE.
Definition: CbmMcbm2018UnpackerAlgoTof.h:90
CbmMcbm2018UnpackerAlgoTof.h
gdpbv100::GET4_V2X_ERR_CHAN_STATE
@ GET4_V2X_ERR_CHAN_STATE
Definition: gDpbMessv100.h:114
CbmMcbm2018TofPar::GetNrOfGbtx
Int_t GetNrOfGbtx()
Definition: CbmMcbm2018TofPar.h:72
gdpbv100::kuEpochCounterSz
const uint32_t kuEpochCounterSz
Definition: gDpbMessv100.h:40
CbmMcbm2018UnpackerAlgoTof::fhVectorCapacity
TH1 * fhVectorCapacity
Definition: CbmMcbm2018UnpackerAlgoTof.h:189
CbmStar2019Algo< CbmTofDigi >::fdTsFullSizeInNs
Double_t fdTsFullSizeInNs
Total size of the core MS in a TS, [nanoseconds].
Definition: CbmStar2019Algo.h:121
gdpbv100::Message::getGdpbSysErrData
uint16_t getGdpbSysErrData() const
Definition: gDpbMessv100.h:253
CbmStar2019Algo< CbmTofDigi >::fParCList
TList * fParCList
Parameter management.
Definition: CbmStar2019Algo.h:108
CbmMcbm2018UnpackerAlgoTof::fuNrOfChannelsPerFee
UInt_t fuNrOfChannelsPerFee
Number of channels in each GET4.
Definition: CbmMcbm2018UnpackerAlgoTof.h:91
gdpbv100::Message::getGdpbSysPattIndex
uint16_t getGdpbSysPattIndex() const
Definition: gDpbMessv100.h:260
CbmMcbm2018UnpackerAlgoTof::fuGet4Nr
UInt_t fuGet4Nr
running number (0 to fuNrOfGet4PerGdpb) of the Get4 chip of a unique GDPB for current message
Definition: CbmMcbm2018UnpackerAlgoTof.h:134
CbmMcbm2018UnpackerAlgoTof::fuNrOfGet4PerFee
UInt_t fuNrOfGet4PerFee
Number of FEBs per GDPB.
Definition: CbmMcbm2018UnpackerAlgoTof.h:89
CbmMcbm2018UnpackerAlgoTof::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Definition: CbmMcbm2018UnpackerAlgoTof.h:114
CbmStar2019Algo< CbmTofDigi >::fvMsComponentsList
std::vector< size_t > fvMsComponentsList
Parameters related to FLES containers.
Definition: CbmStar2019Algo.h:111
CbmMcbm2018UnpackerAlgoTof::fuGet4Id
UInt_t fuGet4Id
Index of the DPB from which the MS currently unpacked is coming.
Definition: CbmMcbm2018UnpackerAlgoTof.h:132
gdpbv100::GET4_V2X_ERR_DLL_LOCK
@ GET4_V2X_ERR_DLL_LOCK
Definition: gDpbMessv100.h:119
gdpbv100::GET4_V2X_ERR_FIFO_WRITE
@ GET4_V2X_ERR_FIFO_WRITE
Definition: gDpbMessv100.h:112
CbmMcbm2018UnpackerAlgoTof::fvulCurrentEpoch
std::vector< ULong64_t > fvulCurrentEpoch
Data format control: Current time references for each GDPB: merged epoch marker, epoch cycle,...
Definition: CbmMcbm2018UnpackerAlgoTof.h:136
CbmTofDetectorId_v14a.h
CbmMcbm2018UnpackerAlgoTof::FillHistograms
Bool_t FillHistograms()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1489
gdpbv100::Message::getStarTsLsbStarD
uint64_t getStarTsLsbStarD() const
Definition: gDpbMessv100.h:273
CbmMcbm2018TofPar::GetNrOfGdpbs
Int_t GetNrOfGdpbs()
FIXME: replace with method returning the correspondign constants! see Star2019 parameter.
Definition: CbmMcbm2018TofPar.h:66
gdpbv100::PATT_MISSMATCH
@ PATT_MISSMATCH
Definition: gDpbMessv100.h:81
gdpbv100::GET4_V2X_ERR_UNKNOWN
@ GET4_V2X_ERR_UNKNOWN
Definition: gDpbMessv100.h:130
CbmMcbm2018UnpackerAlgoTof::fvuStarTokenLast
std::vector< UInt_t > fvuStarTokenLast
Definition: CbmMcbm2018UnpackerAlgoTof.h:160
CbmMcbm2018UnpackerAlgoTof::ProcessError
void ProcessError(const gdpbv100::FullMessage &mess)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1207
CbmMcbm2018UnpackerAlgoTof::fhChanCoinc
std::vector< TH2 * > fhChanCoinc
Definition: CbmMcbm2018UnpackerAlgoTof.h:179
CbmMcbm2018UnpackerAlgoTof::ProcessPattern
void ProcessPattern(const gdpbv100::FullMessage &mess)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1249
TrbNetState::DEBUG
@ DEBUG
gdpbv100::MSG_STAR_TRI_C
@ MSG_STAR_TRI_C
Definition: gDpbMessv100.h:65
gdpbv100::Message::getGdpbSysFwErrResync
uint32_t getGdpbSysFwErrResync() const
Definition: gDpbMessv100.h:257
gdpbv100::PATT_RESYNC
@ PATT_RESYNC
Definition: gDpbMessv100.h:83
CbmMcbm2018UnpackerAlgoTof::fuNrOfGbtx
UInt_t fuNrOfGbtx
Definition: CbmMcbm2018UnpackerAlgoTof.h:96
gdpbv100::GET4_V2X_ERR_EP
@ GET4_V2X_ERR_EP
Definition: gDpbMessv100.h:111
gdpbv100::Message::getData
uint64_t getData() const
Definition: gDpbMessv100.h:156
CbmMcbm2018UnpackerAlgoTof::Reset
virtual void Reset()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:127
CbmMcbm2018UnpackerAlgoTof::ResetHistograms
Bool_t ResetHistograms()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1516
CbmMcbm2018UnpackerAlgoTof::fhRawTRefDig0
TH1 * fhRawTRefDig0
Definition: CbmMcbm2018UnpackerAlgoTof.h:172
gdpbv100::GET4_V2X_ERR_SYNC
@ GET4_V2X_ERR_SYNC
Definition: gDpbMessv100.h:109
CbmMcbm2018UnpackerAlgoTof::fvulStarTsMsb
std::vector< ULong64_t > fvulStarTsMsb
Definition: CbmMcbm2018UnpackerAlgoTof.h:156
gdpbv100::GET4_V2X_ERR_EP_CNT_SYNC
@ GET4_V2X_ERR_EP_CNT_SYNC
Definition: gDpbMessv100.h:110
CbmMcbm2018TofPar::GetNrOfRpc
Int_t GetNrOfRpc(Int_t i)
Definition: CbmMcbm2018TofPar.h:74
CbmMcbm2018UnpackerAlgoTof::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018UnpackerAlgoTof.h:128
CbmStar2019Algo
Definition: CbmStar2019Algo.h:43
CbmMcbm2018UnpackerAlgoTof::fvulCurrentEpochFull
std::vector< ULong64_t > fvulCurrentEpochFull
Epoch cycle from the Ms Start message and Epoch counter flip.
Definition: CbmMcbm2018UnpackerAlgoTof.h:139
gdpbv100::GET4_V2X_ERR_SEQUENCE_ER
@ GET4_V2X_ERR_SEQUENCE_ER
Definition: gDpbMessv100.h:127
gdpbv100::Message::getGdpbTsLsbStarB
uint64_t getGdpbTsLsbStarB() const
Definition: gDpbMessv100.h:268
gdpbv100::Message::getStarTrigMsgIndex
uint16_t getStarTrigMsgIndex() const
Definition: gDpbMessv100.h:264
CbmMcbm2018UnpackerAlgoTof::fuNrOfChannelsPerGdpb
UInt_t fuNrOfChannelsPerGdpb
Number of GET4s per GDPB.
Definition: CbmMcbm2018UnpackerAlgoTof.h:94
gdpbv100::GET4_V2X_ERR_TOK_RING_ST
@ GET4_V2X_ERR_TOK_RING_ST
Definition: gDpbMessv100.h:115
CbmMcbm2018UnpackerAlgoTof::fuTsMaxVectorSize
size_t fuTsMaxVectorSize
Definition: CbmMcbm2018UnpackerAlgoTof.h:190
CbmMcbm2018UnpackerAlgoTof::fuMsIndex
UInt_t fuMsIndex
Start Time in ns of current MS from its index field in header.
Definition: CbmMcbm2018UnpackerAlgoTof.h:123
CbmStar2019Algo< CbmTofDigi >::fdTsCoreSizeInNs
Double_t fdTsCoreSizeInNs
Size of a single MS, [nanoseconds].
Definition: CbmStar2019Algo.h:119
CbmMcbm2018UnpackerAlgoTof::fvulGdpbTsLsb
std::vector< ULong64_t > fvulGdpbTsLsb
Definition: CbmMcbm2018UnpackerAlgoTof.h:155
CbmTofAddress.h
CbmMcbm2018UnpackerAlgoTof::fdCapacityIncFactor
Double_t fdCapacityIncFactor
Definition: CbmMcbm2018UnpackerAlgoTof.h:191
CbmMcbm2018UnpackerAlgoTof::fvvmEpSupprBuffer
std::vector< std::vector< gdpbv100::Message > > fvvmEpSupprBuffer
Buffers.
Definition: CbmMcbm2018UnpackerAlgoTof.h:151
gdpbv100::kuChipIdMergedEpoch
const uint32_t kuChipIdMergedEpoch
Definition: gDpbMessv100.h:51
gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG
@ GET4_V2X_ERR_ADD_RIS_EDG
Definition: gDpbMessv100.h:125
CbmMcbm2018UnpackerAlgoTof::ProcessSlCtrl
void ProcessSlCtrl(const gdpbv100::FullMessage &mess)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1170
CbmMcbm2018UnpackerAlgoTof::ProcessMs
Bool_t ProcessMs(const fles::Timeslice &ts, size_t uMsCompIdx, size_t uMsIdx)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:615
CbmMcbm2018UnpackerAlgoTof::Init
virtual Bool_t Init()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:122
CbmStar2019Algo< CbmTofDigi >::fDigiVect
std::vector< CbmTofDigi > fDigiVect
Vector of pointers to canvases + optional folder name.
Definition: CbmStar2019Algo.h:140
CbmMcbm2018UnpackerAlgoTof::fdTsStartTime
Double_t fdTsStartTime
SysId of the current MS in TS (0 to fuTotalMsNb)
Definition: CbmMcbm2018UnpackerAlgoTof.h:118
CbmMcbm2018UnpackerAlgoTof::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:144
gdpbv100::MSG_SYST
@ MSG_SYST
Definition: gDpbMessv100.h:62
CbmMcbm2018TofPar::GetModuleId
Int_t GetModuleId(Int_t i)
Definition: CbmMcbm2018TofPar.h:77
CbmMcbm2018UnpackerAlgoTof::ProcessEpSupprBuffer
void ProcessEpSupprBuffer()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:999
CbmMcbm2018UnpackerAlgoTof::fhChCountRemap
std::vector< TH1 * > fhChCountRemap
Definition: CbmMcbm2018UnpackerAlgoTof.h:177
CbmMcbm2018UnpackerAlgoTof::fviRpcSide
std::vector< Int_t > fviRpcSide
Definition: CbmMcbm2018UnpackerAlgoTof.h:100
CbmTofDigi
Data class for expanded digital TOF information.
Definition: CbmTofDigi.h:38
CbmMcbm2018UnpackerAlgoTof::fhVectorSize
TH1 * fhVectorSize
Definition: CbmMcbm2018UnpackerAlgoTof.h:188
gdpbv100::Message::getStarTsMidStarC
uint64_t getStarTsMidStarC() const
Definition: gDpbMessv100.h:271
CbmMcbm2018UnpackerAlgoTof::ProcessHit
void ProcessHit(const gdpbv100::FullMessage &mess)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1065
CbmMcbm2018UnpackerAlgoTof::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Definition: CbmMcbm2018UnpackerAlgoTof.h:126
gdpbv100::GET4_V2X_ERR_TOT_RANGE
@ GET4_V2X_ERR_TOT_RANGE
Definition: gDpbMessv100.h:123
FormatMsHeaderPrintout
std::string FormatMsHeaderPrintout(const fles::MicrosliceDescriptor &msDescriptor)
Definition: CbmFormatMsHeaderPrintout.cxx:5
gdpbv100::GET4_V2X_ERR_DLL_RESET
@ GET4_V2X_ERR_DLL_RESET
Definition: gDpbMessv100.h:120
gdpbv100::GET4_V2X_ERR_SPI
@ GET4_V2X_ERR_SPI
Definition: gDpbMessv100.h:118
CbmMcbm2018UnpackerAlgoTof::fhRawTDigRef0
TH1 * fhRawTDigRef0
Definition: CbmMcbm2018UnpackerAlgoTof.h:170
gdpbv100::GET4_V2X_ERR_READ_INIT
@ GET4_V2X_ERR_READ_INIT
Definition: gDpbMessv100.h:108
gdpbv100::Message::getGdpbSysPattPattern
uint32_t getGdpbSysPattPattern() const
Definition: gDpbMessv100.h:261
CbmMcbm2018UnpackerAlgoTof::fhRawTRefDig1
TH1 * fhRawTRefDig1
Definition: CbmMcbm2018UnpackerAlgoTof.h:173
CbmMcbm2018UnpackerAlgoTof::ProcessTs
Bool_t ProcessTs(const fles::Timeslice &ts)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:535
CbmMcbm2018UnpackerAlgoTof::fuNrOfGdpbs
UInt_t fuNrOfGdpbs
Definition: CbmMcbm2018UnpackerAlgoTof.h:86
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
CbmMcbm2018TofPar::GetRpcType
Int_t GetRpcType(Int_t i)
Definition: CbmMcbm2018TofPar.h:75
gdpbv100::Message::getGdpbSysUnkwData
uint32_t getGdpbSysUnkwData() const
Definition: gDpbMessv100.h:255
CbmMcbm2018UnpackerAlgoTof::fvbMaskedComponents
std::vector< Bool_t > fvbMaskedComponents
Switch ON the filling of a additional set of histograms.
Definition: CbmMcbm2018UnpackerAlgoTof.h:81
gdpbv100::GET4_V2X_ERR_LOST_EVT
@ GET4_V2X_ERR_LOST_EVT
Definition: gDpbMessv100.h:113
CbmMcbm2018UnpackerAlgoTof::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Idx of the current TS.
Definition: CbmMcbm2018UnpackerAlgoTof.h:115
gdpbv100::kulEpochCycleFieldSz
const uint64_t kulEpochCycleFieldSz
Definition: gDpbMessv100.h:49
CbmMcbm2018UnpackerAlgoTof::fuNrOfFeePerGdpb
UInt_t fuNrOfFeePerGdpb
gDPB ID to index map
Definition: CbmMcbm2018UnpackerAlgoTof.h:88
CbmMcbm2018UnpackerAlgoTof::fvulGdpbTsMsb
std::vector< ULong64_t > fvulGdpbTsMsb
[DPB], FIXME: dimension to be removed as not needed with real MS
Definition: CbmMcbm2018UnpackerAlgoTof.h:154
gdpbv100::Message::getGdpbGenChipId
uint16_t getGdpbGenChipId() const
Definition: gDpbMessv100.h:214
CbmMcbm2018UnpackerAlgoTof::ProcessEpochCycle
void ProcessEpochCycle(const uint64_t &ulCycleData)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:792
gdpbv100::GET4_V2X_ERR_READOUT_ERR
@ GET4_V2X_ERR_READOUT_ERR
Definition: gDpbMessv100.h:117
CbmMcbm2018UnpackerAlgoTof::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition: CbmMcbm2018UnpackerAlgoTof.h:130
gdpbv100::MSG_STAR_TRI_B
@ MSG_STAR_TRI_B
Definition: gDpbMessv100.h:64
gdpbv100::SYS_PATTERN
@ SYS_PATTERN
Definition: gDpbMessv100.h:76
CbmMcbm2018UnpackerAlgoTof::CreateHistograms
Bool_t CreateHistograms()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1319
CbmMcbm2018UnpackerAlgoTof::fuDiamondDpbIdx
UInt_t fuDiamondDpbIdx
Definition: CbmMcbm2018UnpackerAlgoTof.h:106
CbmMcbm2018UnpackerAlgoTof::fviNrOfRpc
std::vector< Int_t > fviNrOfRpc
Definition: CbmMcbm2018UnpackerAlgoTof.h:98
gdpbv100::FullMessage
Definition: gDpbMessv100.h:362
CbmMcbm2018UnpackerAlgoTof::~CbmMcbm2018UnpackerAlgoTof
~CbmMcbm2018UnpackerAlgoTof()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:112
CbmMcbm2018TofPar::GetRpcSide
Int_t GetRpcSide(Int_t i)
Definition: CbmMcbm2018TofPar.h:76
CbmMcbm2018UnpackerAlgoTof::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:520
CbmTofAddress::GetUniqueAddress
static UInt_t GetUniqueAddress(UInt_t Sm, UInt_t Rpc, UInt_t Channel, UInt_t Side=0, UInt_t SmType=0)
Definition: CbmTofAddress.h:124
CbmMcbm2018TofPar::Get4ChanToPadiChan
Int_t Get4ChanToPadiChan(UInt_t uChannelInFee)
Definition: CbmMcbm2018TofPar.cxx:147
CbmMcbm2018UnpackerAlgoTof::fuNrOfGet4
UInt_t fuNrOfGet4
Number of channels in each FEE.
Definition: CbmMcbm2018UnpackerAlgoTof.h:92
gdpbv100::Message::getStarTokenStarD
uint32_t getStarTokenStarD() const
Definition: gDpbMessv100.h:280
CbmMcbm2018UnpackerAlgoTof::fvuStarTrigCmdLast
std::vector< UInt_t > fvuStarTrigCmdLast
Definition: CbmMcbm2018UnpackerAlgoTof.h:162
gdpbv100::Message::getStarTsMsbStarB
uint64_t getStarTsMsbStarB() const
Definition: gDpbMessv100.h:269
CbmMcbm2018UnpackerAlgoTof::fviRpcType
std::vector< Int_t > fviRpcType
Definition: CbmMcbm2018UnpackerAlgoTof.h:99
CbmMcbm2018UnpackerAlgoTof::fvulCurrentEpochCycle
std::vector< ULong64_t > fvulCurrentEpochCycle
Current epoch index, per DPB.
Definition: CbmMcbm2018UnpackerAlgoTof.h:138
gdpbv100::Message::getGdpbHitChanId
uint16_t getGdpbHitChanId() const
Definition: gDpbMessv100.h:219
CbmMcbm2018UnpackerAlgoTof::fvuStarDaqCmdLast
std::vector< UInt_t > fvuStarDaqCmdLast
Definition: CbmMcbm2018UnpackerAlgoTof.h:161
CbmMcbm2018UnpackerAlgoTof::fGdpbIdIndexMap
std::map< UInt_t, UInt_t > fGdpbIdIndexMap
Total number of GDPBs in the system.
Definition: CbmMcbm2018UnpackerAlgoTof.h:87
CbmMcbm2018UnpackerAlgoTof::fuNrOfGet4PerGdpb
UInt_t fuNrOfGet4PerGdpb
Total number of Get4 chips in the system.
Definition: CbmMcbm2018UnpackerAlgoTof.h:93
CbmMcbm2018UnpackerAlgoTof::fdTimeOffsetNs
Double_t fdTimeOffsetNs
User settings: Data correction parameters.
Definition: CbmMcbm2018UnpackerAlgoTof.h:105
gdpbv100::PATT_ENABLE
@ PATT_ENABLE
Definition: gDpbMessv100.h:82
CbmMcbm2018TofPar::GetNrOfGet4PerFee
Int_t GetNrOfGet4PerFee()
Definition: CbmMcbm2018TofPar.h:69
CbmMcbm2018UnpackerAlgoTof::GetParList
TList * GetParList()
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:157
gdpbv100::GET4_V2X_ERR_UNPAIR_FALL
@ GET4_V2X_ERR_UNPAIR_FALL
Definition: gDpbMessv100.h:126
gdpbv100::SYS_GET4_SYNC_MISS
@ SYS_GET4_SYNC_MISS
Definition: gDpbMessv100.h:73
CbmMcbm2018UnpackerAlgoTof::fhRawDigiLastDigi
TH1 * fhRawDigiLastDigi
Definition: CbmMcbm2018UnpackerAlgoTof.h:174
CbmMcbm2018UnpackerAlgoTof::fhRawTDigRef
TH1 * fhRawTDigRef
Definition: CbmMcbm2018UnpackerAlgoTof.h:171
CbmStar2019Algo< CbmTofDigi >::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmStar2019Algo.h:116
CbmMcbm2018UnpackerAlgoTof::fviRpcChUId
std::vector< Int_t > fviRpcChUId
Definition: CbmMcbm2018UnpackerAlgoTof.h:102
gdpbv100::Message::getGdpbHit32Tot
uint16_t getGdpbHit32Tot() const
Definition: gDpbMessv100.h:227
CbmFormatMsHeaderPrintout.h
CbmMcbm2018TofPar::GetNrOfFeesPerGdpb
Int_t GetNrOfFeesPerGdpb()
Definition: CbmMcbm2018TofPar.h:68
gdpbv100::GET4_V2X_ERR_EVT_DISCARD
@ GET4_V2X_ERR_EVT_DISCARD
Definition: gDpbMessv100.h:124
gdpbv100::Message::getStarDaqCmdStarD
uint32_t getStarDaqCmdStarD() const
Definition: gDpbMessv100.h:279
gdpbv100::GET4_V2X_ERR_EPOCH_OVERF
@ GET4_V2X_ERR_EPOCH_OVERF
Definition: gDpbMessv100.h:128
CbmMcbm2018UnpackerAlgoTof::ProcessSysMess
void ProcessSysMess(const gdpbv100::FullMessage &mess)
Definition: CbmMcbm2018UnpackerAlgoTof.cxx:1173
CbmMcbm2018UnpackerAlgoTof::fuCurrentMsSysId
size_t fuCurrentMsSysId
Idx of the current MS in TS (0 to fuTotalMsNb)
Definition: CbmMcbm2018UnpackerAlgoTof.h:116
gdpbv100::SYS_GDPB_UNKWN
@ SYS_GDPB_UNKWN
Definition: gDpbMessv100.h:71